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 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. ''' _orig_Method = xmlrpc.client._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) xmlrpc.client._Method = KeywordArgMethod Server.__init__(self, service_url) setattr(self, "_ServerProxy__request", self.api_error_check(self._ServerProxy__request)) self.vms = {} self.hosts = {} self.msattrs = None self.msci = None self.username = None self.print_message = print_message self.last_refresh = datetime.now()
def _connect(self): if not self.conn: self.conn = Server(self.cobbler_host, allow_none=True) self.token = None if self.cobbler_username is not None: self.token = self.conn.login(self.cobbler_username, self.cobbler_password)
def gnuradio_start_graph(gr_host="localhost", gr_port=8080): try: from xmlrpc.client import Server from xmlrpc.client import Fault except ImportError: print("xmlrpclib is needed to call 'gnuradio_start_graph'") else: s = Server(f"http://{gr_host}:{gr_port}") try: s.start() except Fault as e: print(f"ERROR: {e.faultString}")
def find_updates(pkgset, stable_only=True): no_releases = set() def write(s): sys.stdout.write(s) sys.stdout.flush() pypi = Server("http://pypi.python.org/pypi/") pkgname2latest = {} pkgfiles = [pkgfile(x) for x in pkgset.find_packages()] for x in pkgfiles: if x.pkgname not in pkgname2latest: pkgname2latest[x.pkgname] = x elif x.version_info > pkgname2latest[x.pkgname].version_info: pkgname2latest[x.pkgname] = x need_update = [] sys.stdout.write("checking %s packages for newer version\n" % len(pkgname2latest),) for count, (pkgname, file) in enumerate(pkgname2latest.items()): if count % 40 == 0: write("\n") releases = pypi.package_releases(pkgname) releases = [(parse_version(x), x) for x in releases] if stable_only: releases = filter_stable_releases(releases) status = "." if releases: m = max(releases) if m[0] > file.version_info: file.latest_version = m[1] status = "u" # print "%s needs update from %s to %s" % (pkgname, file.version, m[1]) need_update.append(file) else: no_releases.add(pkgname) status = "e" write(status) write("\n\n") no_releases = list(no_releases) if no_releases: no_releases.sort() sys.stdout.write("no releases found on pypi for %s\n\n" % (", ".join(no_releases),)) return need_update
class IndexStorageClient(object): def __init__(self, server_address=ServerAddress): self.server_address = server_address self.server_proxy = XMLRPCServerProxy( "http://%s:%s" % self.srever_address, allow_none=None) def set_index(self, index_list): return self.server_proxy.set_index(encode_to_binary(index_list)) def get_index(self, index_key): return decode_from_binary(self.server_proxy.get_index(index_key))
def __init__(self, atac_api_key): self.atac_api_key = atac_api_key atac_api = "http://muovi.roma.it/ws/xml/" self.servers = { "auth": Server(urljoin(atac_api, "autenticazione/" + "1")), "paline": Server(urljoin(atac_api, "paline/" + "7")), "percorso": Server(urljoin(atac_api, "percorso/" + "2")) } self.server_resp_codes = {"expired_session": 824, "unknown_percorso": 807, "unknown_palina": 803, "linea_inesistente": 804} self.__update_token() self.generic_error = BotResponse(False, "Ho incontrato un errore :pensive: forse atac " "non è online al momento :worried:. Riprova fra poco!")
def latest_release(package): """Retrieve latest released data.""" url = 'http://pypi.python.org/pypi' LOGGER.info("Connecting to '{0:s}'.".format(url)) if _PY3K: from xmlrpc.client import Server else: from xmlrpclib import Server pypi = Server(url) show_hidden = False releases = pypi.package_releases(package, show_hidden) for release in releases: urls = pypi.release_urls(package, release) return urls
def create_jdbc_driver_with_all_jars(server_proxy: str, path_to_the_jars_folder: str, jdbc_name: str, jdbc_main_class: str, jdbc_prefix: str): srv = Server(server_proxy, context=ssl._create_unverified_context()) jdbc_name = srv.addJDBCDriver({ 'comment': '', 'jdbc_main': jdbc_main_class, 'jdbc_name': jdbc_name, 'jdbc_prefix': jdbc_prefix }) jdbc = getattr(srv, jdbc_name) for filename in glob.glob(os.path.join(path_to_the_jars_folder, '*.jar')): jar = open(filename, "rb") read = jar.read() jdbc.uploadFile(Binary(read), os.path.basename(filename)) print("Uploaded successfully.")
def mirror(package_name, destdir=None, dry_run=False, stable_only=True): pypi = Server("http://pypi.python.org/pypi/") versions = pypi.package_releases(package_name) command_base = ('pip -q install --no-deps -i http://pypi.python.org/simple' ' -I -d %s %s==' % (destdir, package_name)) commands = [('%s%s' % (command_base, version), version) for version in versions] for command, version in commands: print "Mirroring %s==%s" % (package_name, version) if not dry_run: running_command = subprocess.Popen(command, shell=True) running_command.communicate()[0] print "... completed mirror of %s at %s" % (package_name, version)
def __init__(self, host): """ Args: host (str): URL to 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 make_pypi_client(url): http_proxy_url = urllib.getproxies().get("http", "") if http_proxy_url: http_proxy_spec = urllib.splithost( urllib.splittype(http_proxy_url)[1])[0] transport = ProxiedTransport() transport.set_proxy(http_proxy_spec) else: transport = None return Server(url, transport=transport)
def load_stock_price_from_rpc_server(server_port, trade_date, stock_ticker): server = Server('http://localhost:{}'.format(server_port)) while True: try: stock_data = server.load_stock_price(trade_date.strftime('%Y%m%d'), stock_ticker) except ConnectionResetError: time.sleep(0.1) else: break data_df = pd.read_json(stock_data, orient='records', date_unit='s') if data_df.empty: return {} else: return data_df.loc[0].to_dict()
def gnuradio_set_vars(gr_host=IP_TX_MACHINE, gr_port=PORT_TX_MACHINE_VAR, **kwargs): try: from xmlrpc.client import Server from xmlrpc.client import Fault except ImportError: print("xmlrpc is needed to call 'gnuradio_set_vars'") else: s = Server("http://{}:{}".format(gr_host, gr_port)) for k, v in kwargs.items(): try: getattr(s, "set_{}".format(k))(v) except Fault: print("Unknown variable '{}'".format(k)) s = None
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 = RequestsTransport() 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 gnuradio_stop_graph(gr_host="localhost", gr_port=8080): try: from xmlrpc.client import Server from xmlrpc.client import Fault except ImportError: print("xmlrpc is needed to call 'gnuradio_stop_graph'") else: s = Server(f"http://{gr_host}:{gr_port}") s.stop() s.wait()
def gnuradio_set_vars(gr_host="localhost", gr_port=8080, **kwargs): if not kwargs: return try: from xmlrpc.client import Server from xmlrpc.client import Fault except ImportError: print("xmlrpc is needed to call 'gnuradio_set_vars'") else: s = Server(f"http://{gr_host}:{gr_port}") for k, v in kwargs.items(): try: getattr(s, f"set_{k}")(v) except Fault: print(f"Unknown variable '{k}'") s = None
def lambda_handler(event, context): """ Input: event: { 'body': { 'id_palina': id_palina, 'token': authentication_token } } """ body = event['body'] print('Request for palina {}'.format(body['id_palina'])) server = Server(os.environ['PALINA_URL'], use_builtin_types=True) ts = datetime.datetime.utcnow() try: res = server.paline.Previsioni(body['token'], body['id_palina'], 'it') except Fault as err: if err.faultCode == 803: return invalid_palina(err) else: raise arrival.process(res, ts) return {'statusCode': 200, 'body': 'DONE'}
def gnuradio_get_vars(*args, **kwargs): if "gr_host" not in kwargs: kwargs["gr_host"] = "127.0.0.1" if "gr_port" not in kwargs: kwargs["gr_port"] = 8080 rv = {} try: from xmlrpc.client import Server from xmlrpc.client import Fault except ImportError: print("xmlrpc is needed to call 'gnuradio_get_vars'") else: s = Server(f"http://{kwargs['gr_host']}:{kwargs['gr_port']}") for v in args: try: res = getattr(s, f"get_{v}")() rv[v] = res except Fault: print(f"Unknown variable '{v}'") s = None if len(args) == 1: return rv[args[0]] return rv
def lambda_handler(event, context): id_palina_list = get_id_palina_list() s1 = Server(os.environ['ATAC_AUTH_URL'], use_builtin_types=True) token = s1.autenticazione.Accedi(os.environ['ATAC_DEV_KEY'], os.environ['ATAC_ID_UTENTE']) client = boto3.client('lambda') for id_palina in id_palina_list: client.invoke( FunctionName="palinaRequest", InvocationType='Event', Payload=json.dumps( { 'body': { 'id_palina': id_palina, 'token': token } } ) ) return { 'statusCode': 200, 'body': json.dumps('DONE') }
def gnuradio_get_vars(*args, **kwargs): if "gr_host" not in kwargs: kwargs["gr_host"] = IP_TX_MACHINE if "gr_port" not in kwargs: kwargs["gr_port"] = PORT_TX_MACHINE_VAR rv = {} try: from xmlrpc.client import Server from xmlrpc.client import Fault except ImportError: print("xmlrpc is needed to call 'gnuradio_get_vars'") else: s = Server("http://{}:{}".format(kwargs["gr_host"], kwargs["gr_port"])) for v in args: try: res = getattr(s, "get_{}".format(v))() rv[v] = res except Fault: print("Unknown variable '{}'".format(v)) s = None if len(args) == 1: return rv[args[0]] return rv
def setUp(self): s1 = Server(os.environ['ATAC_AUTH_URL'], use_builtin_types=True) self.token = s1.autenticazione.Accedi(os.environ['ATAC_DEV_KEY'], os.environ['ATAC_ID_UTENTE']) self.event = {'body': {'token': self.token, 'id_palina': '10037'}} self.context = None
# testing xmlrpc finger try: # Python 3 from xmlrpc.client import Server except ImportError: # Python 2 from xmlrpclib import Server server = Server("http://127.0.0.1:8000/RPC2") print(server.getUser("moshez"))
import os import sys from os import path from xmlrpc.client import Server from virtualenv import create_bootstrap_script from application import create_bootstrap_script from flask_script import Manager, Server sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),'..'))) app = create_app() manager = Manager(app) manager.add_command("runserver", Server( use_debugger = True, use_reloader = True, host = os.getenv('IP', '0.0.0.0'),DS port = int(os.getenv('PORT', 5000))) )
import os import sys from os import path from xmlrpc.client import Server from virtualenv import create_bootstrap_script from application import create_bootstrap_script from flask_script import Manager, Server sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) app = create_app() manager = Manager(app) manager.add_command( "runserver", Server(use_debugger=True, use_reloader=True, host=os.getenv('IP', '0.0.0.0'), port=int(os.getenv('PORT', 5000)))) if __name__ == "__main__": manager.run()
def login(self, user, password): self.server = Server(self.generic.url + '/rpc/xmlrpc') self.token = self.server.confluence1.login(user, password) assert self.token is not None, 'Login failed' return self.token
import os import sys from os import path from xmlrpc.client import Server from virtualenv import create_bootstrap_script from application import create_bootstrap_script from flask_script import Manager, Server sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),'..'))) app = create_app() manager = Manager(app) manager.add_command("runserver", Server() use_debugger = True, use_reloader = True, host = os.getenv('IP', '0.0.0.0'), port = int(os.getenv('PORT', 5000))) )
def __init__(self): self.rpc = Server(config.get('api.url'), allow_none=True) self.key = config.get('api.key')
class CobblerInventory(object): def __init__(self): """ Main execution path """ self.conn = None self.inventory = dict() # A list of groups and the hosts in that group self.cache = dict() # Details about hosts in the inventory self.ignore_settings = False # used to only look at env vars for settings. # Read env vars, read settings, and parse CLI arguments self.parse_env_vars() self.read_settings() self.parse_cli_args() # Cache if self.args.refresh_cache: self.update_cache() elif not self.is_cache_valid(): self.update_cache() else: self.load_inventory_from_cache() self.load_cache_from_cache() data_to_print = "" # Data to print if self.args.host: data_to_print += self.get_host_info() else: self.inventory['_meta'] = {'hostvars': {}} for hostname in self.cache: self.inventory['_meta']['hostvars'][hostname] = { 'cobbler': self.cache[hostname] } data_to_print += self.json_format_dict(self.inventory, True) print(data_to_print) def _connect(self): if not self.conn: self.conn = Server(self.cobbler_host, allow_none=True) self.token = None if self.cobbler_username is not None: self.token = self.conn.login(self.cobbler_username, self.cobbler_password) def is_cache_valid(self): """ Determines if the cache files have expired, or if it is still valid """ if os.path.isfile(self.cache_path_cache): mod_time = os.path.getmtime(self.cache_path_cache) current_time = time() if (mod_time + self.cache_max_age) > current_time: if os.path.isfile(self.cache_path_inventory): return True return False def read_settings(self): """ Reads the settings from the cobbler.ini file """ if (self.ignore_settings): return config = ConfigParser.SafeConfigParser() config.read( os.path.dirname(os.path.realpath(__file__)) + '/cobbler.ini') self.cobbler_host = config.get('cobbler', 'host') self.cobbler_username = None self.cobbler_password = None if config.has_option('cobbler', 'username'): self.cobbler_username = config.get('cobbler', 'username') if config.has_option('cobbler', 'password'): self.cobbler_password = config.get('cobbler', 'password') # Cache related cache_path = config.get('cobbler', 'cache_path') self.cache_path_cache = cache_path + "/ansible-cobbler.cache" self.cache_path_inventory = cache_path + "/ansible-cobbler.index" self.cache_max_age = config.getint('cobbler', 'cache_max_age') def parse_env_vars(self): """ Reads the settings from the environment """ # Env. Vars: # COBBLER_host # COBBLER_username # COBBLER_password # COBBLER_cache_path # COBBLER_cache_max_age # COBBLER_ignore_settings self.cobbler_host = os.getenv('COBBLER_host', None) self.cobbler_username = os.getenv('COBBLER_username', None) self.cobbler_password = os.getenv('COBBLER_password', None) # Cache related cache_path = os.getenv('COBBLER_cache_path', None) if (cache_path is not None): self.cache_path_cache = cache_path + "/ansible-cobbler.cache" self.cache_path_inventory = cache_path + "/ansible-cobbler.index" self.cache_max_age = int(os.getenv('COBBLER_cache_max_age', "30")) # ignore_settings is used to ignore the settings file, for use in Ansible # Tower (or AWX inventory scripts and not throw python exceptions.) if (os.getenv('COBBLER_ignore_settings', False) == "True"): self.ignore_settings = True def parse_cli_args(self): """ Command line argument processing """ parser = argparse.ArgumentParser( description='Produce an Ansible Inventory file based on Cobbler') parser.add_argument('--list', action='store_true', default=True, help='List instances (default: True)') parser.add_argument( '--host', action='store', help='Get all the variables about a specific instance') parser.add_argument( '--refresh-cache', action='store_true', default=False, help= 'Force refresh of cache by making API requests to cobbler (default: False - use cache files)' ) self.args = parser.parse_args() def update_cache(self): """ Make calls to cobbler and save the output in a cache """ self._connect() self.groups = dict() self.hosts = dict() if self.token is not None: data = self.conn.get_systems(self.token) else: data = self.conn.get_systems() for host in data: # Get the FQDN for the host and add it to the right groups dns_name = host['hostname'] # None ksmeta = None interfaces = host['interfaces'] # hostname is often empty for non-static IP hosts if dns_name == '': for (iname, ivalue) in iteritems(interfaces): if ivalue['management'] or not ivalue['static']: this_dns_name = ivalue.get('dns_name', None) dns_name = this_dns_name if this_dns_name else '' if dns_name == '' or dns_name is None: continue status = host['status'] profile = host['profile'] classes = host[orderby_keyname] if status not in self.inventory: self.inventory[status] = [] self.inventory[status].append(dns_name) if profile not in self.inventory: self.inventory[profile] = [] self.inventory[profile].append(dns_name) for cls in classes: if cls not in self.inventory: self.inventory[cls] = [] self.inventory[cls].append(dns_name) # Since we already have all of the data for the host, update the host details as well # The old way was ksmeta only -- provide backwards compatibility self.cache[dns_name] = host if "ks_meta" in host: for key, value in iteritems(host["ks_meta"]): self.cache[dns_name][key] = value self.write_to_cache(self.cache, self.cache_path_cache) self.write_to_cache(self.inventory, self.cache_path_inventory) def get_host_info(self): """ Get variables about a specific host """ if not self.cache or len(self.cache) == 0: # Need to load index from cache self.load_cache_from_cache() if self.args.host not in self.cache: # try updating the cache self.update_cache() if self.args.host not in self.cache: # host might not exist anymore return self.json_format_dict({}, True) return self.json_format_dict(self.cache[self.args.host], True) def push(self, my_dict, key, element): """ Pushed an element onto an array that may not have been defined in the dict """ if key in my_dict: my_dict[key].append(element) else: my_dict[key] = [element] def load_inventory_from_cache(self): """ Reads the index from the cache file sets self.index """ cache = open(self.cache_path_inventory, 'r') json_inventory = cache.read() self.inventory = json.loads(json_inventory) def load_cache_from_cache(self): """ Reads the cache from the cache file sets self.cache """ cache = open(self.cache_path_cache, 'r') json_cache = cache.read() self.cache = json.loads(json_cache) def write_to_cache(self, data, filename): """ Writes data in JSON format to a file """ json_data = self.json_format_dict(data, True) cache = open(filename, 'w') cache.write(json_data) cache.close() def to_safe(self, word): """ Converts 'bad' characters in a string to underscores so they can be used as Ansible groups """ return re.sub(r"[^A-Za-z0-9\-]", "_", word) def json_format_dict(self, data, pretty=False): """ Converts a dict to a JSON object and dumps it as a formatted string """ if pretty: return json.dumps(data, sort_keys=True, indent=2) else: return json.dumps(data)
import os import sys from os import path from xmlrpc.client import Server from virtualenv import create_bootstrap_script from application import create_bootstrap_script from flask_script import Manager, Server sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),'..'))) app = create_app() manager = Manager(app) manager.add_command("runserver", Server( use_debugger = True, use_reloader = True, host = os.getenv('IP', '0.0.0.0'), port = int(os.getenv('PORT', 5000))) ) if __name__ == "__main"
def __init__(self, server_address=ServerAddress): self.server_address = server_address self.server_proxy = XMLRPCServerProxy( "http://%s:%s" % self.srever_address, allow_none=None)
def make_pypi_client(url): return Server(url)
# testing xmlrpc finger try: # Python 3 from xmlrpc.client import Server except ImportError: # Python 2 from xmlrpclib import Server server = Server('http://127.0.0.1:8000/RPC2') print(server.getUser('moshez'))