def getConnection(self):
self.semaforo.acquire(True)
if self._server is None:
self._server = Server(self._host, self.transport,
'utf-8') #,verbose=1
self.semaforo.release()
return self
def connect(self):
"""Get a handle to a remote connection."""
url = self.url
self.server = Server(url)
if self._user_name is not None and self._password is not None:
self.session = self.server.login(self._user_name, self._password)
return self
class XMLRPCRepository(RemoteRepository):
def __init__(self, location, verbose=False):
self.location = location
# an empty Environment to help with tracking packages
self.environment = Environment(search_path=[])
self.server = Server(self.location)
self._projects = None
self.tmpdir = mkdtemp(prefix="ensetuptools-")
self.verbose = verbose
@property
def projects(self):
if self._projects == None:
info("Scanning repository at %s..." % self.location)
for project in self.server.list_packages():
self._projects[project] = XMLRPCProject(self, project)
return self._projects
def search(self, combiner='and', **kwargs):
precise_terms = dict((key, value) for key, value in kwargs
if isinstance(value, basestring))
if precise_terms:
partial_match_names = set(partial_match['name']
for partial_match in
self.server.search(precise_terms,
combiner))
else:
partial_match_names = set(self.projects)
matches = []
for project in partial_match_names:
matches += self.projects[project].search(combiner, **kwargs)
return matches
def run(self, task_queue, uid, document_type, callback_url, callback_verb, expire, cloudooo_settings, sam_settings):
print 'Metadata extraction started...'
self._sam = Restfulie.at(sam_settings['url']).auth(*sam_settings['auth']).as_('application/json')
cloudooo = Server("%s/RPC2" % cloudooo_settings['url'])
response = loads(self._sam.get(key=uid).body)
doc = response['data']['file']
filename = response['data']['filename']
if not filename.endswith('pdf'):
print "Converting document to pdf..."
doc = cloudooo.convertFile(doc, filename[-3:], 'pdf')
temp_doc = TemporaryFile(suffix=filename[:-3] + "pdf", delete=False)
print temp_doc.name, filename
temp_doc.write(decodestring(doc))
temp_doc.close()
extractor = {'tcc': TccExtractor, 'event': EventExtractor}
print "Extracting the metadata..."
metadata = extractor[document_type](temp_doc.name).all_metadata()
metadata_key = self._sam.post(value=metadata, expire=expire).resource().key
response['data']['metadata_key'] = metadata_key
self._sam.put(key=uid, value=response['data']).resource()
print "Metadata extraction complete. Sending callback task..."
send_task('nsicloudooomanager.tasks.MetadataCallback',
args=(callback_url, callback_verb, uid, metadata_key),
queue=task_queue, routing_key=task_queue)
print "Metadata callback task sent."
def __init__ (self, service_url, print_message = False):
'''
This rewrites the xmlrpc function bindings to use a
decorator so that we can check the return status of the Slave
functions before returning them back to the client
It allows the client object to directly inherit all
of the Slave calls exposed on the server side to the
client side without writing ANOTHER lookup table.
'''
_orig_Method = xmlrpclib._Method
'''
XML-RPC doesn't support keyword arguments,
so we have to do it ourselves...
'''
class KeywordArgMethod(_orig_Method):
def __call__(self, *args, **kwargs):
args = list(args)
if kwargs:
args.append(("kwargs", kwargs))
return _orig_Method.__call__(self, *args)
xmlrpclib._Method = KeywordArgMethod
Server.__init__(self, service_url)
setattr(self, "_ServerProxy__request", self.slave_error_check(self._ServerProxy__request))
self.vms = {}
self.msattrs = None
self.msci = None
self.username = None
self.print_message = print_message
self.last_refresh = datetime_datetime.now()
def main():
try:
global agent_lastrun
agent_lastrun = time()
broker = Server(server_uri)
server_version = broker.bap_version()
if server_version == agent_version:
#TODO: check for files modified since our last run...
while 1:
# recursively crawl folders in our list and find files with the archive bit set.
agent_thisrunstarted = time()
for root, dirs, files in walk(agent_rootdir):
for filename in files:
#TODO: any OS specific things will have to be done here?
fullname = join(root, filename)
modtime = stat(fullname).st_mtime
if agent_lastrun < modtime:
#TODO: this is a file-update, handle it accordingly
print agent_lastrun, modtime, fullname
sleep(agent_timebetweenchecks)
agent_lastrun = agent_thisrunstarted
#TODO: we need a clever way of handling deletes and/or renames!!!
else:
#TODO: handle agent/version mismatch by prompting agent to upgrade.
print "oops! version mismatch!"
except KeyboardInterrupt:
#TODO: call signal_handle_sigterm()
exit(1)
def run(self, port=11111, hostname='localhost', verbose=False):
url = "http://" + hostname + ":" + str(port)
if verbose:
self.outf.write('Stopping xmlrpc service on ' + url + '\n')
self.outf.flush()
from xmlrpclib import Server
server = Server(url)
server.quit()
def __init__(self,ConfluenceURL,login='',password=''):
self.URL = ConfluenceURL
logger.info("Establishing Connection to confluence at %s" % ConfluenceURL)
self.session = Server(ConfluenceURL+'/rpc/xmlrpc').confluence2
logger.info("Connection established. Logging in as %s" % login)
self.token = self.session.login(login,password)
logger.info("Successfully logged in as %s" % login)
self.PDFsession = Server(ConfluenceURL+'/rpc/xmlrpc').pdfexport
def archive_recording(server_url, chan_id, start_time, quality):
""" Archive Recording
Helper function used call the xmlrpc server and archive a recording.
"""
try:
s = Server(server_url)
result = s.archive(chan_id, start_time, quality)
except Exception, e:
response = "Error Archiving Recording: %r" % e
def getProximity(self):
try:
s = Server("http://127.0.0.1:54000")
signal = s.getProximity(self.macAddress)
except:
signal = None
return signal
def getProximity(self):
try:
s = Server("http://127.0.0.1:54000")
signal = s.getProximity(self.macAddress)
except:
signal = None
return signal
def __init__(self,
proxy_address=(PROXY_ADDRESS, PROXY_PORT),
web_address=(WEB_ADDRESS, WEB_PORT)):
self._proxy = Server('http://%s:%s' % proxy_address, allow_none=True)
# print "Proxy: ",proxy_address
self.start_server(proxy_address, web_address)
self.data = None
self.type = None
self.url = None
self.width = 0
self.height = 0
def main():
s = Server("http://*****:*****@localhost:8080/exist/xmlrpc")
d = {
"data": urllib.urlopen("http://localhost:8081/status").read(),
}
res = s.xupdate("/db", Binary(upd % d))
if not res:
s.parse("<data/>", "/db/pycoon-status")
def main():
s = Server("http://*****:*****@localhost:8080/exist/xmlrpc")
d = {
"data": urllib.urlopen("http://localhost:8081/status").read(),
}
res = s.xupdate("/db", Binary(upd % d))
if not res:
s.parse("<data/>", "/db/pycoon-status")
def __init__(self, host=None, port=9123, force=0, **kwargs):
global _server
if not force and _server is not None:
self.server = _server
else:
if not host:
host = os.environ.get('PYMOL_RPCHOST', 'localhost')
_server = None
serv = Server('http://%s:%d' % (host, port))
serv.ping()
_server = serv
self.server = serv
self.InitializePyMol()
def __init__(self, host=None, port=9123, force=0, **kwargs):
global _server
if not force and _server is not None:
self.server = _server
else:
if not host:
host = os.environ.get("PYMOL_RPCHOST", "localhost")
_server = None
serv = Server("http://%s:%d" % (host, port))
serv.ping()
_server = serv
self.server = serv
self.InitializePyMol()
def _connect(self):
'''Connect to the remote server via XML-RPC HTTP; return status'''
# Now try to connect
self._connection = Server(self._make_sync_url())
# check whether the connection was made and the Master Babel Tower
# exists
try:
self._connection.getAllLanguages()
return 1 # pragma: no cover
except Exception:
self._connection = None
return 0
def validate_to_biomedtown(username, password):
""" *validate_to_biomedtown* method
This method check if the password is valid.
Return True or False.
"""
server = Server('https://%s:%s@%s/portal_towntool/' % (username, password, CREDENTIAL_MANAGER_URL))
try:
response = server.authService()
if response is not False:
return response
return False
except Exception, e:
return False
def main(argv=[]):
server = Server("http://localhost:11111")
try:
args = ['bzr']
[args.append(arg) for arg in argv[1:]]
exit_val, out, err = server.run_bzr_command(args, os.getcwd())
outf = setup_outf()
outf.write(out.data.decode(osutils.get_terminal_encoding(), 'replace'))
sys.stderr.write(err)
outf.flush()
sys.stderr.flush()
sys.exit(exit_val)
except Error, exc:
sys.stderr.write(exc.__repr__())
raise
def main(argv=[]):
server = Server("http://localhost:11111")
try:
args = ['bzr']
[args.append(arg) for arg in argv[1:]]
exit_val, out, err = server.run_bzr_command(args, os.getcwd())
outf = setup_outf()
outf.write(out.data.decode(osutils.get_terminal_encoding(), 'replace'))
sys.stderr.write(err)
outf.flush();
sys.stderr.flush();
sys.exit(exit_val)
except Error, exc:
sys.stderr.write(exc.__repr__())
raise
def importContent(self):
s = Server(self.server)
token = s.confluence1.login(self.login, self.passwd)
self.__remoteMkDirs(s, token, self.idestination)
destList = os.walk(self.idestination)
for root, subFolders, files in os.walk(self.idestination):
for folder in subFolders:
dpath = os.path.join(root,
folder).replace('(', '').replace(')', '')
self.__createDir(s, token, dpath)
for fle in files:
fullrelpath = os.path.join(root,
fle).replace('(',
'').replace(')', '')
basename, ext = os.path.splitext(fullrelpath)
if ext == '' or self.__isProjectDir(
os.path.basename(fullrelpath)):
self.__loadPage(s, token, fullrelpath)
else:
self.__loadAttachment(s, token, fullrelpath)
return True
def generate_content(self):
self.find_json_files()
for file_name in self.list_of_files:
node_data = {}
json_file = open(self.file_directory + file_name)
data = json.load(json_file)
node_data['fqdn'] = data['fqdn']
node_data['ipaddress_public'] = data['ipaddress_public']
node_data['ipaddress_private'] = data['ipaddress_private']
node_data['ipaddress_servicenet'] = data['ipaddress_servicenet']
self.servers.append(node_data)
content = self.template.render(your_name=self.your_name,
servers=self.servers)
# WIKI URL
s = Server("https://somecompany.com/rpc/xmlrpc")
# WIKI Credentials
token = s.confluence2.login("username", "password")
# WIKI Space and Page Name
page = s.confluence2.getPage(token, "~username", "Test Page")
page["content"] = content
s.confluence2.storePage(token, page)
def run(self):
#setting interval for the next run
delay = int(self.getConfigParam('delay'))
self.setInterval(delay)
# the parameters into the 'run' method
self.logger().info('%s connector next run in %s s' % (self.getName(), delay))
# now go get the sitemap.xml file itself
host = self.getConfigParam('confluence_host')
user = self.getConfigParam('confluence_user')
password = self.getConfigParam('confluence_pass')
self.logger().debug(' logging %s %s:%s' % (host, user, password))
self.confluence = Server("http://%s/rpc/xmlrpc" % host)
self.conf_token = self.confluence.confluence2.login(user, password)
spaces = self.confluence.confluence2.getSpaces(self.conf_token)
n = 0
for space in spaces:
feed_type = 'metadata-and-url'
#feed_type = 'incremental'
feed = connector.Feed(feed_type)
n += self.make_feed(feed, space)
self.pushFeed(feed)
feed.clear()
self.logger().info('Congrats, work done! %d URLs have been posted to GSA.' % n)
def __init__(self, uri, scenename, context, name, imageType): """ @param uri: uri of remote renderserver OR 'localhost' @type uri: string @param scenename: name of current scene @type scenename: string @param context: current render context @type context: Scene.Renderdata @param name: filename of saved .blend file @type name: string @param imageType: type of output image @type imageType: int """ self.configurer = Configurer() self.uri = uri self.scenename = scenename self.context = context self.name = name self.rpcserver = None self.blendSent = False self.imageType = imageType if uri == 'localhost': self.blendSent = True self.scn = Scene.Get(scenename) else: self.rpcserver = Server(uri) self._reset()
def connect(self):
"""Get a handle to a remote connection."""
url = self.url
self.server = Server(url)
if self._user_name is not None and self._password is not None:
self.session = self.server.login(self._user_name, self._password)
return self
def load_keys(username):
init()
log.debug("Loading keys for %s" % username)
global auth
if not enabled:
return []
try:
issues=[]
if useSoap:
if not auth:
auth = client.service.login(credentials['username'], credentials['password'])
tries=2
while tries >0:
tries-=1
try:
issues = client.service.getIssuesFromJqlSearch(auth, 'resolution = Unresolved AND assignee = %s AND "User flags" = Visible and remainingEstimate > 0' % username, 50)
tries=0
except:
auth = client.service.login(credentials['username'], credentials['password'])
else:
s = Server(jira_scheme+'://%s/rpc/xmlrpc' % jira_host)
auth = s.jira1.login(credentials['username'], credentials['password'])
issues = s.jira1.getIssuesFromJqlSearch(auth, 'resolution = Unresolved AND assignee = %s AND "User flags" = Visible and remainingEstimate > 0' % username)
result = list()
for issue in issues:
result.append(issue['key'])
return sorted(result)
except:
traceback.print_exc()
return []
def __init__(self, location, verbose=False):
self.location = location
# an empty Environment to help with tracking packages
self.environment = Environment(search_path=[])
self.server = Server(self.location)
self._projects = None
self.tmpdir = mkdtemp(prefix="ensetuptools-")
self.verbose = verbose
def __init__(self, context, request):
""" init view """
self.context = context
self.request = request
settings = getMultiAdapter((context,request),
name="helpdesk_settings")
self.rpcserver = Server('http://%s:%i' %
(settings.xmlrpc_host,settings.xmlrpc_port))
def __init__(self, xmlrpc_server, fetch_increment=200):
SearchEngine.__init__(self)
if _use_pyxmlrpc:
(host, port) = xmlrpc_server.split(':')
self._server = client(host, int(port))
else:
self._server = Server("http://" + xmlrpc_server)
self._fetch_increment = fetch_increment
def __init__(self,proxy_address=(PROXY_ADDRESS,PROXY_PORT), web_address=(WEB_ADDRESS,WEB_PORT)):
self._proxy = Server('http://%s:%s'%proxy_address,allow_none=True)
# print "Proxy: ",proxy_address
self.start_server(proxy_address,web_address)
self.data = None
self.type = None
self.url = None
self.width = 0
self.height = 0
def __init__(self, service_url):
'''
This rewrites the xmlrpc function bindings to use a
decorator so that we can check the return status of API
functions before returning them back to the client
It allows the client object to directly inherit all
of the API calls exposed on the server side to the
client side without writing ANOTHER lookup table.
'''
Server.__init__(self, service_url)
setattr(self, "_ServerProxy__request",
self.api_error_check(self._ServerProxy__request))
self.vms = {}
self.msattrs = None
self.msci = None
self.username = None
def __init__ (self, service_url):
'''
This rewrites the xmlrpc function bindings to use a
decorator so that we can check the return status of API
functions before returning them back to the client
It allows the client object to directly inherit all
of the API calls exposed on the server side to the
client side without writing ANOTHER lookup table.
'''
Server.__init__(self, service_url)
setattr(self, "_ServerProxy__request", self.api_error_check(self._ServerProxy__request))
self.vms = {}
self.msattrs = None
self.msci = None
self.username = None
def run_export_queue(admin_user, admin_pw, expected=None):
globals, locals = get_twill_glocals()
base_url = globals.get('base_url')
prepath = globals.get('prepath')
log_warn("(zope) Running export queue for %s" % (base_url))
scheme, uri = urllib.splittype(base_url)
host, path = urllib.splithost(uri)
if prepath is not None:
path = prepath + path
auth_url = "%s://%s:%s@%s%s/" % (scheme, admin_user, admin_pw, host, path)
portal = XMLRPCServer(auth_url)
# pass in a maxwait of 1 second to speed things up
exports = portal.manage_project_export_queue(1)
if expected is not None and expected not in exports:
raise TwillAssertionError("project id %s not found in exported projects: %r" % (expected, exports))
def run_export_queue(admin_user, admin_pw, expected=None):
globals, locals = get_twill_glocals()
base_url = globals.get("base_url")
prepath = globals.get("prepath")
log_warn("(zope) Running export queue for %s" % (base_url))
scheme, uri = urllib.splittype(base_url)
host, path = urllib.splithost(uri)
if prepath is not None:
path = prepath + path
auth_url = "%s://%s:%s@%s%s/" % (scheme, admin_user, admin_pw, host, path)
portal = XMLRPCServer(auth_url)
# pass in a maxwait of 1 second to speed things up
exports = portal.manage_project_export_queue(1)
if expected is not None and expected not in exports:
raise TwillAssertionError("project id %s not found in exported projects: %r" % (expected, exports))
class Command(BaseCommand):
args = '<command> [args]' # TODO
help = 'TODO'
def __init__(self, *args, **kwargs):
super(Command, self).__init__(*args, **kwargs)
self.server = Server(settings.SIOWORKERSD_URL)
def cmd_list(self, **kwargs):
l = self.server.get_workers()
if l:
self.stdout.write('\n'.join(map(str, l)))
else:
self.stdout.write('No workers connected.\n')
def cmd_run(self, *args, **kwargs):
env = json.loads(' '.join(args))
self.stdout.write(self.server.run(env))
def cmd_sync_run(self, *args, **kwargs):
env = json.loads(' '.join(args))
self.stdout.write(repr(self.server.sync_run(env)))
def cmd_queue(self, *args, **kwargs):
q = self.server.get_queue()
if not q:
self.stdout.write('Empty queue.\n')
return
self.stdout.write(unicode(q).encode('utf-8'))
def handle(self, *args, **kwargs):
if not args:
cmds = [i[4:] for i in dir(self) if i.startswith('cmd_')]
self.stdout.write('Available commands: %s\n' % ', '.join(cmds))
return
cmd = args[0]
args = args[1:]
try:
f = getattr(self, 'cmd_' + cmd)
except AttributeError:
raise CommandError('Invalid command: %s' % cmd)
f(*args, **kwargs)
def __init__(self, host):
'''
host: The URL of your archiver's ArchiveDataServer.cgi. Will
look something like:
http://cr01arc01/cgi-bin/ArchiveDataServer.cgi
'''
super(Archiver, self).__init__()
self.server = Server(host)
self.archiver = self.server.archiver
self.archives_for_channel = defaultdict(list)
def start(self):
server = Server(self.server_url)
self.graph = server.ubigraph
# Create a graph
for i in range(0, 10):
self.graph.new_vertex_w_id(i)
# Make some edges
for i in range(0, 10):
self.graph.new_edge(i, (i + 1) % 10)
def __resetConnection(self, s, token):
print 'Restablishing Connection...'
# s.confluence1.logout(token)
s = Server(self.server)
token = s.confluence1.login(self.login, self.passwd)
print 'Connection Established.'
return s, token
def _auth(self):
now = datetime.now()
if (self.auth and (now - self.lastAuth) < timedelta(seconds=60)):
self.log.info('reusing auth')
else:
server = self.registryValue('server')
self.s = Server(server)
self.log.info('Authenticaing on server: ' + server + ' with ' +
self.registryValue('user'))
self.auth = self.s.jira1.login(self.registryValue('user'),
self.registryValue('password'))
self.lastAuth = datetime.now()
class Command(BaseCommand):
args = '<command> [args]' # TODO
help = 'TODO'
def __init__(self, *args, **kwargs):
super(Command, self).__init__(*args, **kwargs)
self.server = Server(settings.SIOWORKERSD_URL)
def cmd_list(self, **kwargs):
l = self.server.get_workers()
if l:
self.stdout.write('\n'.join(map(str, l)))
else:
self.stdout.write('No workers connected.\n')
def cmd_run(self, *args, **kwargs):
self.stdout.write(self.server.run(' '.join(args)))
def cmd_sync_run(self, *args, **kwargs):
self.stdout.write(repr(self.server.sync_run(' '.join(args))))
def cmd_queue(self, *args, **kwargs):
q = self.server.get_queue()
if not q:
self.stdout.write('Empty queue.\n')
return
self.stdout.write(unicode(q).encode('utf-8'))
def handle(self, *args, **kwargs):
if not args:
cmds = [i[4:] for i in dir(self) if i.startswith('cmd_')]
self.stdout.write('Available commands: %s\n' % ', '.join(cmds))
return
cmd = args[0]
args = args[1:]
try:
f = getattr(self, 'cmd_' + cmd)
except AttributeError:
raise CommandError('Invalid command: %s' % cmd)
f(*args, **kwargs)
def exec_xmlrpc(func, **kwargs):
""" Send a XMLRPC request """
try:
server = Server(settings.IPBOARD_ENDPOINT, verbose=False)
params = {}
for i in kwargs:
params[i] = kwargs[i]
params['api_key'] = settings.IPBOARD_APIKEY
params['api_module'] = settings.IPBOARD_APIMODULE
return getattr(server, func)(params)
except:
return {}
def main():
server = Server(uri) # 连接远程服务.
# 测试远程调用函数.
print "chop_in_half(): ", server.chop_in_half("hello server.")
print "repeat(): ", server.repeat("hello server.", 3)
print "_string(): ", server._string("addadd")
# print "join(): ", server.python_string.join(["what a", "f*****g day."], "-")
try:
server._privateFunction()
except Fault:
print "_privateFunction(): not supported, can't access..."
def _connect(self):
'''Connect to the remote server via XML-RPC HTTP; return status'''
# Now try to connect
self._connection = Server(self._make_sync_url())
# check whether the connection was made and the Master Babel Tower
# exists
try:
self._connection.getAllLanguages()
return 1 # pragma: no cover
except Exception:
self._connection = None
return 0
def writeToPage():
# Read the text of the page from standard input
## content = sys.stdin.read()
## s = Server("http://confluence.example.com/rpc/xmlrpc")
## token = s.confluence1.login("username", "password")
## page = s.confluence1.getPage(token, "SPACEKEY", "Page Title")
content = "hello world!"
s = Server(server + "/rpc/xmlrpc")
token = s.confluence1.login(username, password)
page = s.confluence1.getPage(token, spacekey, pagetitle)
page["content"] = content
s.confluence1.storePage(token, page)
def check_for_updates(): """ Check and return available updates. Honour the frequency of update checking unless force is True. Return list of pair (version, description), where description is an html-formatted text. Raise an exception if anything goes wrong. """ if( force or preferences.updateLastCheck is None or datetime.datetime.now() > preferences.updateLastCheck + datetime.timedelta(days=preferences.updateFrequency) ): tr = ProxyTransport() s = Server(preferences.updateUrl, transport = tr) # method returns a dictionary with those keys: # 'new_url': if defined, new url of the webservice # 'updates': list of 3-tuples (version, description, downloadUrl) u = s.checkForUpdates( glb.VERSION, preferences.updateFrequency, platform.system(), platform.architecture(), platform.platform(), platform.python_version(), wx.version(), i18n.getLang(), ) u2 = [x for x in u['updates'] if x[0] not in preferences.ignoredUpdates] preferences.updateLastCheck = datetime.datetime.now() if 'new_url' in u: preferences.updateUrl = u['new_url'] return u2 return []
def main():
server = Server(uri) # 连接远程服务.
# 测试远程调用函数.
print "chop_in_half(): ", server.chop_in_half("hello server.")
print "repeat(): ", server.repeat("hello server.", 3)
print "_string(): ", server._string("addadd")
# print "join(): ", server.python_string.join(["what a", "f*****g day."], "-")
try:
server._privateFunction()
except Fault:
print "_privateFunction(): not supported, can't access..."
class MagentoXMLRPCConnection:
"""
Holds an XML-RPC connection to a remote Magento XML-RPC server.
"""
def __init__(self, url, user_name=None, password=None):
self.url = url
self._user_name = user_name
self._password = password
def connect(self):
"""Get a handle to a remote connection."""
url = self.url
self.server = Server(url)
if self._user_name is not None and self._password is not None:
self.session = self.server.login(self._user_name, self._password)
return self
def __getattr__(self, name):
""" Allow to call mehod on connection """
if not name.startswith("_"):
return MethodWrapper(name, self)
class SioworkersdBackend(object):
"""A backend which collaborates with sioworkersd"""
server = Server(settings.SIOWORKERSD_URL, allow_none=True)
def run_job(self, job, **kwargs):
env = {'workers_jobs': {'dummy_name': job}}
env['workers_jobs.extra_args'] = kwargs
env['oioioi_instance'] = settings.SITE_NAME
env['contest_priority'] = (settings.OIOIOI_INSTANCE_PRIORITY_BONUS +
settings.NON_CONTEST_PRIORITY)
env['contest_weight'] = (settings.OIOIOI_INSTANCE_WEIGHT_BONUS +
settings.NON_CONTEST_WEIGHT)
ans = SioworkersdBackend.server.sync_run_group(json.dumps(env))
if 'error' in ans:
raise RuntimeError(
'Error from workers:\n%s\nTB:\n%s' %
(ans['error']['message'], ans['error']['traceback']))
return ans['workers_jobs.results']['dummy_name']
def run_jobs(self, dict_of_jobs, **kwargs):
env = {'workers_jobs': dict_of_jobs, 'workers_jobs.extra_args': kwargs}
env['oioioi_instance'] = settings.SITE_NAME
env['contest_priority'] = (settings.OIOIOI_INSTANCE_PRIORITY_BONUS +
settings.NON_CONTEST_PRIORITY)
env['contest_weight'] = (settings.OIOIOI_INSTANCE_WEIGHT_BONUS +
settings.NON_CONTEST_WEIGHT)
ans = SioworkersdBackend.server.sync_run_group(json.dumps(env))
if 'error' in ans:
raise RuntimeError(
'Error from workers:\n%s\nTB:\n%s' %
(ans['error']['message'], ans['error']['traceback']))
return ans['workers_jobs.results']
def send_async_jobs(self, env, **kwargs):
url = settings.SIOWORKERS_LISTEN_URL
if url is None:
url = 'http://' + settings.SIOWORKERS_LISTEN_ADDR + ':' \
+ str(settings.SIOWORKERS_LISTEN_PORT)
env['return_url'] = url
SioworkersdBackend.server.run_group(json.dumps(env))
class MagentoXMLRPCConnection:
"""
Holds an XML-RPC connection to a remote Magento XML-RPC server.
"""
def __init__(self, url, user_name = None, password = None):
self.url = url
self._user_name = user_name
self._password = password
def connect(self):
"""Get a handle to a remote connection."""
url = self.url
self.server = Server(url)
if self._user_name is not None and self._password is not None:
self.session = self.server.login(self._user_name, self._password)
return self
def __getattr__(self, name):
""" Allow to call mehod on connection """
if not name.startswith("_"):
return MethodWrapper(name, self)
def authenticate(self, widget):
try:
if self.serverEntry.get_text().endswith("xmlrpc") != True:
raise NameError, "Invalid URL"
else:
self.server = Server(self.serverEntry.get_text())
self.token = self.server.confluence1.login(
self.userNameEntry.get_text(), self.passwordEntry.get_text())
self.master.mainWindow.remove(self.loginVBox)
self.launchPad()
except xmlrpclib.Fault:
self.master.errDialog("\t\t\tLogin Failed\t\t\t")
except NameError:
self.master.errDialog(
"\t\t\tURL Must end with proper RPC \n http://test.com/rpc/xmlrpc for example\t\t\t"
)
except:
self.master.errDialog("\t\tConnection Failed\t\t")
def __init__(self, *args, **kwargs):
super(Command, self).__init__(*args, **kwargs)
self.server = Server(settings.SIOWORKERSD_URL)
#!/usr/bin/python2.4 -i
from xmlrpclib import Server
import sys
ZAPI_KEY = "5d4a65c46a072a4542a816f2f28bd01a"
AUTH_DICT = {'username': "******", 'password': "******"}
if len(sys.argv) > 2:
AUTH_DICT['username'] = sys.argv[2]
if len(sys.argv) > 3:
AUTH_DICT['password'] = sys.argv[3]
print "opening rpc connection to %s" % sys.argv[1]
s = Server("http://%s" % sys.argv[1])
#print s.productionstats.get_user_count(foo=22)
import sys, string, xmlrpclib, re
#!/usr/bin/python
#
# Reads from standard input, dumps it onto a Confluence page
# You'll need to modify the URL/username/password/spacekey/page title
# below, because I'm too lazy to bother with argv.
import sys
from xmlrpclib import Server
# Read the text of the page from standard input
#content = sys.stdin.read()
content = "This is a test"
s = Server("https://lyonscg.atlassian.net/wiki/rpc/xmlrpc")
token = s.confluence1.login('*****@*****.**', 'mT7bwujk!7890')
page = s.confluence1.getPage(token, "AHTS", "Test Page")
page["content"] = content
s.confluence1.storePage(token, page)
#server = xmlrpclib.ServerProxy('https://lyonscgahdev.atlassioan.net/confluence/rpc/xmlrpc');
#token = server.confluence1.login('rayctran', 'pb4ugo2bed!7890');
#page = server.confluence1.getPage(token, AHTS, "Test Page");
#if page is None:
# exit("Could not find page " + spacekey + ":" + pagetitle);
#
#content = "This is a test page"
#
#page['content'] = content;
#server.confluence1.storePage(token, page);
def main():
server = Server(uri) # 连接远程服务.
print "rpc_test_service(): ", server.rpc_test_service()
generate_test_data.py
Author: Trey Stout
Date Added: Wed May 31 14:51:09 CDT 2006
generate some basic users, images, comments and tags
"""
import sys, psycopg2, time, os
from urllib import urlretrieve
from xmlrpclib import Server, Binary, Fault
from pprint import pprint, pformat
DSN = "host=localhost dbname=aztk_core user=aztk"
COM_RPC = Server("http://zoto.com/RPC2")
RPC = Server("http://192.168.5.22:7010/")
IMG_PATH = '/zoto/aztk/lib/test_images2'
if __name__ == "__main__":
print "Creating connection..."
con = psycopg2.connect(DSN)
cur = con.cursor()
"""
used to get a bunch of images off of .com
"""
"""
response = COM_RPC.lightbox.get_all(('trey', 'treytrey'), 700, 0)
for row in response:
def __init__(self):
self.nounPhrases = []
self.ontoURL = configuration.ONTOLOGY_SERVICE_URL + "/" + configuration.ONTOLOGY_NAME
self.tagger = Server("http://" + configuration.TAG_SERVICE_URL + ":" + str(configuration.TAG_SERVICE_PORT), verbose=0)
# Setting Confluence URL, Space, username and password.
server = sys.argv[1]
conf_user = sys.argv[2]
conf_pwd = sys.argv[3]
conf_space = sys.argv[4]
with open(htmlreportname, 'a') as f:
f.write("<br><i>Scanning URL:<b> ")
f.write(server)
f.write("</b> and SPACE:<b> ")
f.write(conf_space)
f.write("</b></i><br>")
f.write("<br><b>The following stuff is busted.</b> ;-)<br>")
# Access the site via XML-RPC to retrieve the list of all pages in the space (once-off action)
s = Server(server + "/rpc/xmlrpc")
s = s.confluence1
token = s.login(conf_user,conf_pwd)
# this is a "dictionary" (spaceindex)
spaceindex = s.getPages(token, conf_space)
s.logout(token)
def downloadpage(site_address):
# Conditional block that tries to access the URL and catches HTTP Error codes sent back.
try:
response = urllib2.urlopen(site_address)
html = response.read()
#BEGIN HTTP error finder block
except urllib2.HTTPError, e:
# e.code is just the numerical HTTP error code from the server. i.e. 404
print "Error", e.code, "was detected."
logger.setLevel(logging.DEBUG)
if __name__ == "__main__":
success = False
error = ""
try:
config = Config(cfg="analysis.conf")
cuckoo = CuckooHost(config.ip, config.port)
analyzer = Macalyzer(cuckoo, config)
success = analyzer.run()
except KeyboardInterrupt:
error = "Keyboard Interrupt"
except Exception as err:
error_exc = format_exc()
error = str(err)
if len(analyzer.log.handlers):
analyzer.log.exception(error_exc)
else:
stderr.write("{0}\n".format(error_exc))
# Once the analysis is completed or terminated for any reason, we report
# back to the agent, notifying that it can report back to the host.
finally:
# Establish connection with the agent XMLRPC server.
server = Server("http://127.0.0.1:8000")
server.complete(success, error, PATHS["root"])
def __init__(self):
self.settings = ConfluenceSettings()
self.server = Server(self.settings.uri).confluence2
self.db = DatabaseWrapper()
self.page = None
class ConfluenceInstance(object):
def __init__(self):
self.settings = ConfluenceSettings()
self.server = Server(self.settings.uri).confluence2
self.db = DatabaseWrapper()
self.page = None
def get_token(self):
LOGGER.info('Logging in to Confluence as %s' % self.settings.login)
token = self.server.login(self.settings.login, self.settings.password)
return token
def get_page(self):
if self.page is None:
LOGGER.info('Fetching page contents from Confluence')
data = self.server.getPage(
self.get_token(),
self.settings.namespace,
self.settings.pagename
)
self.page = ConfluencePage(data)
return self.page
def save_page(self, page):
page = self.__attach_statistics(page)
self.server.storePage(self.get_token(), page.data)
def __attach_statistics(self, page):
stats = Stats(self.db.get_dc_issues()).get_result()
content = page.data['content']
message = structured_macro_info(
'Warning',
paragraph(update_message(self.settings.login, strftime("%Y-%m-%d %H:%M:%S %z", gmtime())))
)
to_go_count = stats['total']['count'] - stats['ready']['count'] - stats['passed']['count'] - stats['failed'][
'count']
stat_info = paragraph(
structured_macro_status('Grey', '%s total' % len(DatabaseWrapper.get_all_issues())) +
structured_macro_status('Grey', '%s desk check' % stats['total']['count']) +
structured_macro_status('Blue', '%s ready' % stats['ready']['count']) +
structured_macro_status('Green', '%s pass' % stats['passed']['count']) +
structured_macro_status('Red', '%s fail' % stats['failed']['count']) +
structured_macro_status_subtle('%s to go' % to_go_count)
)
content = message + stat_info + content
page.data.update({'content': str(content)})
return page
def __outdated_issues_block(self):
items_for_list = []
for issue in self.db.get_outdated_issues():
items_for_list.append({
'link': JiraSettings().browse + issue.key,
'title': issue.key,
'comment': ' (%s)' % issue.est_date,
})
if len(items_for_list) > 0:
outdated = paragraph(
structured_macro_expand('%s outdated issues' % len(items_for_list),
unordered_list_with_hrefs(items_for_list))
)
else:
outdated = ''
return outdated
