Created
August 18, 2013 02:04
-
-
Save hiromu/6259580 to your computer and use it in GitHub Desktop.
pwclient
- fix bug about parsing command-line option
- add option to specify filename
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#!/usr/bin/env python | |
# | |
# Patchwork command line client | |
# Copyright (C) 2008 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 | |
# 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 = "https://patchwork.kernel.org/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) | |
git-am <ID> : Apply a patch to current git branch using "git am" | |
get <ID> : Download a patch and save it locally | |
info <ID> : Display patchwork info about a given patch ID | |
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 | |
update [-s state] [-c commit-ref] <ID> | |
: Update patch¥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 | |
-m <messageid>: Filter by Message-Id | |
-o <filename> : Save patch to filename¥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("%-7s %-12s %s" % ("ID", "State", "Name")) | |
print("%-7s %-12s %s" % ("--", "-----", "----")) | |
for patch in patches: | |
print("%-7d %-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>:" % ¥ | |
(unicode(person['name']).encode("utf-8"), ¥ | |
unicode(person['email']).encode("utf-8")) | |
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_info(rpc, patch_id): | |
patch = rpc.patch_get(patch_id) | |
s = "Information for patch id %d" % (patch_id) | |
print(s) | |
print('-' * len(s)) | |
for key, value in sorted(patch.iteritems()): | |
print("- %- 14s: %s" % (key, value)) | |
def action_get(rpc, patch_id, fname): | |
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) | |
if fname == "": | |
fname = os.path.basename(patch['filename']) | |
base_fname = fname | |
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, apply_cmd=None): | |
patch = rpc.patch_get(patch_id) | |
if patch == {}: | |
sys.stderr.write("Error getting information on patch ID %d¥n" % ¥ | |
patch_id) | |
sys.exit(1) | |
if apply_cmd is None: | |
print "Applying patch #%d to current directory" % patch_id | |
apply_cmd = ['patch', '-p1'] | |
else: | |
print "Applying patch #%d using %s" % ( | |
patch_id, repr(' '.join(apply_cmd))) | |
print "Description: %s" % patch['name'] | |
s = rpc.patch_get_mbox(patch_id) | |
if len(s) > 0: | |
proc = subprocess.Popen(apply_cmd, stdin = subprocess.PIPE) | |
proc.communicate(unicode(s).encode('utf-8')) | |
else: | |
sys.stderr.write("Error: No patch content found¥n") | |
sys.exit(1) | |
def action_update_patch(rpc, patch_id, state = None, commit = None): | |
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 = {} | |
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 commit: | |
params['commit_ref'] = commit | |
success = False | |
try: | |
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'] | |
auth_actions = ['update'] | |
def main(): | |
try: | |
opts, args = getopt.gnu_getopt(sys.argv[2:], 's:p:w:d:n:c:h:m:o:') | |
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 = "" | |
hash_str = "" | |
msgid_str = "" | |
filename_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') | |
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': | |
msgid_str = value | |
elif name == '-o': | |
filename_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) | |
if msgid_str: | |
filt.add("msgid", msgid_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 == 'view': | |
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 in ('get', 'save', 'info'): | |
try: | |
patch_id = patch_id or int(args[0]) | |
except: | |
sys.stderr.write("Invalid patch ID given¥n") | |
sys.exit(1) | |
if action == 'info': | |
action_info(rpc, patch_id) | |
else: | |
action_get(rpc, patch_id, filename_str) | |
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 == 'git-am': | |
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, ['git', 'am']) | |
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) | |
else: | |
sys.stderr.write("Unknown action '%s'¥n" % action) | |
usage() | |
if __name__ == "__main__": | |
main() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment