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 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 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'))
