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

1 #!/usr/bin/env python

2 #

3 # Patchwork command line client

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

22 import os

23 import sys

24 import xmlrpclib

25 import getopt

26 import string

27 import tempfile

28 import subprocess

29 import base64

30 import ConfigParser

32 # Default Patchwork remote XML-RPC server URL

33 # This script will check the PW_XMLRPC_URL environment variable

34 # for the URL to access. If that is unspecified, it will fallback to

35 # the hardcoded default value specified here.

36 DEFAULT_URL = "http://patchwork/xmlrpc/"

37 CONFIG_FILES = [os.path.expanduser('~/.pwclientrc')]

39 class Filter:

40 """Filter for selecting patches."""

41 def __init__(self):

42 # These fields refer to specific objects, so they are special

43 # because we have to resolve them to IDs before passing the

44 # filter to the server

45 self.state = ""

46 self.project = ""

48 # The dictionary that gets passed to via XML-RPC

49 self.d = {}

51 def add(self, field, value):

52 if field == 'state':

53 self.state = value

54 elif field == 'project':

55 self.project = value

56 else:

57 # OK to add directly

58 self.d[field] = value

60 def resolve_ids(self, rpc):

61 """Resolve State, Project, and Person IDs based on filter strings."""

62 if self.state != "":

63 id = state_id_by_name(rpc, self.state)

64 if id == 0:

65 sys.stderr.write("Note: No State found matching %s*, " \

66 "ignoring filter\n" % self.state)

67 else:

68 self.d['state_id'] = id

70 if self.project != "":

71 id = project_id_by_name(rpc, self.project)

72 if id == 0:

73 sys.stderr.write("Note: No Project found matching %s, " \

74 "ignoring filter\n" % self.project)

75 else:

76 self.d['project_id'] = id

78 def __str__(self):

79 """Return human-readable description of the filter."""

80 return str(self.d)

82 class BasicHTTPAuthTransport(xmlrpclib.Transport):

84 def __init__(self, username = None, password = None):

85 self.username = username

86 self.password = password

87 xmlrpclib.Transport.__init__(self)

89 def authenticated(self):

90 return self.username != None and self.password != None

92 def send_host(self, connection, host):

93 xmlrpclib.Transport.send_host(self, connection, host)

94 if not self.authenticated():

95 return

96 credentials = '%s:%s' % (self.username, self.password)

97 auth = 'Basic ' + base64.encodestring(credentials).strip()

98 connection.putheader('Authorization', auth)

100 def usage():

101 sys.stderr.write("Usage: %s <action> [options]\n\n" % \

102 (os.path.basename(sys.argv[0])))

103 sys.stderr.write("Where <action> is one of:\n")

104 sys.stderr.write(

105 """ apply <ID> : Apply a patch (in the current dir, using -p1)

106 get <ID> : Download a patch and save it locally

107 projects : List all projects

108 states : Show list of potential patch states

109 list [str] : List patches, using the optional filters specified

110 below and an optional substring to search for patches

111 by name

112 search [str] : Same as 'list'

113 view <ID> : View a patch

114 update [-s state] [-c commit-ref] <ID>

115 : Update patch\n""")

116 sys.stderr.write("""\nFilter options for 'list' and 'search':

117 -s <state> : Filter by patch state (e.g., 'New', 'Accepted', etc.)

118 -p <project> : Filter by project name (see 'projects' for list)

119 -w <who> : Filter by submitter (name, e-mail substring search)

120 -d <who> : Filter by delegate (name, e-mail substring search)

121 -n <max #> : Restrict number of results\n""")

122 sys.stderr.write("""\nActions that take an ID argument can also be \

123 invoked with:

124 -h <hash> : Lookup by patch hash\n""")

125 sys.exit(1)

126

127 def project_id_by_name(rpc, linkname):

128 """Given a project short name, look up the Project ID."""

129 if len(linkname) == 0:

130 return 0

131 projects = rpc.project_list(linkname, 0)

132 for project in projects:

133 if project['linkname'] == linkname:

134 return project['id']

135 return 0

136

137 def state_id_by_name(rpc, name):

138 """Given a partial state name, look up the state ID."""

139 if len(name) == 0:

140 return 0

141 states = rpc.state_list(name, 0)

142 for state in states:

143 if state['name'].lower().startswith(name.lower()):

144 return state['id']

145 return 0

146

147 def person_ids_by_name(rpc, name):

148 """Given a partial name or email address, return a list of the

149 person IDs that match."""

150 if len(name) == 0:

151 return []

152 people = rpc.person_list(name, 0)

153 return map(lambda x: x['id'], people)

154

155 def list_patches(patches):

156 """Dump a list of patches to stdout."""

157 print("%-5s %-12s %s" % ("ID", "State", "Name"))

158 print("%-5s %-12s %s" % ("--", "-----", "----"))

159 for patch in patches:

160 print("%-5d %-12s %s" % (patch['id'], patch['state'], patch['name']))

161

162 def action_list(rpc, filter, submitter_str, delegate_str):

163 filter.resolve_ids(rpc)

164

165 if submitter_str != "":

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 (person['name'], person['email'])

175 f = filter

176 f.add("submitter_id", id)

177 patches = rpc.patch_list(f.d)

178 list_patches(patches)

179 return

180

181 if delegate_str != "":

182 ids = person_ids_by_name(rpc, delegate_str)

183 if len(ids) == 0:

184 sys.stderr.write("Note: Nobody found matching *%s*\n", \

185 delegate_str)

186 else:

187 for id in ids:

188 person = rpc.person_get(id)

189 print "Patches delegated to %s <%s>:" % \

190 (person['name'], person['email'])

191 f = filter

192 f.add("delegate_id", id)

193 patches = rpc.patch_list(f.d)

194 list_patches(patches)

195 return

196

197 patches = rpc.patch_list(filter.d)

198 list_patches(patches)

199

200 def action_projects(rpc):

201 projects = rpc.project_list("", 0)

202 print("%-5s %-24s %s" % ("ID", "Name", "Description"))

203 print("%-5s %-24s %s" % ("--", "----", "-----------"))

204 for project in projects:

205 print("%-5d %-24s %s" % (project['id'], \

206 project['linkname'], \

207 project['name']))

208

209 def action_states(rpc):

210 states = rpc.state_list("", 0)

211 print("%-5s %s" % ("ID", "Name"))

212 print("%-5s %s" % ("--", "----"))

213 for state in states:

214 print("%-5d %s" % (state['id'], state['name']))

215

216 def action_get(rpc, patch_id):

217 patch = rpc.patch_get(patch_id)

218 s = rpc.patch_get_mbox(patch_id)

219

220 if patch == {} or len(s) == 0:

221 sys.stderr.write("Unable to get patch %d\n" % patch_id)

222 sys.exit(1)

223

224 base_fname = fname = os.path.basename(patch['filename'])

225 i = 0

226 while os.path.exists(fname):

227 fname = "%s.%d" % (base_fname, i)

228 i += 1

229

230 try:

231 f = open(fname, "w")

232 except:

233 sys.stderr.write("Unable to open %s for writing\n" % fname)

234 sys.exit(1)

235

236 try:

237 f.write(s)

238 f.close()

239 print "Saved patch to %s" % fname

240 except:

241 sys.stderr.write("Failed to write to %s\n" % fname)

242 sys.exit(1)

243

244 def action_apply(rpc, patch_id):

245 patch = rpc.patch_get(patch_id)

246 if patch == {}:

247 sys.stderr.write("Error getting information on patch ID %d\n" % \

248 patch_id)

249 sys.exit(1)

250 print "Applying patch #%d to current directory" % patch_id

251 print "Description: %s" % patch['name']

252 s = rpc.patch_get_mbox(patch_id)

253 if len(s) > 0:

254 proc = subprocess.Popen(['patch', '-p1'], stdin = subprocess.PIPE)

255 proc.communicate(s)

256 else:

257 sys.stderr.write("Error: No patch content found\n")

258 sys.exit(1)

259

260 def action_update_patch(rpc, patch_id, state = None, commit = None):

261 patch = rpc.patch_get(patch_id)

262 if patch == {}:

263 sys.stderr.write("Error getting information on patch ID %d\n" % \

264 patch_id)

265 sys.exit(1)

266

267 params = {}

268

269 if state:

270 state_id = state_id_by_name(rpc, state)

271 if state_id == 0:

272 sys.stderr.write("Error: No State found matching %s*\n" % state)

273 sys.exit(1)

274 params['state'] = state_id

275

276 if commit:

277 params['commit_ref'] = commit

278

279 success = False

280 try:

281 success = rpc.patch_set(patch_id, params)

282 except xmlrpclib.Fault, f:

283 sys.stderr.write("Error updating patch: %s\n" % f.faultString)

284

