git.ozlabs.org Git - patchwork/blob - apps/patchwork/bin/pwclient

   1 #!/usr/bin/env python
   2 #
   3 # Patchwork command line client
   4 # Copyright (C) 2008 Nate Case <ncase@xes-inc.com>
   5 #
   6 # This file is part of the Patchwork package.
   7 #
   8 # Patchwork is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # Patchwork is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with Patchwork; if not, write to the Free Software
  20 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21
  22 import os
  23 import sys
  24 import xmlrpclib
  25 import argparse
  26 import string
  27 import tempfile
  28 import subprocess
  29 import base64
  30 import ConfigParser
  31 import shutil
  32 import re
  33
  34 # Default Patchwork remote XML-RPC server URL
  35 # This script will check the PW_XMLRPC_URL environment variable
  36 # for the URL to access.  If that is unspecified, it will fallback to
  37 # the hardcoded default value specified here.
  38 DEFAULT_URL = "http://patchwork/xmlrpc/"
  39 CONFIG_FILE = os.path.expanduser('~/.pwclientrc')
  40
  41 class Filter:
  42     """Filter for selecting patches."""
  43     def __init__(self):
  44         # These fields refer to specific objects, so they are special
  45         # because we have to resolve them to IDs before passing the
  46         # filter to the server
  47         self.state = ""
  48         self.project = ""
  49
  50         # The dictionary that gets passed to via XML-RPC
  51         self.d = {}
  52
  53     def add(self, field, value):
  54         if field == 'state':
  55             self.state = value
  56         elif field == 'project':
  57             self.project = value
  58         else:
  59             # OK to add directly
  60             self.d[field] = value
  61
  62     def resolve_ids(self, rpc):
  63         """Resolve State, Project, and Person IDs based on filter strings."""
  64         if self.state != "":
  65             id = state_id_by_name(rpc, self.state)
  66             if id == 0:
  67                 sys.stderr.write("Note: No State found matching %s*, " \
  68                                  "ignoring filter\n" % self.state)
  69             else:
  70                 self.d['state_id'] = id
  71
  72         if self.project != None:
  73             id = project_id_by_name(rpc, self.project)
  74             if id == 0:
  75                 sys.stderr.write("Note: No Project found matching %s, " \
  76                                  "ignoring filter\n" % self.project)
  77             else:
  78                 self.d['project_id'] = id
  79
  80     def __str__(self):
  81         """Return human-readable description of the filter."""
  82         return str(self.d)
  83
  84 class BasicHTTPAuthTransport(xmlrpclib.SafeTransport):
  85
  86     def __init__(self, username = None, password = None, use_https = False):
  87         self.username = username
  88         self.password = password
  89         self.use_https = use_https
  90         xmlrpclib.SafeTransport.__init__(self)
  91
  92     def authenticated(self):
  93         return self.username != None and self.password != None
  94
  95     def send_host(self, connection, host):
  96         xmlrpclib.Transport.send_host(self, connection, host)
  97         if not self.authenticated():
  98             return
  99         credentials = '%s:%s' % (self.username, self.password)
 100         auth = 'Basic ' + base64.encodestring(credentials).strip()
 101         connection.putheader('Authorization', auth)
 102
 103     def make_connection(self, host):
 104         if self.use_https:
 105             fn = xmlrpclib.SafeTransport.make_connection
 106         else:
 107             fn = xmlrpclib.Transport.make_connection
 108         return fn(self, host)
 109
 110 def project_id_by_name(rpc, linkname):
 111     """Given a project short name, look up the Project ID."""
 112     if len(linkname) == 0:
 113         return 0
 114     projects = rpc.project_list(linkname, 0)
 115     for project in projects:
 116         if project['linkname'] == linkname:
 117             return project['id']
 118     return 0
 119
 120 def state_id_by_name(rpc, name):
 121     """Given a partial state name, look up the state ID."""
 122     if len(name) == 0:
 123         return 0
 124     states = rpc.state_list(name, 0)
 125     for state in states:
 126         if state['name'].lower().startswith(name.lower()):
 127             return state['id']
 128     return 0
 129
 130 def person_ids_by_name(rpc, name):
 131     """Given a partial name or email address, return a list of the
 132     person IDs that match."""
 133     if len(name) == 0:
 134         return []
 135     people = rpc.person_list(name, 0)
 136     return map(lambda x: x['id'], people)
 137
 138 def list_patches(patches, format_str=None):
 139     """Dump a list of patches to stdout."""
 140     if format_str:
 141         format_field_re = re.compile("%{([a-z0-9_]+)}")
 142
 143         def patch_field(matchobj):
 144             fieldname = matchobj.group(1)
 145
 146             if fieldname == "_msgid_":
 147                 # naive way to strip < and > from message-id
 148                 val = string.strip(str(patch["msgid"]), "<>")
 149             else:
 150                 val = str(patch[fieldname])
 151
 152             return val
 153
 154         for patch in patches:
 155             print(format_field_re.sub(patch_field, format_str))
 156     else:
 157         print("%-7s %-12s %s" % ("ID", "State", "Name"))
 158         print("%-7s %-12s %s" % ("--", "-----", "----"))
 159         for patch in patches:
 160             print("%-7d %-12s %s" % (patch['id'], patch['state'], patch['name']))
 161
 162 def action_list(rpc, filter, submitter_str, delegate_str, format_str=None):
 163     filter.resolve_ids(rpc)
 164
 165     if submitter_str != None:
 166         ids = person_ids_by_name(rpc, submitter_str)
 167         if len(ids) == 0:
 168             sys.stderr.write("Note: Nobody found matching *%s*\n" % \
 169                              submitter_str)
 170         else:
 171             for id in ids:
 172                 person = rpc.person_get(id)
 173                 print "Patches submitted by %s <%s>:" % \
 174                         (unicode(person['name']).encode("utf-8"), \
 175                          unicode(person['email']).encode("utf-8"))
 176                 f = filter
 177                 f.add("submitter_id", id)
 178                 patches = rpc.patch_list(f.d)
 179                 list_patches(patches, format_str)
 180         return
 181
 182     if delegate_str != None:
 183         ids = person_ids_by_name(rpc, delegate_str)
 184         if len(ids) == 0:
 185             sys.stderr.write("Note: Nobody found matching *%s*\n" % \
 186                              delegate_str)
 187         else:
 188             for id in ids:
 189                 person = rpc.person_get(id)
 190                 print "Patches delegated to %s <%s>:" % \
 191                         (person['name'], person['email'])
 192                 f = filter
 193                 f.add("delegate_id", id)
 194                 patches = rpc.patch_list(f.d)
 195                 list_patches(patches, format_str)
 196         return
 197
 198     patches = rpc.patch_list(filter.d)
 199     list_patches(patches, format_str)
 200
 201 def action_projects(rpc):
 202     projects = rpc.project_list("", 0)
 203     print("%-5s %-24s %s" % ("ID", "Name", "Description"))
 204     print("%-5s %-24s %s" % ("--", "----", "-----------"))
 205     for project in projects:
 206         print("%-5d %-24s %s" % (project['id'], \
 207                 project['linkname'], \
 208                 project['name']))
 209
 210 def action_states(rpc):
 211     states = rpc.state_list("", 0)
 212     print("%-5s %s" % ("ID", "Name"))
 213     print("%-5s %s" % ("--", "----"))
 214     for state in states:
 215         print("%-5d %s" % (state['id'], state['name']))
 216
 217 def action_info(rpc, patch_id):
 218     patch = rpc.patch_get(patch_id)
 219     s = "Information for patch id %d" % (patch_id)
 220     print(s)
 221     print('-' * len(s))
 222     for key, value in sorted(patch.iteritems()):
 223         print("- %- 14s: %s" % (key, unicode(value).encode("utf-8")))
 224
 225 def action_get(rpc, patch_id):
 226     patch = rpc.patch_get(patch_id)
 227     s = rpc.patch_get_mbox(patch_id)
 228
 229     if patch == {} or len(s) == 0:
 230         sys.stderr.write("Unable to get patch %d\n" % patch_id)
 231         sys.exit(1)
 232
 233     base_fname = fname = os.path.basename(patch['filename'])
 234     i = 0
 235     while os.path.exists(fname):
 236         fname = "%s.%d" % (base_fname, i)
 237         i += 1
 238
 239     try:
 240         f = open(fname, "w")
 241     except:
 242         sys.stderr.write("Unable to open %s for writing\n" % fname)
 243         sys.exit(1)
 244
 245     try:
 246         f.write(unicode(s).encode("utf-8"))
 247         f.close()
 248         print "Saved patch to %s" % fname
 249     except:
 250         sys.stderr.write("Failed to write to %s\n" % fname)
 251         sys.exit(1)
 252
 253 def action_apply(rpc, patch_id, apply_cmd=None):
 254     patch = rpc.patch_get(patch_id)
 255     if patch == {}:
 256         sys.stderr.write("Error getting information on patch ID %d\n" % \
 257                          patch_id)
 258         sys.exit(1)
 259
 260     if apply_cmd is None:
 261       print "Applying patch #%d to current directory" % patch_id
 262       apply_cmd = ['patch', '-p1']
 263     else:
 264       print "Applying patch #%d using %s" % (
 265           patch_id, repr(' '.join(apply_cmd)))
 266
 267     print "Description: %s" % patch['name']
 268     s = rpc.patch_get_mbox(patch_id)
 269     if len(s) > 0:
 270         proc = subprocess.Popen(apply_cmd, stdin = subprocess.PIPE)
 271         proc.communicate(unicode(s).encode('utf-8'))
 272     else:
 273         sys.stderr.write("Error: No patch content found\n")
 274         sys.exit(1)
 275
 276 def action_update_patch(rpc, patch_id, state = None, commit = None):
 277     patch = rpc.patch_get(patch_id)
 278     if patch == {}:
 279         sys.stderr.write("Error getting information on patch ID %d\n" % \
 280                          patch_id)
 281         sys.exit(1)
 282
 283     params = {}
 284
 285     if state:
 286         state_id = state_id_by_name(rpc, state)
 287         if state_id == 0:
 288             sys.stderr.write("Error: No State found matching %s*\n" % state)
 289             sys.exit(1)
 290         params['state'] = state_id
 291
 292     if commit:
 293         params['commit_ref'] = commit
 294
 295     success = False
 296     try:
 297         success = rpc.patch_set(patch_id, params)
 298     except xmlrpclib.Fault, f:
 299         sys.stderr.write("Error updating patch: %s\n" % f.faultString)
 300
 301     if not success:
 302         sys.stderr.write("Patch not updated\n")
 303
 304 def patch_id_from_hash(rpc, project, hash):
 305     try:
 306         patch = rpc.patch_get_by_project_hash(project, hash)
 307     except xmlrpclib.Fault:
 308         # the server may not have the newer patch_get_by_project_hash function,
 309         # so fall back to hash-only.
 310         patch = rpc.patch_get_by_hash(hash)
 311
 312     if patch == {}:
 313         sys.stderr.write("No patch has the hash provided\n")
 314         sys.exit(1)
 315
 316     patch_id = patch['id']
 317     # be super paranoid
 318     try:
 319         patch_id = int(patch_id)
 320     except:
 321         sys.stderr.write("Invalid patch ID obtained from server\n")
 322         sys.exit(1)
 323     return patch_id
 324
 325 auth_actions = ['update']
 326
 327 # unfortunately we currently have to revert to this ugly hack..
 328 class _RecursiveHelpAction(argparse._HelpAction):
 329
 330     def __call__(self, parser, namespace, values, option_string=None):
 331         parser.print_help()
 332         print
 333
 334         subparsers_actions = [
 335             action for action in parser._actions
 336             if isinstance(action, argparse._SubParsersAction)
 337         ]
 338         hash_n_id_actions = set(['hash', 'id', 'help'])
 339         for subparsers_action in subparsers_actions:
 340             for choice, subparser in subparsers_action.choices.items():
 341                 # gross but the whole thing is..
 342                 if (len(subparser._actions) == 3 \
 343                     and set([a.dest for a in subparser._actions]) \
 344                         == hash_n_id_actions) \
 345                    or len(subparser._actions) == 0:
 346                     continue
 347                 print("command '{}'".format(choice))
 348                 print(subparser.format_help())
 349
 350         parser.exit()
 351
 352 def main():
 353     hash_parser = argparse.ArgumentParser(add_help=False, version=False)
 354     hash_parser.add_argument(
 355         '-h', metavar='HASH', dest='hash', action='store',
 356         help='''Lookup by patch hash'''
 357     )
 358     hash_parser.add_argument(
 359         'id', metavar='ID', nargs='*', action='store', type=int,
 360         help='Patch ID',
 361     )
 362     hash_parser.add_argument(
 363         '-p', metavar='PROJECT',
 364         help='''Lookup patch in project'''
 365     )
 366
 367     filter_parser = argparse.ArgumentParser(add_help=False, version=False)
 368     filter_parser.add_argument(
 369         '-s', metavar='STATE',
 370         help='''Filter by patch state (e.g., 'New', 'Accepted', etc.)'''
 371     )
 372     filter_parser.add_argument(
 373         '-p', metavar='PROJECT',
 374         help='''Filter by project name (see 'projects' for list)'''
 375     )
 376     filter_parser.add_argument(
 377         '-w', metavar='WHO',
 378         help='''Filter by submitter (name, e-mail substring search)'''
 379     )
 380     filter_parser.add_argument(
 381         '-d', metavar='WHO',
 382         help='''Filter by delegate (name, e-mail substring search)'''
 383     )
 384     filter_parser.add_argument(
 385         '-n', metavar='MAX#',
 386         type=int,
 387         help='''Restrict number of results'''
 388     )
 389     filter_parser.add_argument(
 390         '-m', metavar='MESSAGEID',
 391         help='''Filter by Message-Id'''
 392     )
 393     filter_parser.add_argument(
 394         '-f', metavar='FORMAT',
 395         help='''Print output in the given format. You can use tags matching '''
 396             '''fields, e.g. %%{id}, %%{state}, or %%{msgid}.'''
 397     )
 398     filter_parser.add_argument(
 399         'patch_name', metavar='STR', nargs='?',
 400         help='substring to search for patches by name',
 401     )
 402     help_parser = argparse.ArgumentParser(add_help=False, version=False)
 403     help_parser.add_argument(
 404         '--help', action='help', help=argparse.SUPPRESS,
 405         #help='''show this help message and exit'''
 406     )
 407
 408     action_parser = argparse.ArgumentParser(
 409         prog='pwclient',
 410         add_help=False,
 411         version=False,
 412         formatter_class=argparse.RawDescriptionHelpFormatter,
 413         epilog='''(apply | get | info | view | update) (-h HASH | ID [ID ...])''',
 414     )
 415     action_parser.add_argument(
 416         '--help',
 417         #action='help',
 418         action=_RecursiveHelpAction,
 419         help='''Print this help text'''
 420     )
 421
 422     subparsers = action_parser.add_subparsers(
 423         title='Commands',
 424         metavar=''
 425     )
 426     apply_parser = subparsers.add_parser(
 427         'apply', parents=[hash_parser, help_parser],
 428         add_help=False,
 429         help='''Apply a patch (in the current dir, using -p1)'''
 430     )
 431     apply_parser.set_defaults(subcmd='apply')
 432     git_am_parser = subparsers.add_parser(
 433         'git-am', parents=[hash_parser, help_parser],
 434         add_help=False,
 435         help='''Apply a patch to current git branch using "git am".'''
 436     )
 437     git_am_parser.set_defaults(subcmd='git_am')
 438     git_am_parser.add_argument(
 439         '-s', '--signoff',
 440         action='store_true',
 441         help='''pass --signoff to git-am'''
 442     )
 443     get_parser = subparsers.add_parser(
 444         'get', parents=[hash_parser, help_parser],
 445         add_help=False,
 446         help='''Download a patch and save it locally'''
 447     )
 448     get_parser.set_defaults(subcmd='get')
 449     info_parser = subparsers.add_parser(
 450         'info', parents=[hash_parser, help_parser],
 451         add_help=False,
 452         help='''Display patchwork info about a given patch ID'''
 453     )
 454     info_parser.set_defaults(subcmd='info')
 455     projects_parser = subparsers.add_parser(
 456         'projects',
 457         add_help=False,
 458         help='''List all projects'''
 459     )
 460     projects_parser.set_defaults(subcmd='projects')
 461     states_parser = subparsers.add_parser(
 462         'states',
 463         add_help=False,
 464         help='''Show list of potential patch states'''
 465     )
 466     states_parser.set_defaults(subcmd='states')
 467     view_parser = subparsers.add_parser(
 468         'view', parents=[hash_parser, help_parser],
 469         add_help=False,
 470         help='''View a patch'''
 471     )
 472     view_parser.set_defaults(subcmd='view')
 473     update_parser = subparsers.add_parser(
 474         'update', parents=[hash_parser, help_parser],
 475         add_help=False,
 476         help='''Update patch''',
 477         epilog='''Using a COMMIT-REF allows for only one ID to be specified''',
 478     )
 479     update_parser.add_argument(
 480         '-c', metavar='COMMIT-REF',
 481         help='''commit reference hash'''
 482     )
 483     update_parser.add_argument(
 484         '-s', metavar='STATE',
 485         required=True,
 486         help='''Set patch state (e.g., 'Accepted', 'Superseded' etc.)'''
 487     )
 488     update_parser.set_defaults(subcmd='update')
 489     list_parser = subparsers.add_parser("list",
 490         add_help=False,
 491         #aliases=['search'],
 492         parents=[filter_parser, help_parser],
 493         help='''List patches, using the optional filters specified
 494         below and an optional substring to search for patches
 495         by name'''
 496     )
 497     list_parser.set_defaults(subcmd='list')
 498     search_parser = subparsers.add_parser("search",
 499         add_help=False,
 500         parents=[filter_parser, help_parser],
 501         help='''Alias for "list"'''
 502     )
 503     # Poor man's argparse aliases:
 504     # We register the "search" parser but effectively use "list" for the
 505     # help-text.
 506     search_parser.set_defaults(subcmd='list')
 507     if len(sys.argv) < 2:
 508         action_parser.print_help()
 509         sys.exit(0)
 510
 511     args = action_parser.parse_args()
 512     args = dict(vars(args))
 513     action = args.get('subcmd')
 514
 515     if args.get('hash') and len(args.get('id')):
 516         # mimic mutual exclusive group
 517         sys.stderr.write("Error: [-h HASH] and [ID [ID ...]] " +
 518           "are mutually exlusive\n")
 519         locals()[action + '_parser'].print_help()
 520         sys.exit(1)
 521
 522     # set defaults
 523     filt = Filter()
 524     commit_str = None
 525     url = DEFAULT_URL
 526
 527     state_str = args.get('s')
 528     project_str = args.get('p')
 529     submitter_str = args.get('w')
 530     delegate_str = args.get('d')
 531     format_str = args.get('f')
 532     hash_str = args.get('hash')
 533     patch_ids = args.get('id')
 534     msgid_str = args.get('m')
 535     if args.get('c'):
 536         # update multiple IDs with a single commit-hash does not make sense
 537         if action == 'update' and patch_ids and len(patch_ids) > 1:
 538             sys.stderr.write(
 539               "Declining update with COMMIT-REF on multiple IDs\n"
 540             )
 541             update_parser.print_help()
 542             sys.exit(1)
 543         commit_str = args.get('c')
 544
 545     if args.get('n') != None:
 546         try:
 547             filt.add("max_count", args.get('n'))
 548         except:
 549             sys.stderr.write("Invalid maximum count '%s'\n" % args.get('n'))
 550             action_parser.print_help()
 551             sys.exit(1)
 552
 553     do_signoff = args.get('signoff')
 554
 555     # grab settings from config files
 556     config = ConfigParser.ConfigParser()
 557     config.read([CONFIG_FILE])
 558
 559     if not config.has_section('options'):
 560         sys.stderr.write('~/.pwclientrc is in the old format. Migrating it...')
 561
 562         old_project = config.get('base','project')
 563
 564         new_config = ConfigParser.ConfigParser()
 565         new_config.add_section('options')
 566
 567         new_config.set('options','default',old_project)
 568         new_config.add_section(old_project)
 569
 570         new_config.set(old_project,'url',config.get('base','url'))
 571         if config.has_option('auth', 'username'):
 572             new_config.set(old_project,'username',config.get('auth','username'))
 573         if config.has_option('auth', 'password'):
 574             new_config.set(old_project,'password',config.get('auth','password'))
 575
 576         old_config_file = CONFIG_FILE + '.orig'
 577         shutil.copy2(CONFIG_FILE,old_config_file)
 578
 579         with open(CONFIG_FILE, 'wb') as fd:
 580             new_config.write(fd)
 581
 582         sys.stderr.write(' Done.\n')
 583         sys.stderr.write('Your old ~/.pwclientrc was saved to %s\n' % old_config_file)
 584         sys.stderr.write('and was converted to the new format. You may want to\n')
 585         sys.stderr.write('inspect it before continuing.\n')
 586         sys.exit(1)
 587
 588     if not project_str:
 589         try:
 590             project_str = config.get('options', 'default')
 591         except:
 592             sys.stderr.write("No default project configured in ~/.pwclientrc\n")
 593             action_parser.print_help()
 594             sys.exit(1)
 595
 596     if not config.has_section(project_str):
 597         sys.stderr.write("No section for project %s\n" % project_str)
 598         sys.exit(1)
 599     if not config.has_option(project_str, 'url'):
 600         sys.stderr.write("No URL for project %s\n" % project_str)
 601         sys.exit(1)
 602     if not do_signoff and config.has_option('options', 'signoff'):
 603         do_signoff = config.getboolean('options', 'signoff')
 604     if not do_signoff and config.has_option(project_str, 'signoff'):
 605         do_signoff = config.getboolean(project_str, 'signoff')
 606
 607     url = config.get(project_str, 'url')
 608
 609     (username, password) = (None, None)
 610     transport = None
 611     if action in auth_actions:
 612         if config.has_option(project_str, 'username') and \
 613                 config.has_option(project_str, 'password'):
 614
 615             use_https = url.startswith('https')
 616
 617             transport = BasicHTTPAuthTransport( \
 618                     config.get(project_str, 'username'),
 619                     config.get(project_str, 'password'),
 620                     use_https)
 621
 622         else:
 623             sys.stderr.write(("The %s action requires authentication, "
 624                     "but no username or password\nis configured\n") % action)
 625             sys.exit(1)
 626
 627     if project_str:
 628         filt.add("project", project_str)
 629
 630     if state_str:
 631         filt.add("state", state_str)
 632
 633     if msgid_str:
 634         filt.add("msgid", msgid_str)
 635
 636     try:
 637         rpc = xmlrpclib.Server(url, transport = transport)
 638     except:
 639         sys.stderr.write("Unable to connect to %s\n" % url)
 640         sys.exit(1)
 641
 642     # It should be safe to assume hash_str is not zero, but who knows..
 643     if hash_str != None:
 644         patch_ids = [patch_id_from_hash(rpc, project_str, hash_str)]
 645
 646     # helper for non_empty() to print correct helptext
 647     h = locals()[action + '_parser']
 648
 649     # Require either hash_str or IDs for
 650     def non_empty(h, patch_ids):
 651         """Error out if no patch IDs were specified"""
 652         if patch_ids == None or len(patch_ids) < 1:
 653             sys.stderr.write("Error: Missing Argument! " +
 654               "Either [-h HASH] or [ID [ID ...]] are required\n")
 655             if h:
 656                 h.print_help()
 657             sys.exit(1)
 658         return patch_ids
 659
 660     if action == 'list' or action == 'search':
 661         if args.get('patch_name') != None:
 662             filt.add("name__icontains", args.get('patch_name'))
 663         action_list(rpc, filt, submitter_str, delegate_str, format_str)
 664
 665     elif action.startswith('project'):
 666         action_projects(rpc)
 667
 668     elif action.startswith('state'):
 669         action_states(rpc)
 670
 671     elif action == 'view':
 672         for patch_id in non_empty(h, patch_ids):
 673             s = rpc.patch_get_mbox(patch_id)
 674             if len(s) > 0:
 675                 print unicode(s).encode("utf-8")
 676
 677     elif action == 'info':
 678         for patch_id in non_empty(h, patch_ids):
 679             action_info(rpc, patch_id)
 680
 681     elif action == 'get':
 682         for patch_id in non_empty(h, patch_ids):
 683             action_get(rpc, patch_id)
 684
 685     elif action == 'apply':
 686         for patch_id in non_empty(h, patch_ids):
 687             action_apply(rpc, patch_id)
 688
 689     elif action == 'git_am':
 690         cmd = ['git', 'am']
 691         if do_signoff:
 692             cmd.append('-s')
 693         for patch_id in non_empty(h, patch_ids):
 694             action_apply(rpc, patch_id, cmd)
 695
 696     elif action == 'update':
 697         for patch_id in non_empty(h, patch_ids):
 698             action_update_patch(rpc, patch_id, state = state_str,
 699                 commit = commit_str
 700             )
 701
 702     else:
 703         sys.stderr.write("Unknown action '%s'\n" % action)
 704         action_parser.print_help()
 705         sys.exit(1)
 706
 707 if __name__ == "__main__":
 708     main()