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 __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 __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 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 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 []
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