#
-# buildservice.py - Buildservice API support for Yabsc
+# buildservice.py - Buildservice API
#
-# Copyright (C) 2008 James Oakley <jfunk@opensuse.org>
-# Copyright (C) 2010, 2011, 2012 Intel, Inc.
+# Copyright (C) 2010, 2011, 2012, 2013 Intel, Inc.
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
import os
import string
-import sys
import shutil
-import tempfile
-import time
import urllib2
import M2Crypto
import xml.etree.cElementTree as ElementTree
-from collections import defaultdict
-from pwd import getpwnam
-import errors
-from osc import conf, core
-
-class ObsError(Exception):
- pass
-
-# Injection code for osc.core to fix the empty XML bug
-def solid_get_files_meta(self, revision='latest', skip_service=True):
- from time import sleep
+from gitbuildsys.errors import ObsError
+from gitbuildsys.oscapi import OSC
- retry_count = 3
- while retry_count > 0:
- fm = core.show_files_meta(self.apiurl, self.prjname, self.name,
- revision=revision, meta=self.meta)
- try:
- root = core.ET.fromstring(fm)
- break
- except:
- print 'corrupted or empty obs server response ,retrying ...'
- sleep(1)
- retry_count -= 1
-
- if not retry_count:
- # all the re-try failed, abort
- raise ObsError('cannet fetch files meta xml from server')
-
- # look for "too large" files according to size limit and mark them
- for e in root.findall('entry'):
- size = e.get('size')
- if size and self.size_limit and int(size) > self.size_limit \
- or skip_service and (e.get('name').startswith('_service:') or e.get('name').startswith('_service_')):
- e.set('skipped', 'true')
- return core.ET.tostring(root)
-
-core.Package.get_files_meta = solid_get_files_meta
-
-class _Metafile:
- """
- _Metafile(url, input, change_is_required=False, file_ext='.xml')
-
- Implementation on osc.core.metafile that does not print to stdout
- """
-
- def __init__(self, url, input, change_is_required=False, file_ext='.xml'):
- self.url = url
- self.change_is_required = change_is_required
-
- (fd, self.filename) = tempfile.mkstemp(prefix = 'osc_metafile.', suffix = file_ext, dir = '/tmp')
-
- f = os.fdopen(fd, 'w')
- f.write(''.join(input))
- f.close()
-
- self.hash_orig = core.dgst(self.filename)
-
- def sync(self):
- hash = core.dgst(self.filename)
- if self.change_is_required == True and hash == self.hash_orig:
- os.unlink(self.filename)
- return True
-
- # don't do any exception handling... it's up to the caller what to do in case
- # of an exception
- core.http_PUT(self.url, file=self.filename)
- os.unlink(self.filename)
- return True
-
-# helper functions for class _ProjectFlags
-def _flag2bool(flag):
- """
- _flag2bool(flag) -> Boolean
- Returns a boolean corresponding to the string 'enable', or 'disable'
- """
+from osc import conf, core
- if flag == 'enable':
- return True
- elif flag == 'disable':
- return False
-
-def _bool2flag(b):
- """
- _bool2flag(b) -> String
-
- Returns 'enable', or 'disable' according to boolean value b
- """
- if b == True:
- return 'enable'
- elif b == False:
- return 'disable'
-
-class _ProjectFlags(object):
- """
- _ProjectFlags(bs, project)
-
- Represents the flags in project through the BuildService object bs
- """
-
- def __init__(self, bs, project):
- self.bs = bs
- self.tree = ElementTree.fromstring(self.bs.getProjectMeta(project))
-
- # The "default" flags, when undefined
- self.defaultflags = {'build': True,
- 'publish': True,
- 'useforbuild': True,
- 'debuginfo': False}
-
- # Figure out what arches and repositories are defined
- self.arches = {}
- self.repositories = {}
-
- # Build individual repository list
- for repository in self.tree.findall('repository'):
- repodict = {'arches': {}}
- self.__init_flags_in_dict(repodict)
- for arch in repository.findall('arch'):
- repodict['arches'][arch.text] = {}
- self.__init_flags_in_dict(repodict['arches'][arch.text])
- # Add placeholder in global arches
- self.arches[arch.text] = {}
- self.repositories[repository.get('name')] = repodict
-
- # Initialise flags in global arches
- for archdict in self.arches.values():
- self.__init_flags_in_dict(archdict)
-
- # A special repository representing the global and global arch flags
- self.allrepositories = {'arches': self.arches}
- self.__init_flags_in_dict(self.allrepositories)
-
- # Now populate the structures from the xml data
- for flagtype in ('build', 'publish', 'useforbuild', 'debuginfo'):
- flagnode = self.tree.find(flagtype)
- if flagnode:
- for node in flagnode:
- repository = node.get('repository')
- arch = node.get('arch')
-
- if repository and arch:
- self.repositories[repository]['arches'][arch][flagtype] = _flag2bool(node.tag)
- elif repository:
- self.repositories[repository][flagtype] = _flag2bool(node.tag)
- elif arch:
- self.arches[flagtype] = _flag2bool(node.tag)
- else:
- self.allrepositories[flagtype] = _flag2bool(node.tag)
-
- def __init_flags_in_dict(self, d):
- """
- __init_flags_in_dict(d)
+class BuildService(OSC):
+ """Interface to Build Service API"""
- Initialize all build flags to None in d
- """
- d.update({'build': None,
- 'publish': None,
- 'useforbuild': None,
- 'debuginfo': None})
+ def __init__(self, apiurl, oscrc):
+ OSC.__init__(self, apiurl, oscrc)
- def save(self):
+ def getSrcFileList(self, project, package, revision=None):
+ """ get source file list of prj/pac
"""
- save()
+ return core.meta_get_filelist(self.apiurl, project, package, expand=True, revision=revision)
- Save flags
+ def getSrcFileContent(self, project, package, path, revision=None):
+ """ Cat remote file
"""
- for flagtype in ('build', 'publish', 'useforbuild', 'debuginfo'):
- # Clear if set
- flagnode = self.tree.find(flagtype)
- if flagnode:
- self.tree.remove(flagnode)
-
- # Generate rule nodes
- rulenodes = []
-
- # globals
- if self.allrepositories[flagtype] != None:
- rulenodes.append(ElementTree.Element(_bool2flag(self.allrepositories[flagtype])))
- for arch in self.arches:
- if self.arches[arch][flagtype] != None:
- rulenodes.append(ElementTree.Element(_bool2flag(self.arches[arch][flagtype]), arch=arch))
-
- # repositories
- for repository in self.repositories:
- if self.repositories[repository][flagtype] != None:
- rulenodes.append(ElementTree.Element(_bool2flag(self.repositories[repository][flagtype]), repository=repository))
- for arch in self.repositories[repository]['arches']:
- if self.repositories[repository]['arches'][arch][flagtype] != None:
- rulenodes.append(ElementTree.Element(_bool2flag(self.repositories[repository]['arches'][arch][flagtype]), arch=arch, repository=repository))
-
- # Add nodes to tree
- if rulenodes:
- from pprint import pprint
- pprint(rulenodes)
- flagnode = ElementTree.Element(flagtype)
- self.tree.insert(3, flagnode)
- for rulenode in rulenodes:
- flagnode.append(rulenode)
-
- print ElementTree.tostring(self.tree)
-
-class BuildService(object):
- """Interface to Build Service API"""
-
- def __init__(self, apiurl=None, oscrc=None):
- if oscrc:
- try:
- conf.get_config(override_conffile = oscrc)
- except OSError, e:
- if e.errno == 1:
- # permission problem, should be the chmod(0600) issue
- raise RuntimeError, 'Current user has no write permission for specified oscrc: %s' % oscrc
-
- raise # else
- except urllib2.URLError:
- raise errors.ObsError("invalid service apiurl: %s" % apiurl)
- else:
- conf.get_config()
-
- if apiurl:
- self.apiurl = apiurl
+ rev = core.show_upstream_xsrcmd5(self.apiurl, project, package, revision=revision)
+ if rev:
+ query = { 'rev': rev }
else:
- self.apiurl = conf.config['apiurl']
+ query = None
- def getAPIServerList(self):
- """getAPIServerList() -> list
+ u = core.makeurl(self.apiurl, ['source', project, package, core.pathname2url(path)], query=query)
- Get list of API servers configured in .oscrc
- """
- apiservers = []
- for host in conf.config['api_host_options'].keys():
- apiurl = "%s://%s" % (conf.config['scheme'], host)
- return apiservers
+ content = ''
+ for buf in core.streamfile(u, core.http_GET, core.BUFSIZE):
+ content += buf
- # the following two alias api are added temporarily for compatible safe
- def is_new_package(self, dst_project, dst_package):
- return self.isNewPackage(dst_project, dst_package)
- def gen_req_info(self, reqid, show_detail = True):
- return self.genRequestInfo(reqid, show_detail)
+ # return unicode str
+ return content.decode('utf8')
def isNewPackage(self, dst_project, dst_package):
"""Check whether the dst pac is a new one
if e.code == 404:
new_prj = True
else:
- raise errors.ObsError("%s" % e)
+ raise ObsError("%s" % e)
except (urllib2.URLError, M2Crypto.m2urllib2.URLError, \
M2Crypto.SSL.SSLError), e:
- raise errors.ObsError("%s" % e)
+ raise ObsError("%s" % e)
return new_prj
def genRequestInfo(self, reqid, show_detail = True):
return reqdiff
def _gen_server_diff(req):
- """ Reserved getter: get req diff, if and only if the recommanded getter failed
+ """ Reserved getter: get req diff, if and only if the recommanded getter failed
"""
reqdiff = ''
dst_prj, dst_pkg,
msg, orev=orev, src_update=src_update)
- def reqAccept(self, reqid, msg=''):
- """ This method is called to accept a request
- Success: return None
- Failed: return string of error message
- """
-
- try:
- core.change_request_state(self.apiurl, reqid, 'accepted', message=msg, supersed=None)
- except Exception, e:
- return str(e)
-
- return None
-
def reqDecline(self, reqid, msg=''):
""" This method is called to decline a request
Success: return None
return None
- def reqRevoke(self, reqid, msg=''):
- """ This method is called to revoke a request
- Success: return None
- Failed: return string of error message
- """
-
- try:
- core.change_request_state(self.apiurl, reqid, 'revoked', message=msg, supersed=None)
- except Exception, e:
- return str(e)
-
- return None
-
- def reqReview(self, reqid, user='', group='', msg=''):
- """ This method is called to add review msg to a request
- Success: return None
- Failed: return string of error message
- """
- try:
- query = { 'cmd': 'addreview' }
- if user:
- query['by_user'] = user
- if group:
- query['by_group'] = group
- u = core.makeurl(self.apiurl, ['request', reqid], query=query)
- f = core.http_POST(u, data=msg)
- root = ElementTree.parse(f).getroot()
- root.get('code')
- except Exception, e:
- return str(e)
-
- return None
-
def reqSupersede(self, reqid, msg='', supersed=None):
""" This method is called to supersede a request
Success: return None
return None
- def getSrcFileList(self, project, package, revision=None):
- """ get source file list of prj/pac
- """
-
- return core.meta_get_filelist(self.apiurl, project, package, expand=True, revision=revision)
-
- def getSrcFileContent(self, project, package, path, revision=None):
- """ Cat remote file
- """
-
- rev = core.show_upstream_xsrcmd5(self.apiurl, project, package, revision=revision)
- if rev:
- query = { 'rev': rev }
- else:
- query = None
-
- u = core.makeurl(self.apiurl, ['source', project, package, core.pathname2url(path)], query=query)
-
- content = ''
- for buf in core.streamfile(u, core.http_GET, core.BUFSIZE):
- content += buf
-
- # return unicode str
- return content.decode('utf8')
-
- def getSrcFileChecksum(self, project, package, path, revision=None):
- """ getSrcFileChecksum(project, package, path, revision=None) -> string
- returns source md5 of a source file
- """
-
- query = {}
- query['expand'] = 1
- if revision:
- query['rev'] = revision
-
- u = core.makeurl(self.apiurl, ['source', project, package], query=query)
- f = core.http_GET(u)
- root = ElementTree.parse(f).getroot()
-
- for node in root.findall('entry'):
- if node.get('name') == path:
- return node.get('md5')
-
- return None
-
- def getPackageChecksum(self, project, package, revision=None):
- """ getPackageChecksum(project, package, revision=None) -> string
- returns srcmd5 of a package
- """
-
- query = {}
- query['expand'] = 1
- if revision:
- query['rev'] = revision
-
- u = core.makeurl(self.apiurl, ['source', project, package], query=query)
- f = core.http_GET(u)
- root = ElementTree.parse(f).getroot()
-
- return root.get('srcmd5')
-
- def getLinkinfo(self, project, package, revision=None):
- """ getLinkinfo(project, package, revision=None) -> (linked_prj, linked_pkg, linked_srcmd5)
- returns link info of a prj/pkg
- """
-
- query = {}
- query['expand'] = 1
- if revision:
- query['rev'] = revision
-
- u = core.makeurl(self.apiurl, ['source', project, package], query=query)
- f = core.http_GET(u)
- root = ElementTree.parse(f).getroot()
-
- for node in root.findall('linkinfo'):
- return (node.get('project'), node.get('package'), node.get('srcmd5'))
-
- return None
-
- def getUserData(self, user, *tags):
- """getUserData() -> str
-
- Get the user data
- """
- return core.get_user_data(self.apiurl, user, *tags)
-
- def getUserName(self):
- """getUserName() -> str
-
- Get the user name associated with the current API server
- """
- return conf.config['api_host_options'][self.apiurl]['user']
-
- def getProjectList(self):
- """getProjectList() -> list
-
- Get list of projects
- """
- return [project for project in core.meta_get_project_list(self.apiurl) if project != 'deleted']
-
- def getWatchedProjectList(self):
- """getWatchedProjectList() -> list
-
- Get list of watched projects
- """
- username = self.getUserName()
- tree = ElementTree.fromstring(''.join(core.get_user_meta(self.apiurl, username)))
- projects = []
- watchlist = tree.find('watchlist')
- if watchlist:
- for project in watchlist.findall('project'):
- projects.append(project.get('name'))
- homeproject = 'home:%s' % username
- if not homeproject in projects and homeproject in self.getProjectList():
- projects.append(homeproject)
- return projects
-
- def watchProject(self, project):
- """
- watchProject(project)
-
- Watch project
- """
- username = self.getUserName()
- data = core.meta_exists('user', username, create_new=False, apiurl=self.apiurl)
- url = core.make_meta_url('user', username, self.apiurl)
-
- person = ElementTree.fromstring(''.join(data))
- watchlist = person.find('watchlist')
- if not watchlist:
- watchlist = ElementTree.SubElement(person, 'watchlist')
- ElementTree.SubElement(watchlist, 'project', name=str(project))
-
- f = _Metafile(url, ElementTree.tostring(person))
- f.sync()
-
- def unwatchProject(self, project):
- """
- watchProject(project)
-
- Watch project
- """
- username = self.getUserName()
- data = core.meta_exists('user', username, create_new=False, apiurl=self.apiurl)
- url = core.make_meta_url('user', username, self.apiurl)
-
- person = ElementTree.fromstring(''.join(data))
- watchlist = person.find('watchlist')
- for node in watchlist:
- if node.get('name') == str(project):
- watchlist.remove(node)
- break
-
- f = _Metafile(url, ElementTree.tostring(person))
- f.sync()
-
def getRepoState(self, project):
targets = {}
print "==%s= %s=" %(self.apiurl, project)
targets[('/'.join((result.get('repository'), result.get('arch'))))] = result.get('state')
return targets
- def getResults(self, project):
- """getResults(project) -> (dict, list)
-
- Get results of a project. Returns (results, targets)
-
- results is a dict, with package names as the keys, and lists of result codes as the values
-
- targets is a list of targets, corresponding to the result code lists
- """
- results = {}
- targets = []
- tree = ElementTree.fromstring(''.join(core.show_prj_results_meta(self.apiurl, project)))
- for result in tree.findall('result'):
- targets.append('/'.join((result.get('repository'), result.get('arch'))))
- for status in result.findall('status'):
- package = status.get('package')
- code = status.get('code')
- if not package in results:
- results[package] = []
- results[package].append(code)
- return (results, targets)
-
- def getDiff(self, sprj, spkg, dprj, dpkg, rev):
- diff = ''
- diff += core.server_diff(self.apiurl, sprj, spkg, None,
- dprj, dpkg, rev, False, True)
- return diff
-
def getTargets(self, project):
"""
getTargets(project) -> list
targets.append('%s/%s' % (repo.get('name'), arch.text))
return targets
- def getPackageStatus(self, project, package):
- """
- getPackageStatus(project, package) -> dict
-
- Returns the status of a package as a dict with targets as the keys and status codes as the
- values
- """
- status = {}
- tree = ElementTree.fromstring(''.join(core.show_results_meta(self.apiurl, project, package)))
- for result in tree.findall('result'):
- target = '/'.join((result.get('repository'), result.get('arch')))
- statusnode = result.find('status')
- code = statusnode.get('code')
- details = statusnode.find('details')
- if details is not None:
- code += ': ' + details.text
- status[target] = code
- return status
-
- def getProjectDiff(self, src_project, dst_project):
- diffs = []
-
- packages = self.getPackageList(src_project)
- for src_package in packages:
- diff = core.server_diff(self.apiurl,
- dst_project, src_package, None,
- src_project, src_package, None, False)
- diffs.append(diff)
-
- return '\n'.join(diffs)
-
def getPackageList(self, prj, deleted=None):
query = {}
if deleted:
root = ElementTree.parse(f).getroot()
return [ node.get('name') for node in root.findall('entry') ]
- def getBinaryList(self, project, target, package):
- """
- getBinaryList(project, target, package) -> list
-
- Returns a list of binaries for a particular target and package
- """
-
- (repo, arch) = target.split('/')
- return core.get_binarylist(self.apiurl, project, repo, arch, package)
-
- def getBinary(self, project, target, package, file, path):
- """
- getBinary(project, target, file, path)
-
- Get binary 'file' for 'project' and 'target' and save it as 'path'
- """
-
- (repo, arch) = target.split('/')
- core.get_binary_file(self.apiurl, project, repo, arch, file, target_filename=path, package=package)
-
def getBuildLog(self, project, target, package, offset=0):
"""
getBuildLog(project, target, package, offset=0) -> str
u = core.makeurl(self.apiurl, ['build', project, repo, arch, package, '_log?nostream=1&start=%s' % offset])
return core.http_GET(u).read()
- def getWorkerStatus(self):
- """
- getWorkerStatus() -> list of dicts
-
- Get worker status as a list of dictionaries. Each dictionary contains the keys 'id',
- 'hostarch', and 'status'. If the worker is building, the dict will additionally contain the
- keys 'project', 'package', 'target', and 'starttime'
- """
-
- url = core.makeurl(self.apiurl, ['build', '_workerstatus'])
- f = core.http_GET(url)
- tree = ElementTree.parse(f).getroot()
- workerstatus = []
- for worker in tree.findall('building'):
- d = {'id': worker.get('workerid'),
- 'status': 'building'}
- for attr in ('hostarch', 'project', 'package', 'starttime'):
- d[attr] = worker.get(attr)
- d['target'] = '/'.join((worker.get('repository'), worker.get('arch')))
- d['started'] = time.asctime(time.localtime(float(worker.get('starttime'))))
- workerstatus.append(d)
- for worker in tree.findall('idle'):
- d = {'id': worker.get('workerid'),
- 'hostarch': worker.get('hostarch'),
- 'status': 'idle'}
- workerstatus.append(d)
- return workerstatus
-
- def getWaitStats(self):
- """
- getWaitStats() -> list
-
- Returns the number of jobs in the wait queue as a list of (arch, count)
- pairs
- """
-
- url = core.makeurl(self.apiurl, ['build', '_workerstatus'])
- f = core.http_GET(url)
- tree = ElementTree.parse(f).getroot()
- stats = []
- for worker in tree.findall('waiting'):
- stats.append((worker.get('arch'), int(worker.get('jobs'))))
- return stats
-
- def getSubmitRequests(self):
- """
- getSubmitRequests() -> list of dicts
-
- """
-
- url = core.makeurl(self.apiurl, ['search', 'request', '?match=submit'])
- f = core.http_GET(url)
- tree = ElementTree.parse(f).getroot()
- submitrequests = []
- for sr in tree.findall('request'):
- if sr.get('type') != "submit":
- continue
-
- d = {'id': int(sr.get('id'))}
- sb = sr.findall('submit')[0]
- src = sb.findall('source')[0]
- d['srcproject'] = src.get('project')
- d['srcpackage'] = src.get('package')
- dst = sb.findall('target')[0]
- d['dstproject'] = dst.get('project')
- d['dstpackage'] = dst.get('package')
- d['state'] = sr.findall('state')[0].get('name')
-
- submitrequests.append(d)
- submitrequests.sort(key=lambda x: x['id'])
- return submitrequests
-
- def rebuild(self, project, package, target=None, code=None):
- """
- rebuild(project, package, target, code=None)
-
- Rebuild 'package' in 'project' for 'target'. If 'code' is specified,
- all targets with that code will be rebuilt
- """
-
- if target:
- (repo, arch) = target.split('/')
- else:
- repo = None
- arch = None
- return core.rebuild(self.apiurl, project, package, repo, arch, code)
-
- def abortBuild(self, project, package=None, target=None):
- """
- abort(project, package=None, target=None)
-
- Abort build of a package or all packages in a project
- """
-
- if target:
- (repo, arch) = target.split('/')
- else:
- repo = None
- arch = None
- return core.abortbuild(self.apiurl, project, package, arch, repo)
-
- def getBuildHistory(self, project, package, target):
- """
- getBuildHistory(project, package, target) -> list
-
- Get build history of package for target as a list of tuples of the form
- (time, srcmd5, rev, versrel, bcnt)
- """
-
- (repo, arch) = target.split('/')
- u = core.makeurl(self.apiurl, ['build', project, repo, arch, package, '_history'])
- f = core.http_GET(u)
- root = ElementTree.parse(f).getroot()
-
- r = []
- for node in root.findall('entry'):
- rev = int(node.get('rev'))
- srcmd5 = node.get('srcmd5')
- versrel = node.get('versrel')
- bcnt = int(node.get('bcnt'))
- t = time.localtime(int(node.get('time')))
- t = time.strftime('%Y-%m-%d %H:%M:%S', t)
-
- r.append((t, srcmd5, rev, versrel, bcnt))
- return r
-
- def getCommitLog(self, project, package, revision=None):
- """
- getCommitLog(project, package, revision=None) -> list
-
- Get commit log for package in project. If revision is set, get just the
- log for that revision.
-
- Each log is a tuple of the form (rev, srcmd5, version, time, user,
- comment)
- """
-
- u = core.makeurl(self.apiurl, ['source', project, package, '_history'])
- f = core.http_GET(u)
- root = ElementTree.parse(f).getroot()
-
- r = []
- revisions = root.findall('revision')
- revisions.reverse()
- for node in revisions:
- rev = int(node.get('rev'))
- if revision and rev != int(revision):
- continue
- srcmd5 = node.find('srcmd5').text
- version = node.find('version').text
- user = node.find('user').text
- try:
- comment = node.find('comment').text
- except:
- comment = '<no message>'
- t = time.localtime(int(node.find('time').text))
- t = time.strftime('%Y-%m-%d %H:%M:%S', t)
-
- r.append((rev, srcmd5, version, t, user, comment))
- return r
-
def getProjectConfig(self, project):
"""
getProjectConfig(project) -> string
"""
return ''.join(core.show_project_conf(self.apiurl, project))
- def getProjectMeta(self, project):
- """
- getProjectMeta(project) -> string
-
- Get XML metadata for project
- """
-
- return ''.join(core.show_project_meta(self.apiurl, project))
-
- def getProjectData(self, project, tag):
- """
- getProjectData(project, tag) -> list
-
- Return a string list if node has text, else return the values dict list
- """
-
- data = []
- tree = ElementTree.fromstring(self.getProjectMeta(project))
- nodes = tree.findall(tag)
- if nodes:
- for node in nodes:
- node_value = {}
- for key in node.keys():
- node_value[key] = node.get(key)
-
- if node_value:
- data.append(node_value)
- else:
- data.append(node.text)
-
- return data
-
- def getProjectPersons(self, project, role):
- """
- getProjectPersons(project, role) -> list
-
- Return a userid list in this project with this role
- """
-
- userids = []
- persons = self.getProjectData(project, 'person')
- for person in persons:
- if person.has_key('role') and person['role'] == role:
- userids.append(person['userid'])
-
- return userids
-
- def getProjectDevel(self, project):
- """
- getProjectDevel(project) -> tuple (devel_prj, devel_pkg)
-
- Return the devel tuple of a project if it has the node, else return None
- """
-
- devels = self.getProjectData(project, 'devel')
- for devel in devels:
- if devel.has_key('project') and devel.has_key('package'):
- return (devel['project'], devel['package'])
-
- return None
-
- def getProjectLink(self, project):
- """
- getProjectLink(project) -> string
-
- Return the linked project of a project if it has the node, else return None
- """
-
- links = self.getProjectData(project, 'link')
- for link in links:
- if link.has_key('project'):
- return link['project']
-
- return None
-
def deleteProject(self, project):
"""
deleteProject(project)
-
+
Delete the specific project
"""
core.delete_project(self.apiurl, project)
except Exception:
return False
-
+
return True
def getPackageMeta(self, project, package):
return ''.join(core.show_package_meta(self.apiurl, project, package))
- def getPackageData(self, project, package, tag):
- """
- getPackageData(project, package, tag) -> list
-
- Return a string list if node has text, else return the values dict list
- """
-
- data = []
- tree = ElementTree.fromstring(self.getPackageMeta(project, package))
- nodes = tree.findall(tag)
- if nodes:
- for node in nodes:
- node_value = {}
- for key in node.keys():
- node_value[key] = node.get(key)
-
- if node_value:
- data.append(node_value)
- else:
- data.append(node.text)
-
- return data
-
def getPackageRealProjectName(self, project, package):
"""
getPackageRealProjectName(project, package) -> string
return realprj
- def getPackagePersons(self, project, package, role):
- """
- getPackagePersons(project, package, role) -> list
-
- Return a userid list in the package with this role
- """
-
- userids = []
- persons = self.getPackageData(project, package, 'person')
- for person in persons:
- if person.has_key('role') and person['role'] == role:
- userids.append(person['userid'])
-
- return userids
-
- def getPackageDevel(self, project, package):
- """
- getPackageDevel(project, package) -> tuple (devel_prj, devel_pkg)
-
- Return the devel tuple of a package if it has the node, else return None
- """
-
- devels = self.getPackageData(project, package, 'devel')
- for devel in devels:
- if devel.has_key('project') and devel.has_key('package'):
- return (devel['project'], devel['package'])
-
- return None
-
def deletePackage(self, project, package):
"""
deletePackage(project, package)
-
+
Delete the specific package in project
"""
core.delete_package(self.apiurl, project, package)
except Exception:
return False
-
- return True
- def projectFlags(self, project):
- """
- projectFlags(project) -> _ProjectFlags
-
- Return a _ProjectFlags object for manipulating the flags of project
- """
-
- return _ProjectFlags(self, project)
+ return True
def checkout(self, prj, pkg, rev='latest'):
""" checkout the package to current dir with link expanded
try:
core.Project(prj).commit(tuple([pac_path]), msg=msg, files=files)
except urllib2.HTTPError, e:
- raise errors.ObsError('%s' % e)
+ raise ObsError('%s' % e)
core.store_unlink_file(pac.absdir, '_commit_msg')
def branchPkg(self, src_project, src_package, rev=None, target_project=None, target_package=None):
return (targetprj, targetpkg)
- def get_buildconfig(self, prj, repository):
- return core.get_buildconfig(self.apiurl, prj, repository)
-
- def get_ArchitectureList(self, prj, target):
- """
- return the list of Archictecture of the target of the projectObsName for a OBS server.
- """
- url = core.makeurl(self.apiurl,['build', prj, target])
- f = core.http_GET(url)
- if f == None:
- return None
-
- aElement = ElementTree.fromstring(''.join(f.readlines()))
- result = []
- for directory in aElement:
- for entry in directory.getiterator():
- result.append(entry.get("name"))
-
- return result
-
- def get_results(self, prj, package):
- try:
- results = defaultdict(dict)
- build_status = core.get_results(self.apiurl, prj, package)
- for res in build_status:
- repo, arch, status = res.split()
- results[repo][arch] = status
- return results
- except (M2Crypto.m2urllib2.URLError, M2Crypto.SSL.SSLError), err:
- raise errors.ObsError(str(err))
-
- def get_buildlog(self, prj, package, repository, arch, offset = 0):
- """prints out the buildlog on stdout"""
- all_bytes = string.maketrans('', '')
- remove_bytes = all_bytes[:10] + all_bytes[11:32]
- try:
- log = self.getBuildLog(prj, '%s/%s' % (repository, arch), package)
- sys.stdout.write(log.translate(all_bytes, remove_bytes))
- except (M2Crypto.m2urllib2.URLError, M2Crypto.SSL.SSLError), err:
- raise errors.ObsError(str(err))
-
projects / services / jenkins-scripts.git / commitdiff