Browse Source

Remove obsolete mk/pw

* mk/pw: Remove.
Tim Landscheidt 1 year ago
parent
commit
db6da387ae
1 changed files with 0 additions and 664 deletions
  1. 0 664
      mk/pw

+ 0 - 664
mk/pw

@@ -1,664 +0,0 @@
-#!/usr/bin/env python
-#
-# Patchwork command line client
-# Copyright (C) 2008, 2013 Nate Case <ncase@xes-inc.com>
-#
-# This file is part of the Patchwork package.
-#
-# Patchwork is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# Patchwork is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Patchwork; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-import os
-import sys
-import xmlrpclib
-import getopt
-import string
-import tempfile
-import subprocess
-import base64
-import ConfigParser
-import datetime
-import smtplib
-import urllib
-import re
-
-from email.mime.text import MIMEText
-
-notify_on_state_change = {
-    'accepted':          'emacs-orgmode@gnu.org',
-    'rejected':          'emacs-orgmode@gnu.org',
-    'changes requested': 'emacs-orgmode@gnu.org',
-    'rfc':               'emacs-orgmode@gnu.org'
-}
-
-# Default Patchwork remote XML-RPC server URL
-# This script will check the PW_XMLRPC_URL environment variable
-# for the URL to access.  If that is unspecified, it will fallback to
-# the hardcoded default value specified here.
-DEFAULT_URL = "http://patchwork.newartisans.com/xmlrpc/"
-CONFIG_FILES = [os.path.expanduser('~/.pwclientrc')]
-
-class Filter:
-    """Filter for selecting patches."""
-    def __init__(self):
-        # These fields refer to specific objects, so they are special
-        # because we have to resolve them to IDs before passing the
-        # filter to the server
-        self.state = ""
-        self.project = ""
-
-        # The dictionary that gets passed to via XML-RPC
-        self.d = {}
-
-    def add(self, field, value):
-        if field == 'state':
-            self.state = value
-        elif field == 'project':
-            self.project = value
-        else:
-            # OK to add directly
-            self.d[field] = value
-
-    def resolve_ids(self, rpc):
-        """Resolve State, Project, and Person IDs based on filter strings."""
-        if self.state != "":
-            id = state_id_by_name(rpc, self.state)
-            if id == 0:
-                sys.stderr.write("Note: No State found matching %s*, " \
-                                 "ignoring filter\n" % self.state)
-            else:
-                self.d['state_id'] = id
-
-        if self.project != "":
-            id = project_id_by_name(rpc, self.project)
-            if id == 0:
-                sys.stderr.write("Note: No Project found matching %s, " \
-                                 "ignoring filter\n" % self.project)
-            else:
-                self.d['project_id'] = id
-
-    def __str__(self):
-        """Return human-readable description of the filter."""
-        return str(self.d)
-
-class BasicHTTPAuthTransport(xmlrpclib.SafeTransport):
-
-    def __init__(self, username = None, password = None, use_https = False):
-        self.username = username
-        self.password = password
-        self.use_https = use_https
-        xmlrpclib.SafeTransport.__init__(self)
-
-    def authenticated(self):
-        return self.username != None and self.password != None
-
-    def send_host(self, connection, host):
-        xmlrpclib.Transport.send_host(self, connection, host)
-        if not self.authenticated():
-            return
-        credentials = '%s:%s' % (self.username, self.password)
-        auth = 'Basic ' + base64.encodestring(credentials).strip()
-        connection.putheader('Authorization', auth)
-
-    def make_connection(self, host):
-        if self.use_https:
-            fn = xmlrpclib.SafeTransport.make_connection
-        else:
-            fn = xmlrpclib.Transport.make_connection
-        return fn(self, host)
-
-def usage():
-    sys.stderr.write("Usage: %s <action> [options]\n\n" % \
-                        (os.path.basename(sys.argv[0])))
-    sys.stderr.write("Where <action> is one of:\n")
-    sys.stderr.write(
-"""        apply <ID>    : Apply a patch (in the current dir, using -p1)
-        get <ID>      : Download a patch and save it locally
-        projects      : List all projects
-        states        : Show list of potential patch states
-        list [str]    : List patches, using the optional filters specified
-                        below and an optional substring to search for patches
-                        by name
-        search [str]  : Same as 'list'
-        view <ID>     : View a patch
-        show <ID>     : Same as view
-        update [-s state] [-c commit-ref] [-m email-comment] <ID>
-                      : Update patch, send mail to mailing list if appropriate
-        branch <ID>   : Create a topic branch t/patchNNN for this patch
-                      :  and update it to the current master
-        merge [-m email-comment] <ID>
-                      : Merge the t/patchNNN topic branch into master
-\n""")
-    sys.stderr.write("""\nFilter options for 'list' and 'search':
-        -s <state>    : Filter by patch state (e.g., 'New', 'Accepted', etc.)
-        -p <project>  : Filter by project name (see 'projects' for list)
-        -w <who>      : Filter by submitter (name, e-mail substring search)
-        -d <who>      : Filter by delegate (name, e-mail substring search)
-        -n <max #>    : Restrict number of results\n""")
-    sys.stderr.write("""\nActions that take an ID argument can also be \
-invoked with:
-        -h <hash>     : Lookup by patch hash\n""")
-    sys.exit(1)
-
-def project_id_by_name(rpc, linkname):
-    """Given a project short name, look up the Project ID."""
-    if len(linkname) == 0:
-        return 0
-    projects = rpc.project_list(linkname, 0)
-    for project in projects:
-        if project['linkname'] == linkname:
-            return project['id']
-    return 0
-
-def state_id_by_name(rpc, name):
-    """Given a partial state name, look up the state ID."""
-    if len(name) == 0:
-        return 0
-    states = rpc.state_list(name, 0)
-    for state in states:
-        if state['name'].lower().startswith(name.lower()):
-            return state['id']
-    return 0
-
-def person_ids_by_name(rpc, name):
-    """Given a partial name or email address, return a list of the
-    person IDs that match."""
-    if len(name) == 0:
-        return []
-    people = rpc.person_list(name, 0)
-    return map(lambda x: x['id'], people)
-
-def list_patches(patches):
-    """Dump a list of patches to stdout."""
-    print("%-5s %-12s %s" % ("ID", "State", "Name"))
-    print("%-5s %-12s %s" % ("--", "-----", "----"))
-    for patch in patches:
-        print("%-5d %-12s %s" % (patch['id'], patch['state'], patch['name']))
-
-def action_list(rpc, filter, submitter_str, delegate_str):
-    filter.resolve_ids(rpc)
-
-    if submitter_str != "":
-        ids = person_ids_by_name(rpc, submitter_str)
-        if len(ids) == 0:
-            sys.stderr.write("Note: Nobody found matching *%s*\n", \
-                             submitter_str)
-        else:
-            for id in ids:
-                person = rpc.person_get(id)
-                print "Patches submitted by %s <%s>:" % \
-                        (person['name'], person['email'])
-                f = filter
-                f.add("submitter_id", id)
-                patches = rpc.patch_list(f.d)
-                list_patches(patches)
-        return
-
-    if delegate_str != "":
-        ids = person_ids_by_name(rpc, delegate_str)
-        if len(ids) == 0:
-            sys.stderr.write("Note: Nobody found matching *%s*\n", \
-                             delegate_str)
-        else:
-            for id in ids:
-                person = rpc.person_get(id)
-                print "Patches delegated to %s <%s>:" % \
-                        (person['name'], person['email'])
-                f = filter
-                f.add("delegate_id", id)
-                patches = rpc.patch_list(f.d)
-                list_patches(patches)
-        return
-
-    patches = rpc.patch_list(filter.d)
-    list_patches(patches)
-
-def action_projects(rpc):
-    projects = rpc.project_list("", 0)
-    print("%-5s %-24s %s" % ("ID", "Name", "Description"))
-    print("%-5s %-24s %s" % ("--", "----", "-----------"))
-    for project in projects:
-        print("%-5d %-24s %s" % (project['id'], \
-                project['linkname'], \
-                project['name']))
-
-def action_states(rpc):
-    states = rpc.state_list("", 0)
-    print("%-5s %s" % ("ID", "Name"))
-    print("%-5s %s" % ("--", "----"))
-    for state in states:
-        print("%-5d %s" % (state['id'], state['name']))
-
-def action_get(rpc, patch_id):
-    patch = rpc.patch_get(patch_id)
-    s = rpc.patch_get_mbox(patch_id)
-
-    if patch == {} or len(s) == 0:
-        sys.stderr.write("Unable to get patch %d\n" % patch_id)
-        sys.exit(1)
-
-    base_fname = fname = os.path.basename(patch['filename'])
-    i = 0
-    while os.path.exists(fname):
-        fname = "%s.%d" % (base_fname, i)
-        i += 1
-
-    try:
-        f = open(fname, "w")
-    except:
-        sys.stderr.write("Unable to open %s for writing\n" % fname)
-        sys.exit(1)
-
-    try:
-        f.write(unicode(s).encode("utf-8"))
-        f.close()
-        print "Saved patch to %s" % fname
-    except:
-        sys.stderr.write("Failed to write to %s\n" % fname)
-        sys.exit(1)
-
-def action_apply(rpc, patch_id):
-    patch = rpc.patch_get(patch_id)
-    if patch == {}:
-        sys.stderr.write("Error getting information on patch ID %d\n" % \
-                         patch_id)
-        sys.exit(1)
-    print "Applying patch #%d to current directory" % patch_id
-    print "Description: %s" % patch['name']
-    s = rpc.patch_get_mbox(patch_id)
-    if len(s) > 0:
-        proc = subprocess.Popen(['patch', '-p1'], stdin = subprocess.PIPE)
-        proc.communicate(s)
-    else:
-        sys.stderr.write("Error: No patch content found\n")
-        sys.exit(1)
-
-def action_update_patch(rpc, patch_id, state = None, commit = None,
-                        delegate_str = "", comment_str = "None",
-			archived = False):
-    patch = rpc.patch_get(patch_id)
-    if patch == {}:
-        sys.stderr.write("Error getting information on patch ID %d\n" % \
-                         patch_id)
-        sys.exit(1)
-
-    params = {}
-
-    delegate_id = None
-    if delegate_str != "":
-        params['delegate'] = delegate_str
-        ids = person_ids_by_name(rpc, delegate_str)
-        if len(ids) == 0:
-            sys.stderr.write("Note: Nobody found matching *%s*\n"% \
-                             delegate_str)
-        else:
-            delegate_id = ids[0]
-
-    if state:
-        state_id = state_id_by_name(rpc, state)
-        if state_id == 0:
-            sys.stderr.write("Error: No State found matching %s*\n" % state)
-            sys.exit(1)
-        params['state'] = state_id
-
-        if state.lower() in notify_on_state_change:
-            if not delegate_id:
-                sys.stderr.write("Error: Delegate (-d) required for this update\n")
-                sys.exit(1)
-                
-            person = rpc.person_get(delegate_id)
-            submitter = rpc.person_get(patch['submitter_id'])
-
-            from_addr = '%s <%s>' % (person['name'], person['email'])
-            cc_addr   = '%s <%s>' % (submitter['name'], submitter['email'])
-            to_addr   = notify_on_state_change[state.lower()]
-
-            orig_mail = rpc.patch_get_mbox(patch_id)
-            orig_mail = '> ' + orig_mail.replace('\n','\n> ')
-
-            longdesc = '''Patch %s (http://patchwork.newartisans.com/patch/%s/) is now "%s".
-
-Maintainer comment: %s
-
-This relates to the following submission:
-
-http://mid.gmane.org/%s
-
-Here is the original message containing the patch:
-
-%s''' % \
-                (patch['id'], patch['id'], state, comment_str, urllib.quote(patch['msgid']), orig_mail)
-            shortdesc = '[%s] %s' % (state, patch['name'])
-
-            msg = MIMEText(longdesc)
-
-            msg['Subject']    = shortdesc
-            msg['From']       = from_addr
-            msg['To']         = to_addr
-            #msg['Cc']         = cc_addr
-            msg['References'] = patch['msgid']
-
-            # Send the message via our own SMTP server, but don't include
-            # the envelope header.
-            try:
-                s = smtplib.SMTP('localhost')
-                print "Sending e-mail to: %s, %s" % (to_addr, cc_addr)
-                s.sendmail(from_addr, [to_addr, cc_addr], msg.as_string())
-                s.quit()
-            except:
-                sys.stderr.write("Warning: Failed to send e-mail " +
-                                 "(no SMTP server listening at localhost?)\n")
-
-    if commit:
-        params['commit_ref'] = commit
-
-    if archived:
-        params['archived'] = archived
-
-    success = False
-    try:
-        print "Updating patch %d to state '%s', delegate %s" % \
-            (patch_id, state, delegate_str)
-        success = rpc.patch_set(patch_id, params)
-    except xmlrpclib.Fault, f:
-        sys.stderr.write("Error updating patch: %s\n" % f.faultString)
-
-    if not success:
-        sys.stderr.write("Patch not updated\n")
-
-def patch_id_from_hash(rpc, project, hash):
-    try:
-        patch = rpc.patch_get_by_project_hash(project, hash)
-    except xmlrpclib.Fault:
-        # the server may not have the newer patch_get_by_project_hash function,
-        # so fall back to hash-only.
-        patch = rpc.patch_get_by_hash(hash)
-
-    if patch == {}:
-        return None
-
-    return patch['id']
-
-def branch_with(patch_id, rpc, delegate_str):
-    s = rpc.patch_get_mbox(patch_id)
-    if len(s) > 0:
-        print unicode(s).encode("utf-8")
-
-    patch = rpc.patch_get(patch_id)
-
-    # Find the latest commit from the day before the patch
-    proc = subprocess.Popen(['git', 'log', '--until=' + patch['date'],
-                             '-1', '--format=%H', 'master'],
-                            stdout = subprocess.PIPE)
-    sha = proc.stdout.read()[:-1]
-
-    # Create a topic branch named after this commit
-    proc = subprocess.Popen(['git', 'checkout', '-b', 't/patch%s' %
-                             patch_id, sha])
-    sts = os.waitpid(proc.pid, 0)
-    if sts[1] != 0:
-        sys.stderr.write("Could not create branch for patch\n")
-        return
-
-    # Apply the patch to the branch
-    fname = '/tmp/patch'
-    try:
-        f = open(fname, "w")
-    except:
-        sys.stderr.write("Unable to open %s for writing\n" % fname)
-        sys.exit(1)
-
-    try:
-        f.write(unicode(s).encode("utf-8"))
-        f.close()
-        print "Saved patch to %s" % fname
-    except:
-        sys.stderr.write("Failed to write to %s\n" % fname)
-        sys.exit(1)
-
-    proc = subprocess.Popen(['git', 'am', '/tmp/patch'])
-    sts = os.waitpid(proc.pid, 0)
-    if sts[1] != 0:
-        sys.stderr.write("Failed to apply patch to branch\n")
-        proc = subprocess.Popen(['git', 'checkout', 'master'])
-        os.waitpid(proc.pid, 0)
-        proc = subprocess.Popen(['git', 'branch', '-D', 't/patch%s' %
-                                 patch_id, sha])
-        os.waitpid(proc.pid, 0)
-        return
-
-    # If it succeeded this far, mark the patch as "Under Review" by the
-    # invoking user.
-    action_update_patch(rpc, patch_id, state = 'Under Review',
-                        delegate_str = delegate_str)
-
-    proc = subprocess.Popen(['git', 'rebase', 'master'])
-    sts = os.waitpid(proc.pid, 0)
-
-    print sha
-
-def merge_with(patch_id, rpc, delegate_str, comment_str):
-    s = rpc.patch_get_mbox(patch_id)
-    if len(s) > 0:
-        print unicode(s).encode("utf-8")
-
-    proc = subprocess.Popen(['git', 'checkout', 'master'])
-    sts = os.waitpid(proc.pid, 0)
-    if sts[1] != 0:
-        sys.stderr.write("Failed to checkout master branch\n")
-        return
-
-    proc = subprocess.Popen(['git', 'merge', '--ff', 't/patch%s' % patch_id])
-    sts = os.waitpid(proc.pid, 0)
-    if sts[1] != 0:
-        sys.stderr.write("Failed to merge t/patch%s into master\n" % patch_id)
-        return
-
-    proc = subprocess.Popen(['git', 'rev-parse', 'master'],
-                            stdout = subprocess.PIPE)
-    sha = proc.stdout.read()[:-1]
-
-    # If it succeeded this far, mark the patch as "Accepted" by the invoking
-    # user.
-    action_update_patch(rpc, patch_id, state = 'Accepted', commit = sha,
-                        delegate_str = delegate_str, comment_str = comment_str,
-                        archived = True)
-
-    print sha
-
-auth_actions = ['update', 'branch', 'merge']
-
-def main():
-    try:
-        opts, args = getopt.getopt(sys.argv[2:], 's:p:w:d:n:c:h:m:')
-    except getopt.GetoptError, err:
-        print str(err)
-        usage()
-
-    if len(sys.argv) < 2:
-        usage()
-
-    action = sys.argv[1].lower()
-
-    # set defaults
-    filt = Filter()
-    submitter_str = ""
-    delegate_str = ""
-    project_str = ""
-    commit_str = ""
-    state_str = "New"
-    hash_str = ""
-    url = DEFAULT_URL
-
-    config = ConfigParser.ConfigParser()
-    config.read(CONFIG_FILES)
-
-    # grab settings from config files
-    if config.has_option('base', 'url'):
-        url = config.get('base', 'url')
-
-    if config.has_option('base', 'project'):
-        project_str = config.get('base', 'project')
-
-    comment_str = "none"
-    for name, value in opts:
-        if name == '-s':
-            state_str = value
-        elif name == '-p':
-            project_str = value
-        elif name == '-w':
-            submitter_str = value
-        elif name == '-d':
-            delegate_str = value
-        elif name == '-c':
-            commit_str = value
-        elif name == '-h':
-            hash_str = value
-        elif name == '-m':
-	    comment_str = value
-        elif name == '-n':
-            try:
-                filt.add("max_count", int(value))
-            except:
-                sys.stderr.write("Invalid maximum count '%s'\n" % value)
-                usage()
-        else:
-            sys.stderr.write("Unknown option '%s'\n" % name)
-            usage()
-
-    if len(args) > 1:
-        sys.stderr.write("Too many arguments specified\n")
-        usage()
-
-    (username, password) = (None, None)
-    transport = None
-    if action in auth_actions:
-        if config.has_option('auth', 'username') and \
-                config.has_option('auth', 'password'):
-
-            use_https = url.startswith('https')
-
-            transport = BasicHTTPAuthTransport( \
-                    config.get('auth', 'username'),
-                    config.get('auth', 'password'),
-                    use_https)
-
-        else:
-            sys.stderr.write(("The %s action requires authentication, "
-                    "but no username or password\nis configured\n") % action)
-            sys.exit(1)
-
-    if project_str:
-        filt.add("project", project_str)
-
-    if state_str:
-        filt.add("state", state_str)
-
-    try:
-        rpc = xmlrpclib.Server(url, transport = transport)
-    except:
-        sys.stderr.write("Unable to connect to %s\n" % url)
-        sys.exit(1)
-
-    patch_id = None
-    if hash_str:
-        patch_id = patch_id_from_hash(rpc, project_str, hash_str)
-        if patch_id is None:
-            sys.stderr.write("No patch has the hash provided\n")
-            sys.exit(1)
-
-
-    if action == 'list' or action == 'search':
-        if len(args) > 0:
-            filt.add("name__icontains", args[0])
-        action_list(rpc, filt, submitter_str, delegate_str)
-
-    elif action.startswith('project'):
-        action_projects(rpc)
-
-    elif action.startswith('state'):
-        action_states(rpc)
-
-    elif action == 'branch':
-        try:
-            patch_id = patch_id or int(args[0])
-        except:
-            sys.stderr.write("Invalid patch ID given\n")
-            sys.exit(1)
-
-        branch_with(patch_id, rpc, config.get('auth', 'username'))
-
-    elif action == 'merge':
-        try:
-            patch_id = patch_id or int(args[0])
-        except:
-            sys.stderr.write("Invalid patch ID given\n")
-            sys.exit(1)
-
-        merge_with(patch_id, rpc, config.get('auth', 'username'), comment_str)
-
-    elif action == 'test':
-
-	patch_id = patch_id or int(args[0])
-	patch = rpc.patch_get(patch_id)
-	s = rpc.patch_get_mbox(patch_id)
-	print "xxx %s xxx"
-	print "xxx %s xxx" % patch['name']
-	print "xxx %s xxx" % rpc.patch_get_mbox(patch_id)
-
-    elif action == 'view' or action == 'show':
-        try:
-            patch_id = patch_id or int(args[0])
-        except:
-            sys.stderr.write("Invalid patch ID given\n")
-            sys.exit(1)
-
-        s = rpc.patch_get_mbox(patch_id)
-        if len(s) > 0:
-            print unicode(s).encode("utf-8")
-
-    elif action == 'get' or action == 'save':
-        try:
-            patch_id = patch_id or int(args[0])
-        except:
-            sys.stderr.write("Invalid patch ID given\n")
-            sys.exit(1)
-
-        action_get(rpc, patch_id)
-
-    elif action == 'apply':
-        try:
-            patch_id = patch_id or int(args[0])
-        except:
-            sys.stderr.write("Invalid patch ID given\n")
-            sys.exit(1)
-
-        action_apply(rpc, patch_id)
-
-    elif action == 'update':
-        try:
-            patch_id = patch_id or int(args[0])
-        except:
-            sys.stderr.write("Invalid patch ID given\n")
-            sys.exit(1)
-
-        action_update_patch(rpc, patch_id, state = state_str,
-                            commit = commit_str, delegate_str = delegate_str, comment_str = comment_str)
-
-    else:
-        sys.stderr.write("Unknown action '%s'\n" % action)
-        usage()
-
-if __name__ == "__main__":
-    main()