def _load_parameters(cls, masteruri, params, clear_params):
"""
Load parameters onto the parameter server
"""
import roslaunch
import roslaunch.launch
import xmlrpclib
param_server = xmlrpclib.ServerProxy(masteruri)
p = None
try:
# multi-call style xmlrpc
param_server_multi = xmlrpclib.MultiCall(param_server)
# clear specified parameter namespaces
# #2468 unify clear params to prevent error
for p in clear_params:
param_server_multi.deleteParam(rospy.get_name(), p)
r = param_server_multi()
# for code, msg, _ in r:
# if code != 1:
# raise StartException("Failed to clear parameter: %s"%(msg))
# multi-call objects are not reusable
param_server_multi = xmlrpclib.MultiCall(param_server)
for p in params.itervalues():
# suppressing this as it causes too much spam
#printlog("setting parameter [%s]"%p.key)
param_server_multi.setParam(rospy.get_name(), p.key, p.value)
r = param_server_multi()
for code, msg, _ in r:
if code != 1:
raise StartException("Failed to set parameter: %s" % (msg))
except roslaunch.core.RLException, e:
raise StartException(e)
def _load_parameters(masteruri, params, clear_params):
"""
Load parameters onto the parameter server
"""
param_server = xmlrpcclient.ServerProxy(masteruri)
p = None
abs_paths = list() # tuples of (parameter name, old value, new value)
not_found_packages = list() # packages names
param_errors = []
try:
socket.setdefaulttimeout(6 + len(clear_params))
# multi-call style xmlrpc
param_server_multi = xmlrpcclient.MultiCall(param_server)
# clear specified parameter namespaces
# #2468 unify clear params to prevent error
for p in clear_params:
param_server_multi.deleteParam(rospy.get_name(), p)
r = param_server_multi()
for code, msg, _ in r:
if code != 1 and not msg.find("is not set"):
rospy.logwarn("Failed to clear parameter: %s", msg)
# raise StartException("Failed to clear parameter: %s"%(msg))
# multi-call objects are not reusable
socket.setdefaulttimeout(6 + len(params))
param_server_multi = xmlrpcclient.MultiCall(param_server)
for pkey, pval in params.items():
value = pval
# resolve path elements
if isstring(value) and (value.startswith('$')):
value = interpret_path(value)
rospy.logdebug("interpret parameter '%s' to '%s'" %
(value, pval))
# add parameter to the multicall
param_server_multi.setParam(rospy.get_name(), pkey, value)
test_ret = _test_value(pkey, value)
if test_ret:
param_errors.extend(test_ret)
r = param_server_multi()
for code, msg, _ in r:
if code != 1:
raise exceptions.StartException("Failed to set parameter: %s" %
(msg))
except roslaunch.core.RLException as e:
raise exceptions.StartException(e)
except rospkg.ResourceNotFound as rnf:
raise exceptions.StartException(
"Failed to set parameter. ResourceNotFound: %s" % (rnf))
except Exception as e:
raise exceptions.StartException(
"Failed to set parameter. ROS Parameter Server "
"reports: %s\n\n%s" % (e, '\n'.join(param_errors)))
finally:
socket.setdefaulttimeout(None)
return abs_paths, not_found_packages
def _load_parameters(cls, masteruri, params, clear_params, user, pw,
auto_pw_request):
"""
Load parameters onto the parameter server
"""
import roslaunch
import roslaunch.launch
param_server = xmlrpclib.ServerProxy(masteruri)
p = None
abs_paths = list() # tuples of (parameter name, old value, new value)
not_found_packages = list() # packages names
try:
socket.setdefaulttimeout(6 + len(clear_params))
# multi-call style xmlrpc
param_server_multi = xmlrpclib.MultiCall(param_server)
# clear specified parameter namespaces
# #2468 unify clear params to prevent error
for p in clear_params:
param_server_multi.deleteParam(rospy.get_name(), p)
r = param_server_multi()
for code, msg, _ in r:
if code != 1 and not msg.find("is not set"):
rospy.logwarn("Failed to clear parameter: %s", msg)
# raise StartException("Failed to clear parameter: %s"%(msg))
# multi-call objects are not reusable
socket.setdefaulttimeout(6 + len(params))
param_server_multi = xmlrpclib.MultiCall(param_server)
for p in params.itervalues():
# suppressing this as it causes too much spam
value, is_abs_path, found, package = cls._resolve_abs_paths(
p.value,
nm.nameres().address(masteruri), user, pw, auto_pw_request)
if is_abs_path:
abs_paths.append((p.key, p.value, value))
if not found and package:
not_found_packages.append(package)
if p.value is None:
rospy.logwarn("The parameter '%s' is invalid: '%s'" %
(p.key, p.value))
#raise StartException("The parameter '%s' is invalid: '%s'"%(p.key, p.value))
else:
param_server_multi.setParam(
rospy.get_name(), p.key,
value if is_abs_path else p.value)
r = param_server_multi()
for code, msg, _ in r:
if code != 1:
raise StartException("Failed to set parameter: %s" % (msg))
except roslaunch.core.RLException, e:
raise StartException(e)
def package_releases(packages):
mcall = xmlrpclib.MultiCall(client)
called_packages = deque()
for package in packages:
mcall.package_releases(package, True)
called_packages.append(package)
if len(called_packages) == 100:
result = mcall()
mcall = xmlrpclib.MultiCall(client)
for releases in result:
yield called_packages.popleft(), releases
result = mcall()
for releases in result:
yield called_packages.popleft(), releases
def _unreg_on_finish(self):
with self.__lock_info:
self.__unregistered = True
try:
rospy.logdebug(" SyncThread[%s] clear all registrations", self.name)
socket.setdefaulttimeout(5)
own_master = xmlrpcclient.ServerProxy(self.masteruri_local)
own_master_multi = xmlrpcclient.MultiCall(own_master)
# end routine if the master was removed
for topic, _topictype, node, uri in self.__subscriber:
rospy.logdebug(" SyncThread[%s] unsibscribe %s [%s]" % (self.name, topic, node))
own_master_multi.unregisterSubscriber(node, topic, uri)
# TODO: unregister a remote subscriber while local publisher is still there
# Note: the connection between running components after unregistration is stil there!
for topic, _topictype, node, uri in self.__publisher:
rospy.logdebug(" SyncThread[%s] unadvertise %s [%s]" % (self.name, topic, node))
own_master_multi.unregisterPublisher(node, topic, uri)
for service, serviceuri, node, uri in self.__services:
rospy.logdebug(" SyncThread[%s] unregister service %s [%s]" % (self.name, service, node))
own_master_multi.unregisterService(node, service, serviceuri)
rospy.logdebug(" SyncThread[%s] execute a MultiCall", self.name)
_ = own_master_multi()
rospy.logdebug(" SyncThread[%s] finished", self.name)
except:
rospy.logerr("SyncThread[%s] ERROR while ending: %s", self.name, traceback.format_exc())
socket.setdefaulttimeout(None)
def wrapped_func(self, command):
# Dummy function, so that the string appears in a .po file
_ = lambda x: x
self.token = None
self.multicall = xmlrpclib.MultiCall(self.connection)
jid = command.jid
if type(jid) is not list:
jid = [jid]
try:
try:
self.get_auth_token(command.jid)
if self.token:
self.multicall.applyAuthToken(self.token)
function(self, command)
self.commands_out.put_nowait(command)
except xmlrpclib.Fault, fault:
msg = _("Your request has failed. The reason is:\n%(error)s")
self.log.error(str(fault))
self.report_error(jid, msg, {'error': fault.faultString})
except xmlrpclib.Error, err:
msg = _("A serious error occurred while processing your request:\n%(error)s")
self.log.error(str(err))
self.report_error(jid, msg, {'error': str(err)})
def release_data(packages):
mcall = xmlrpclib.MultiCall(client)
i = 0
for package, releases in package_releases(packages):
for version in releases:
mcall.release_urls(package, version)
mcall.release_data(package, version)
i += 1
if i % 50 == 49:
result = mcall()
mcall = xmlrpclib.MultiCall(client)
for urls, data in by_two(result):
yield urls, data
result = mcall()
for urls, data in by_two(result):
yield urls, data
def get_multi(self):
"""
@return: multicall XMLRPC proxy for communicating with master
@rtype: xmlrpclib.MultiCall
"""
import xmlrpclib
return xmlrpclib.MultiCall(self.get())
def registerais(registeredais):
print registeredais
multicall = xmlrpclib.MultiCall(getxmlrpcproxy())
for i in xrange( unitsync.GetSkirmishAICount() ):
shortname = ''
version = ''
for j in xrange( unitsync.GetSkirmishAIInfoCount(i) ):
if unitsync.GetInfoKey(j) == "shortName":
shortname = unitsync.GetInfoValue(j)
if unitsync.GetInfoKey(j) == "version":
version = unitsync.GetInfoValue(j)
if shortname != '' and version != '':
if registeredais.count( [ shortname, version ] ) == 0:
print "registering ai " + shortname + " version " + version + " ..."
multicall.registersupportedai( config.botrunnername, config.sharedsecret, shortname, version )
results = multicall()
successcount = 0
total = 0
for result in results:
total = total + 1
if result[0]:
successcount = successcount + 1
if total > 0:
print str(successcount) + " successes out of " + str(total)
def test(self):
try:
import xmlrpclib
except ImportError:
import xmlrpc.client as xmlrpclib
emailid = BMConfigParser().get('bitmessagesettings', 'apiusername')
password = BMConfigParser().get('bitmessagesettings', 'apipassword')
uri = 'http://%s:%s@%s:%d/' % (emailid, password, self.interface, self.port)
ret = False
try:
api = xmlrpclib.ServerProxy(uri)
print('api: %s' % api)
response = api.system.listMethods()
if response:
print('Methods = %s' % response)
print('MultiCall...')
multi = xmlrpclib.MultiCall(api)
multi.add(1, 2)
multi.add(2, 3)
for response in multi():
print(response)
ret = True
except TypeError as err: # unsupported XML-RPC protocol
print('XML-RPC not initialed correctly. {%s}\n' % str(err))
except xmlrpclib.Fault as err:
print('API returns Fault error. {%s}\n' % str(err))
except Exception as err: # /httplib.BadStatusLine: connection close immediatly
print('Unexpected error. {%s}\n' % sys.exc_info()[0])
if ret is False:
logger.exception(err)
return ret
def call(self):
"""Execute added multicall calls
@return: the results (post-processed), in the order they were added
@rtype: tuple
"""
m = xmlrpclib.MultiCall(self.rt_obj._get_conn())
for call in self.calls:
method, args = call
rpc_call = getattr(method, "rpc_call")
getattr(m, rpc_call)(*args)
results = m()
results = tuple(results)
results_processed = []
for r, c in zip(results, self.calls):
method = c[0] # Method instance
result = process_result(method, r)
results_processed.append(result)
# assign result to class_obj
exists = hasattr(self.class_obj, method.varname)
if not exists or not inspect.ismethod(getattr(self.class_obj, method.varname)):
setattr(self.class_obj, method.varname, result)
return(tuple(results_processed))
def _multicall(self):
'''This returns kind of a mash-up of the Bugzilla object and the
xmlrpclib.MultiCall object. Methods you call on this object will be
added to the MultiCall queue, but they will return None. When you're
ready, call the run() method and all the methods in the queue will be
run and the results of each will be returned in a list. So, for example:
mc = bz._multicall()
mc._getbug(1)
mc._getbug(1337)
mc._query({'component':'glibc','product':'Fedora','version':'devel'})
(bug1, bug1337, queryresult) = mc.run()
Note that you should only use the raw xmlrpc calls (mostly the methods
starting with an underscore). Normal getbug(), for example, tries to
return a _Bug object, but with the multicall object it'll end up empty
and, therefore, useless.
Further note that run() returns a list of raw xmlrpc results; you'll
need to wrap the output in Bug objects yourself if you're doing that
kind of thing. For example, Bugzilla.getbugs() could be implemented:
mc = self._multicall()
for id in idlist:
mc._getbug(id)
rawlist = mc.run()
return [_Bug(self,dict=b) for b in rawlist]
'''
mc = copy.copy(self)
mc._proxy = xmlrpclib.MultiCall(self._proxy)
def run(): return mc._proxy().results
mc.run = run
return mc
def convert_wiki(source, dest, dest_project_id):
if overwrite and (method == 'direct'):
dest.clear_wiki_attachments(dest_project_id)
exclude_authors = [a.strip() for a in config.get('wiki', 'exclude_authors').split(',')]
target_directory = config.get('wiki', 'target-directory')
server = xmlrpclib.MultiCall(source)
for name in source.wiki.getAllPages():
info = source.wiki.getPageInfo(name)
if (info['author'] not in exclude_authors):
page = source.wiki.getPage(name)
print("Page %s:%s" % (name, info))
if (name == 'WikiStart'):
name = 'home'
converted = trac2down.convert(page, os.path.dirname('/wikis/%s' % name))
if method == 'direct':
for attachment in source.wiki.listAttachments(name):
print(attachment)
binary_attachment = source.wiki.getAttachment(attachment).data
try:
attachment_path = dest.create_wiki_attachment(dest_project_id, users_map[info['author']], convert_xmlrpc_datetime(info['lastModified']), attachment, binary_attachment)
except KeyError:
attachment_path = dest.create_wiki_attachment(dest_project_id, default_user, convert_xmlrpc_datetime(info['lastModified']), attachment, binary_attachment)
attachment_name = attachment.split('/')[-1]
converted = converted.replace(r'](%s)' % attachment_name, r'](%s)' % os.path.relpath(attachment_path, '/namespace/project/wiki/page'))
trac2down.save_file(converted, name, info['version'], info['lastModified'], info['author'], target_directory)
def collect_users(source):
get_all_tickets = xmlrpclib.MultiCall(source)
for ticket in source.ticket.query("max=0&order=id"):
get_all_tickets.ticket.get(ticket)
ticket_index = 0
for src_ticket in get_all_tickets():
src_ticket_id = src_ticket[0]
src_ticket_data = src_ticket[3]
print("ticket id: %s" % src_ticket_id)
print("ticket index: %s" % ticket_index)
print("owner: %s" % src_ticket_data['owner'])
print("reporter: %s" % src_ticket_data['reporter'])
ticket_owners.add(src_ticket_data['owner'])
ticket_reporters.add(src_ticket_data['reporter'])
changelog = source.ticket.changeLog(src_ticket_id)
for change in changelog:
change_type = change[2]
if (change_type == "comment") and change[4] != '':
print "ticket message poster: ", change[1]
ticket_message_posters.add(change[1])
ticket_index += 1
def get_pages(self, **kwargs):
options = {
"include_revno": True,
"include_deleted": True,
"exclude_non_writable": kwargs["exclude_non_writable"],
"include_underlay": False,
"prefix": self.prefix,
"pagelist": self.pagelist,
"mark_deleted": True
}
if self.token:
m = xmlrpclib.MultiCall(self.connection)
m.applyAuthToken(self.token)
m.getAllPagesEx(options)
tokres, pages = m()
else:
pages = self.connection.getAllPagesEx(options)
rpages = []
for name, revno in pages:
normalised_name = normalise_pagename(name, self.prefix)
if normalised_name is None:
continue
if abs(revno) != 99999999: # I love sane in-band signalling
remote_rev = abs(revno)
remote_deleted = revno < 0
rpages.append(
SyncPage(normalised_name,
remote_rev=remote_rev,
remote_name=name,
remote_deleted=remote_deleted))
return rpages
def run(self):
'''
'''
if self._masteruri:
result = dict()
for p in self._params:
result[p] = None
try:
name = rospy.get_name()
master = xmlrpclib.ServerProxy(self._masteruri)
param_server_multi = xmlrpclib.MultiCall(master)
for p in self._params:
param_server_multi.getParam(name, p)
r = param_server_multi()
for index, (code, msg, value) in enumerate(r):
result[self._params[index]] = (code, msg, value)
self.parameter_values_signal.emit(self._masteruri, 1, '',
result)
except Exception:
import traceback
# err_msg = "Error while retrieve parameter values from %s: %s"%(self._masteruri, traceback.format_exc(1))
# rospy.logwarn(err_msg)
# lines = traceback.format_exc(1).splitlines()
self.parameter_values_signal.emit(self._masteruri, -1,
traceback.format_exc(1),
result)
def run(self):
'''
'''
if self._masteruri:
result = dict()
names = self._params.keys()
for p in names:
result[p] = None
try:
name = rospy.get_name()
master = xmlrpclib.ServerProxy(self._masteruri)
param_server_multi = xmlrpclib.MultiCall(master)
for p, v in self._params.items():
param_server_multi.setParam(name, p, v)
r = param_server_multi()
for index, (code, msg, value) in enumerate(r):
result[names[index]] = (code, msg, value)
self.result_signal.emit(self._masteruri, 1, '', result)
except Exception:
import traceback
err_msg = "Error while deliver parameter values to %s: %s" % (
self._masteruri, traceback.format_exc(1))
rospy.logwarn(err_msg)
# lines = traceback.format_exc(1).splitlines()
self.result_signal.emit(self._masteruri, -1, err_msg, result)
def get(self, tid):
try:
tid = int(tid)
mc = xmlrpclib.MultiCall(trac.server)
mc.ticket.get(tid)
mc.ticket.changeLog(tid)
mc.ticket.listAttachments(tid)
mc.ticket.getActions(tid)
ticket, changelog, attachments, actions = [c for c in mc()]
self.current = {
'id': tid,
'_ts': ticket[3].get('_ts'),
'summary': ticket[3]['summary'],
'description': ticket[3]['description'],
}
self.get_actions(actions=actions)
self.attachments = [a[0] for a in attachments]
except (TypeError, ValueError):
return 'Please select a ticket'
except Exception as e:
return 'An error occured:\n\t{0}'.format(e)
sticket = ['= Ticket #{0} ='.format(tid), '']
for f in self.fields:
if f['name'] == 'description':
continue
if f['type'] == 'time':
v = get_time(ticket[3][f['name']], True)
else:
v = ticket[3].get(f['name'], '')
sticket.append(u' * {0:>{2}}: {1}'.format(f['label'], v,
self.max_label_width))
sticket.extend([
'', '= Description =', '', ticket[3]['description'], '',
'= Changelog ='
])
ctime = [None, None]
for change in changelog:
if not change[4] or change[2].startswith('_'):
continue
my_time = get_time(change[0], True)
nctime = [my_time, change[1]]
if ctime != nctime:
sticket.extend(['', u'== {0} ({1}) =='.format(*nctime), ''])
ctime = nctime
if change[2] == 'comment':
sticket.append(change[4])
elif change[2] in ('summary', 'description'):
sticket.append('{0} changed'.format(change[2]))
else:
changes = (self.get_label(change[2]), change[3], change[4])
csf = u' * {0}: {1} > {2}' if change[3] else u' * {0}: {2}'
sticket.append(csf.format(*changes))
sticket.extend(['', '== Action ==', ''])
sticket.extend([' - {0}'.format(action[0]) for action in actions])
return u'\n'.join(sticket)
def _unreg_on_finish(self):
with self.__lock_info:
self.__unregistered = True
try:
rospy.logdebug(" SyncThread[%s] clear all registrations",
self.name)
socket.setdefaulttimeout(5)
own_master = xmlrpclib.ServerProxy(self.masteruri_local)
own_master_multi = xmlrpclib.MultiCall(own_master)
# end routine if the master was removed
for topic, node, uri in self.__subscriber:
own_master_multi.unregisterSubscriber(node, topic, uri)
for topic, node, uri in self.__publisher:
own_master_multi.unregisterPublisher(node, topic, uri)
for service, serviceuri, node, uri in self.__services:
own_master_multi.unregisterService(node, service,
serviceuri)
rospy.logdebug(" SyncThread[%s] execute a MultiCall",
self.name)
_ = own_master_multi()
rospy.logdebug(" SyncThread[%s] finished", self.name)
except:
rospy.logerr("SyncThread[%s] ERROR while ending: %s",
self.name, traceback.format_exc())
socket.setdefaulttimeout(None)
def update(self, info_hash, fields):
multi_call = xmlrpclib.MultiCall(self._server)
for key, val in fields.iteritems():
method_name = 'd.%s.set' % key
getattr(multi_call, method_name)(info_hash, str(val))
return multi_call()[0]
def run(self):
print("Starting On " + self.stressWorker)
server = xmlrpclib.ServerProxy("http://" + self.stressWorker + ":8001")
multi = xmlrpclib.MultiCall(server)
multi.do_run(self.cpuStress, self.memStress, self.killTimeout)
multi.do_kill(self.killTimeout)
for response in multi():
print(str(response))
def query_tickets(self, query):
""" Queries a server for tickets matching the query string """
multicall = xmlrpc.MultiCall(self.proxy)
try:
ticket_ids = self.proxy.ticket.query(query)
except xmlrpc.Fault, e:
raise CallFailed, "Code %s: %s" % (e.faultCode,
e.faultString)
def getToc(proxy):
mc = xmlrpclib.MultiCall(proxy)
auth_token = proxy.getAuthToken(name, password)
mc.applyAuthToken(auth_token)
mc.getAllPages()
result = mc()
return result[0], result[1]
def run_client(host, port):
proxy = xmlrpclib.ServerProxy("http://%s:%s/" % (host, port))
multicall = xmlrpclib.MultiCall(proxy)
multicall.add(7, 3)
multicall.subtract(7, 3)
multicall.multiply(7, 3)
multicall.divide(7, 3)
result = multicall()
print "7+3:%d, 7-3:%d, 7*3:%d, 7/3:%d" % tuple(result)
def update(self): """Retrieve the latest data about a file.""" m = xmlrpclib.MultiCall(self.server) m.f.get_path(self['hash'], self['index']) m.f.get_priority(self['hash'], self['index']) results = m() self['name'] = results[0] self['priority'] = results[1]
def run_client(host, port):
# client code
proxy = xmlrpclib.ServerProxy("http://%s:%s/" % (host, port))
multicall = xmlrpclib.MultiCall(proxy)
multicall.add(10, 5)
multicall.subtract(10, 5)
multicall.multiply(10, 5)
multicall.divide(10, 5)
result = multicall()
print "10+5=%d, 10-5=%d, 10*5=%d, 10/5=%d" % tuple(result)
def convert_wiki(source, dest):
exclude_authors = ['trac']
if not os.path.isdir(wiki_export_dir):
os.makedirs(wiki_export_dir)
xmlrpclib.MultiCall(source)
for pagename in source.wiki.getAllPages():
info = source.wiki.getPageInfo(pagename)
if info['author'] in exclude_authors:
continue
page = source.wiki.getPage(pagename)
print "Migrate Wikipage", pagename
if pagename == 'WikiStart':
pagename = 'Home'
converted = trac2markdown(page, os.path.dirname('/wiki/%s' % pagename))
attachments = []
for attachment in source.wiki.listAttachments(
pagename if pagename != 'Home' else 'WikiStart'):
print " Attachment", attachment
attachmentname = os.path.basename(attachment)
attachmentdata = source.wiki.getAttachment(attachment).data
dirname = os.path.join(wiki_export_dir, pagename)
if not os.path.isdir(dirname):
os.makedirs(dirname)
# write attachment data to binary file
open(os.path.join(dirname, attachmentname),
'wb').write(attachmentdata)
attachmenturl = pagename + '/' + attachmentname
converted = re.sub(
r'\[attachment:%s\s([^\[\]]+)\]' % re.escape(attachmentname),
r'[\1](%s)' % attachmenturl, converted)
attachments.append((attachmentname, attachmenturl))
# add a list of attachments
if len(attachments) > 0:
converted += '\n---\n\nAttachments:\n'
for (name, url) in attachments:
converted += ' * [' + name + '](' + url + ')\n'
# TODO we could use the GitHub API to write into the Wiki repository of the GitHub project
try:
open(os.path.join(wiki_export_dir, pagename + '.md'),
'w').write(converted)
except UnicodeEncodeError as e:
print 'EXCEPTION:', e
print ' Context:', e.object[e.start - 20:e.end + 20]
print ' Retrying with UTF-8 encoding'
codecs.open(os.path.join(wiki_export_dir, pagename + '.md'), 'w',
'utf-8').write(converted)
def get_changelogs(self, tickets):
"""
Queries the server for multiple changelogs
Returns a dict of {ticket_id: log}
"""
multicall = xmlrpc.MultiCall(self.proxy)
for ticket in tickets:
multicall.ticket.changeLog(ticket.id)
ticket_ids = [ticket.id for ticket in tickets]
logs = [log for log in multicall()]
return dict(zip(ticket_ids, logs))
def registercapabilities(): multicall = xmlrpclib.MultiCall(getxmlrpcproxy()) multicall.getsupportedmaps( config.botrunnername, config.sharedsecret ) multicall.getsupportedmods( config.botrunnername, config.sharedsecret ) multicall.getsupportedais( config.botrunnername, config.sharedsecret ) resultsets = multicall() registeredmaps = resultsets[0] registeredmods = resultsets[1] registeredais = resultsets[2] registermaps(registeredmaps) registermods(registeredmods) registerais(registeredais)
def migrate_tickets(self):
print("Loading information from Trac…", file=sys.stderr)
get_all_tickets = xmlrpclib.MultiCall(self.trac)
for ticket in self.trac.ticket.query("max=0&order=id"):
get_all_tickets.ticket.get(ticket)
# Take the memory hit so we can rewrite ticket references:
all_trac_tickets = list(get_all_tickets())
all_trac_tickets.sort(key=lambda t: int(t[0]))
print ("Creating GitHub tickets…", file=sys.stderr)
for trac_id, time_created, time_changed, attributes in all_trac_tickets:
title = "%s (Trac #%d)" % (attributes['summary'], trac_id)
body = self.fix_wiki_syntax(attributes['description'])
body += "\n\nMigrated from %s\n" % urljoin(self.trac_public_url, "/ticket/%d" % trac_id)
text_attributes = {k: convert_value_for_json(v) for k, v in attributes.items()}
body += "```json\n" + json.dumps(text_attributes, indent=4) + "\n```\n"
milestone = self.get_gh_milestone(attributes['milestone'])
assignee = self.get_github_username(attributes['owner'])
labels = []
# User does not exist in GitHub -> Add username as label
if (assignee is GithubObject.NotSet and (attributes['owner'] and attributes['owner'].strip())):
labels = self.get_mapped_labels('owner', attributes['owner'])
for attr in ('type', 'component', 'resolution', 'priority', 'keywords'):
labels += self.get_mapped_labels(attr, attributes.get(attr))
for i, j in self.gh_issues.items():
if i == title:
gh_issue = j
if (assignee is not GithubObject.NotSet and
(not gh_issue.assignee
or (gh_issue.assignee.login != assignee.login))):
gh_issue.edit(assignee=assignee)
break
else:
gh_issue = self.import_issue(title, assignee, body,
milestone, labels,
attributes, self.get_trac_comments(trac_id))
print ("\tInitiated issue: %s (%s)" % (title, gh_issue), file=sys.stderr)
self.gh_issues[title] = gh_issue
print("Checking completion…", file=sys.stderr)
for trac_id, time_created, time_changed, attributes in all_trac_tickets:
gh_issue = self.github_repo.get_issue(trac_id)
print("\t%s (%s)" % (gh_issue.title, gh_issue.html_url), file=sys.stderr)