285 if not success:

286 sys.stderr.write("Patch not updated\n")

287

288 def patch_id_from_hash(rpc, hash):

289 patch = rpc.patch_get_by_hash(hash)

290 if patch == {}:

291 return None

292

293 return patch['id']

294

295 auth_actions = ['update']

296

297 def main():

298 try:

299 opts, args = getopt.getopt(sys.argv[2:], 's:p:w:d:n:c:h:')

300 except getopt.GetoptError, err:

301 print str(err)

302 usage()

303

304 if len(sys.argv) < 2:

305 usage()

306

307 action = sys.argv[1].lower()

308

309 # set defaults

310 filt = Filter()

311 submitter_str = ""

312 delegate_str = ""

313 project_str = ""

314 commit_str = ""

315 state_str = ""

316 hash_str = ""

317 url = DEFAULT_URL

318

319 config = ConfigParser.ConfigParser()

320 config.read(CONFIG_FILES)

321

322 # grab settings from config files

323 if config.has_option('base', 'url'):

324 url = config.get('base', 'url')

325

326 if config.has_option('base', 'project'):

327 project_str = config.get('base', 'project')

328

329 for name, value in opts:

330 if name == '-s':

331 state_str = value

332 elif name == '-p':

333 project_str = value

334 elif name == '-w':

335 submitter_str = value

336 elif name == '-d':

337 delegate_str = value

338 elif name == '-c':

339 commit_str = value

340 elif name == '-h':

341 hash_str = value

342 elif name == '-n':

343 try:

344 filt.add("max_count", int(value))

345 except:

346 sys.stderr.write("Invalid maximum count '%s'\n" % value)

347 usage()

348 else:

349 sys.stderr.write("Unknown option '%s'\n" % name)

350 usage()

351

352 if len(args) > 1:

353 sys.stderr.write("Too many arguments specified\n")

354 usage()

355

356 (username, password) = (None, None)

357 transport = None

358 if action in auth_actions:

359 if config.has_option('auth', 'username') and \

360 config.has_option('auth', 'password'):

361

362 transport = BasicHTTPAuthTransport( \

363 config.get('auth', 'username'),

364 config.get('auth', 'password'))

365

366 else:

367 sys.stderr.write(("The %s action requires authentication, "

368 "but no username or password\nis configured\n") % action)

369 sys.exit(1)

370

371 if project_str:

372 filt.add("project", project_str)

373

374 if state_str:

375 filt.add("state", state_str)

376

377 try:

378 rpc = xmlrpclib.Server(url, transport = transport)

379 except:

380 sys.stderr.write("Unable to connect to %s\n" % url)

381 sys.exit(1)

382

383 patch_id = None

384 if hash_str:

385 patch_id = patch_id_from_hash(rpc, hash_str)

386 if patch_id is None:

387 sys.stderr.write("No patch has the hash provided")

388 sys.exit(1)

389

390

391 if action == 'list' or action == 'search':

392 if len(args) > 0:

393 filt.add("name__icontains", args[0])

394 action_list(rpc, filt, submitter_str, delegate_str)

395

396 elif action.startswith('project'):

397 action_projects(rpc)

398

399 elif action.startswith('state'):

400 action_states(rpc)

401

402 elif action == 'view':

403 try:

404 patch_id = patch_id or int(args[0])

405 except:

406 sys.stderr.write("Invalid patch ID given\n")

407 sys.exit(1)

408

409 s = rpc.patch_get_mbox(patch_id)

410 if len(s) > 0:

411 print s

412

413 elif action == 'get' or action == 'save':

414 try:

415 patch_id = patch_id or int(args[0])

416 except:

417 sys.stderr.write("Invalid patch ID given\n")

418 sys.exit(1)

419

420 action_get(rpc, patch_id)

421

422 elif action == 'apply':

423 try:

424 patch_id = patch_id or int(args[0])

425 except:

426 sys.stderr.write("Invalid patch ID given\n")

427 sys.exit(1)

428

429 action_apply(rpc, patch_id)

430

431 elif action == 'update':

432 try:

433 patch_id = patch_id or int(args[0])

434 except:

435 sys.stderr.write("Invalid patch ID given\n")

436 sys.exit(1)

437

438 action_update_patch(rpc, patch_id, state = state_str,

439 commit = commit_str)

440

441 else:

442 sys.stderr.write("Unknown action '%s'\n" % action)

443 usage()

444

445 if __name__ == "__main__":

446 main()