from datetime import datetime, timedelta import xmlrpc.client as xmlrpclib from mcstatus import MinecraftServer from supervisor.states import ProcessStates from supervisor.xmlrpc import SupervisorTransport import parsedatetime port = 25566 mcserver = MinecraftServer('localhost', port) transport = SupervisorTransport(None, None, 'http://localhost:9001/RPC2') transport.verbose = True server = xmlrpclib.Server('http://unused', transport=transport) cal = parsedatetime.Calendar() GRACE_PERIOD = cal.parseDT(os.environ.get('GRACE_PERIOD', '10 minutes'), sourceTime=datetime.min)[0] - datetime.min print(GRACE_PERIOD) # state machine class PersistentState: wait_begin = None start_begin = None persistent = PersistentState()
def do_login(self, args): arg_parser = get_argument_parser() (args, _options) = parse_command_arguments(args, arg_parser) # logout before logging in again if self.session: logging.warning(_N('You are already logged in')) return True # an argument passed to the function get precedence if len(args) == 2: server = args[1] else: # use the server we were already using server = self.config.get("server") # bail out if not server was given if not server: logging.warning(_N('No server specified')) return False # load the server-specific configuration self.load_config_section(server) # an argument passed to the function get precedence if args: username = args[0] elif 'username' in self.config: # use the username from before username = self.config['username'] elif self.options.username: # use the username from before username = self.options.username else: username = '' # set the protocol if self.config.get("nossl"): proto = 'http' else: proto = 'https' server_url = '%s://%s/rpc/api' % (proto, server) # this will enable spewing out all client/server traffic verbose_xmlrpc = False if self.options.debug > 1: verbose_xmlrpc = True # connect to the server logging.debug('Connecting to %s', server_url) self.client = xmlrpclib.Server(server_url, verbose=verbose_xmlrpc) # check the API to verify connectivity # pylint: disable=W0702 try: self.api_version = self.client.api.getVersion() logging.debug('Server API Version = %s', self.api_version) except Exception as exc: # pylint: disable=broad-except if self.options.debug > 0: e = sys.exc_info()[0] logging.exception(e) logging.error(_N('Failed to connect to %s'), server_url) logging.debug("Error while connecting to the server %s: %s", server_url, str(exc)) self.client = None return False # ensure the server is recent enough if float(self.api_version) < self.MINIMUM_API_VERSION: logging.error(_N('API (%s) is too old (>= %s required)'), self.api_version, self.MINIMUM_API_VERSION) self.client = None return False # Handle initial org and user creation # Only 'self.client' object required, skip login and session caching if 'org_createfirst' in self.options.command: return True # store the session file in the server's own directory session_file = os.path.join(self.conf_dir, server, 'session') # retrieve a cached session if os.path.isfile(session_file) and not self.options.password: try: sessionfile = open(session_file, 'r') # read the session (format = username:session) for line in sessionfile.readlines(): parts = line.split(':') # if a username was passed, make sure it matches if username: if parts[0] == username: self.session = parts[1] else: # get the username from the cache if one # wasn't passed by the user username = parts[0] self.session = parts[1] sessionfile.close() except IOError: logging.error(_N('Could not read %s'), session_file) # check the cached credentials by doing an API call if self.session: try: logging.debug('Using cached credentials from %s', session_file) self.client.user.listAssignableRoles(self.session) except xmlrpclib.Fault: logging.warning(_N('Cached credentials are invalid')) self.current_user = '' self.session = '' # attempt to login if we don't have a valid session yet if not self.session: if username: logging.info(_N('Spacewalk Username: %s'), username) else: username = prompt_user(_('Spacewalk Username:'******'login' is called # again, the user is prompted for the information self.options.password = None elif 'password' in self.config: password = self.config['password'] else: password = getpass(_('Spacewalk Password: '******'Invalid credentials')) logging.debug("Login error: %s (%s)", exc.faultString, exc.faultCode) return False try: # make sure ~/.spacecmd/<server> exists conf_dir = os.path.join(self.conf_dir, server) if not os.path.isdir(conf_dir): os.mkdir(conf_dir, int('0700', 8)) # add the new cache to the file line = '%s:%s\n' % (username, self.session) # write the new cache file out sessionfile = open(session_file, 'w') sessionfile.write(line) sessionfile.close() except IOError as exc: logging.error(_N('Could not write session file: %s'), str(exc)) # load the system/package/errata caches self.load_caches(server, username) # keep track of who we are and who we're connected to self.current_user = username self.server = server logging.info(_N('Connected to %s as %s'), server_url, username) return True
def get(self, name, imdb, season, episode): try: import gzip, codecs from io import BytesIO import re, base64 import xmlrpc.client as xmlrpc_client except: log_utils.error() return try: langDict = { 'Afrikaans': 'afr', 'Albanian': 'alb', 'Arabic': 'ara', 'Armenian': 'arm', 'Basque': 'baq', 'Bengali': 'ben', 'Bosnian': 'bos', 'Breton': 'bre', 'Bulgarian': 'bul', 'Burmese': 'bur', 'Catalan': 'cat', 'Chinese': 'chi', 'Croatian': 'hrv', 'Czech': 'cze', 'Danish': 'dan', 'Dutch': 'dut', 'English': 'eng', 'Esperanto': 'epo', 'Estonian': 'est', 'Finnish': 'fin', 'French': 'fre', 'Galician': 'glg', 'Georgian': 'geo', 'German': 'ger', 'Greek': 'ell', 'Hebrew': 'heb', 'Hindi': 'hin', 'Hungarian': 'hun', 'Icelandic': 'ice', 'Indonesian': 'ind', 'Italian': 'ita', 'Japanese': 'jpn', 'Kazakh': 'kaz', 'Khmer': 'khm', 'Korean': 'kor', 'Latvian': 'lav', 'Lithuanian': 'lit', 'Luxembourgish': 'ltz', 'Macedonian': 'mac', 'Malay': 'may', 'Malayalam': 'mal', 'Manipuri': 'mni', 'Mongolian': 'mon', 'Montenegrin': 'mne', 'Norwegian': 'nor', 'Occitan': 'oci', 'Persian': 'per', 'Polish': 'pol', 'Portuguese': 'por,pob', 'Portuguese(Brazil)': 'pob,por', 'Romanian': 'rum', 'Russian': 'rus', 'Serbian': 'scc', 'Sinhalese': 'sin', 'Slovak': 'slo', 'Slovenian': 'slv', 'Spanish': 'spa', 'Swahili': 'swa', 'Swedish': 'swe', 'Syriac': 'syr', 'Tagalog': 'tgl', 'Tamil': 'tam', 'Telugu': 'tel', 'Thai': 'tha', 'Turkish': 'tur', 'Ukrainian': 'ukr', 'Urdu': 'urd' } codePageDict = { 'ara': 'cp1256', 'ar': 'cp1256', 'ell': 'cp1253', 'el': 'cp1253', 'heb': 'cp1255', 'he': 'cp1255', 'tur': 'cp1254', 'tr': 'cp1254', 'rus': 'cp1251', 'ru': 'cp1251' } quality = [ 'bluray', 'hdrip', 'brrip', 'bdrip', 'dvdrip', 'webrip', 'hdtv' ] langs = [] try: try: langs = langDict[control.setting( 'subtitles.lang.1')].split(',') except: langs.append(langDict[control.setting('subtitles.lang.1')]) except: pass try: try: langs = langs + langDict[control.setting( 'subtitles.lang.2')].split(',') except: langs.append(langDict[control.setting('subtitles.lang.2')]) except: pass try: subLang = xbmc.Player().getSubtitles() except: subLang = '' if subLang == langs[0]: raise Exception() server = xmlrpc_client.Server( 'https://api.opensubtitles.org/xml-rpc', verbose=0) # token = server.LogIn('', '', 'en', 'XBMC_Subtitles_v1') token = server.LogIn( '', '', 'en', 'XBMC_Subtitles_Unofficial_v5.2.14' ) # service.subtitles.opensubtitles_by_opensubtitles if 'token' not in token: return log_utils.log('OpenSubtitles Login failed: token=%s' % token, level=log_utils.LOGWARNING) else: token = token['token'] sublanguageid = ','.join(langs) imdbid = re.sub(r'[^0-9]', '', imdb) if not (season is None or episode is None): result = server.SearchSubtitles(token, [{ 'sublanguageid': sublanguageid, 'imdbid': imdbid, 'season': season, 'episode': episode }])['data'] fmt = ['hdtv'] else: result = server.SearchSubtitles(token, [{ 'sublanguageid': sublanguageid, 'imdbid': imdbid }])['data'] try: vidPath = xbmc.Player().getPlayingFile() except: vidPath = '' fmt = re.split(r'\.|\(|\)|\[|\]|\s|\-', vidPath) fmt = [i.lower() for i in fmt] fmt = [i for i in fmt if i in quality] filter = [] result = [i for i in result if i['SubSumCD'] == '1'] for lang in langs: filter += [ i for i in result if i['SubLanguageID'] == lang and any( x in i['MovieReleaseName'].lower() for x in fmt) ] filter += [ i for i in result if i['SubLanguageID'] == lang and any( x in i['MovieReleaseName'].lower() for x in quality) ] filter += [i for i in result if i['SubLanguageID'] == lang] try: lang = xbmc.convertLanguage(filter[0]['SubLanguageID'], xbmc.ISO_639_1) except: lang = filter[0]['SubLanguageID'] filename = filter[0]['SubFileName'] log_utils.log('downloaded subtitle=%s' % filename, level=log_utils.LOGDEBUG) content = [ filter[0]['IDSubtitleFile'], ] content = server.DownloadSubtitles(token, content) content = base64.b64decode(content['data'][0]['data']) content = gzip.GzipFile(fileobj=BytesIO(content)).read() subtitle = control.transPath('special://temp/') subtitle = control.joinPath(subtitle, 'TemporarySubs.%s.srt' % lang) log_utils.log('subtitle file = %s' % subtitle, level=log_utils.LOGDEBUG) codepage = codePageDict.get(lang, '') if codepage and control.setting('subtitles.utf') == 'true': try: content_encoded = codecs.decode( content, codepage) # check for kodi 19? content = codecs.encode(content_encoded, 'utf-8') # check for kodi 19? except: pass file = control.openFile(subtitle, 'w') file.write(content) file.close() xbmc.sleep(1000) xbmc.Player().setSubtitles(subtitle) if control.setting('subtitles.notification') == 'true': if Player().isPlayback(): control.sleep(500) control.notification(title=filename, message=control.lang(32191) % lang.upper()) except: log_utils.error()
Created on 13 Sep. 2017 @author: nikhils List down properties of users. This wull create UserIdProperty.csv' in C:\temp folder.. UserID','account-selection.mode','account-selection.can-charge-personal','account-selection.can-charge-shared-from-list','account-selection.can-charge-shared-by-pin''auto-shared-account','default-shared-account' ''' from xmlrpc import client import os import os.path import csv # #CHNAGE it as your application Server IP/hostname host_name = 'localhost' port = 9191 print("Connecting to server {0} on port {1} ...".format(host_name, port)) server = client.Server('http://%s:%d/rpc/api/xmlrpc' % (host_name, port)) # #CHNAGE as per your admin password or auth token token = 'token' directory = 'c:\\tmp\\' if not os.path.exists(directory): os.makedirs(directory) os.chdir(directory) def main(): ual = [] ual = server.api.listUserAccounts(token, 0, 1000) with open('UserIdProperty.csv', 'w', newline='\n') as f: wr = csv.writer(f) wr.writerow(['UserID','account-selection.mode','account-selection.can-charge-personal',\
def pep440(cached=False): cache_path = os.path.join(CACHE, "pep440.json") # If we were given --cached, then we want to attempt to use cached data if # possible if cached: try: with open(cache_path, "r") as fp: data = json.load(fp) except Exception: data = None else: data = None # If we don't have data, then let's go fetch it from PyPI if data is None: bar = progress.bar.ShadyBar("Fetching Versions") client = xmlrpc_client.Server("https://pypi.python.org/pypi") data = dict([(project, client.package_releases(project, True)) for project in bar.iter(client.list_packages())]) os.makedirs(os.path.dirname(cache_path), exist_ok=True) with open(cache_path, "w") as fp: json.dump(data, fp) # Get a list of all of the version numbers on PyPI all_versions = list(itertools.chain.from_iterable(data.values())) # Determine the total number of versions which are compatible with the # current routine parsed_versions = [ _parse_version(v) for v in all_versions if _parse_version(v) is not None ] # Determine a list of projects that sort exactly the same between # pkg_resources and PEP 440 compatible_sorting = [ project for project, versions in data.items() if (sorted(versions, key=pkg_resources.parse_version) == sorted( (x for x in versions if _parse_version(x)), key=Version)) ] # Determine a list of projects that sort exactly the same between # pkg_resources and PEP 440 when invalid versions are filtered out filtered_compatible_sorting = [ project for project, versions in (( p, [v for v in vs if _parse_version(v) is not None]) for p, vs in data.items()) if (sorted(versions, key=pkg_resources.parse_version) == sorted( versions, key=Version)) ] # Determine a list of projects which do not have any versions that are # valid with PEP 440 and which have any versions registered only_invalid_versions = [ project for project, versions in data.items() if (versions and not [v for v in versions if _parse_version(v) is not None]) ] # Determine a list of projects which have matching latest versions between # pkg_resources and PEP 440 differing_latest_versions = [ project for project, versions in data.items() if (sorted(versions, key=pkg_resources.parse_version)[-1:] != sorted( (x for x in versions if _parse_version(x)), key=Version)[-1:]) ] # Print out our findings print("Total Version Compatibility: {}/{} ({:.2%})".format( len(parsed_versions), len(all_versions), len(parsed_versions) / len(all_versions), )) print("Total Sorting Compatibility (Unfiltered): {}/{} ({:.2%})".format( len(compatible_sorting), len(data), len(compatible_sorting) / len(data))) print("Total Sorting Compatibility (Filtered): {}/{} ({:.2%})".format( len(filtered_compatible_sorting), len(data), len(filtered_compatible_sorting) / len(data), )) print("Projects with No Compatible Versions: {}/{} ({:.2%})".format( len(only_invalid_versions), len(data), len(only_invalid_versions) / len(data), )) print("Projects with Differing Latest Version: {}/{} ({:.2%})".format( len(differing_latest_versions), len(data), len(differing_latest_versions) / len(data), ))
LOCAL_ANSIBLE_CACHE = "/var/cache/ansible/" parser = argparse.ArgumentParser( description= 'Bootstrap an Ansible systems as minion in SUSE Manager using salt-ssh.') parser.add_argument("-s", "--systemid", required=True, dest="systemid", help="the system id for the server in SUSE Manager") parser.add_argument("-m", "--machineid", required=True, dest="machineid", help="the machine id to set") args = parser.parse_args() # Connect to SUSE Manager XMLRPC API and import missing Ansible systems client = xmlrpclib.Server(SATELLITE_URL, verbose=0) key = client.auth.login(SATELLITE_LOGIN, SATELLITE_PASSWORD) print("* Set machine ID from the Ansible system {} to: {}".format( args.systemid, args.machineid)) client.system.changeMachineIdForSystem(key, int(args.systemid), args.machineid) # Logging out client.auth.logout(key) # Done print("* Done!")
def get_a_peer(node, search_node): myserver = client.Server(node + '/seed') try: response = myserver.send_a_peer(search_node) except: raise ("ERROR getting node information from " + node["id"])
#!/usr/bin/python3 from xmlrpc import client import os import sys import datetime HOST = "" USER = "" PASS = "" command = "puppet agent -t" when = "2018-12-11 21:00:00" client = client.Server(HOST) key = client.auth.login(USER, PASS) systemlist = client.systemgroup.listSystems(key, "CentOS7") systemsid = [] for system in systemlist: systemsid.append(system['id']) client.system.scheduleScriptRun(key, systemsid, "root", "root", 300, command, when) client.auth.logout(key)
def __init__(self, site): self.site = site self._keys = None self.server = xc.Server(ARCHIVE_SITE_URL[site])
config = configparser.ConfigParser() config['DEFAULT'] = {'SATELLITE_URL': "https://your_satellite_url", 'SATELLITE_LOGIN': "******", 'SATELLITE_PASSWORD': "******"} config.read('config.ini') SATELLITE_URL = config['DEFAULT']['SATELLITE_URL'] SATELLITE_LOGIN = config['DEFAULT']['SATELLITE_LOGIN'] SATELLITE_PASSWORD = config['DEFAULT']['SATELLITE_PASSWORD'] if len(argv) is 1: print("Syntax: %s <asset name>" % argv[0]) exit(1) #Populate a list of systems from Spacewalk with xc.Server(SATELLITE_URL, verbose=0) as client: try: key = client.auth.login(SATELLITE_LOGIN, SATELLITE_PASSWORD) query = client.system.listSystems(key) except: logger.error("Error connecting to Spacewalk: %s" % exc_info()[1]) exit(1) system = None for item in query: if argv[1] == item["name"]: system = item break if system is not None: for item in 'id','name','last_checkin': print("%s: %s" % (item, system[item])) print("CPU: ")
from django.test import TestCase # Create your tests here. from xmlrpc import client remote = client.Server("http://192.168.1.138/cobbler_api") token = remote.login("cobbler", "cobbler") system_id = remote.new_system(token) remote.modify_system(system_id, "name", "centos2", token) remote.modify_system(system_id, "hostname", "hostname.example.com", token) remote.modify_system(system_id, "gateway", "192.168.1.1", token) remote.modify_system(system_id, "name_servers", "8.8.8.8", token) # 关联内核参数,相当于cobbler profile edit --name=CentOS7.2-x86_64 --kopts=‘net.ifnames=0 biosdevname=0‘,这个装6系统不需要 #remote.modify_system(system_id, "kernel_options", "net.ifnames=0 biosdevname=0", token) remote.modify_system( system_id, 'modify_interface', { "macaddress-eth0": "01:02:03:04:05:07", "ipaddress-eth0": "192.168.1.80", "gateway-eth0": "192.168.1.2", # 改参数不能用 "subnet-eth0": "255.255.255.0", "static-eth0": 1, #"dnsname-eth0": "114.114.114.114" }, token) remote.modify_system(system_id, "profile", "CentOS-6.9-x86_64", token) remote.modify_system(system_id, "ks_meta",
from xmlrpc import client if __name__ == "__main__": try: server = client.Server("http://localhost:9005/RPC2") info = server.supervisor.getAllProcessInfo() error_states = list(filter(lambda x: x["state"] != 20, info)) exit(len(error_states)) except Exception as e: print(e.with_traceback()) exit(1)
try: import xmlrpc.client as xmlrpclib except ImportError: import xmlrpclib s = xmlrpclib.Server("http://127.0.0.1:5000/skitai") print s.indians(10) m = xmlrpclib.MultiCall(s) m.indians(100) m.indians(200) m.indians(100) r = m() print tuple(r)
time.sleep(4) continue except KeyboardInterrupt: process(token, server, subs) break process(subs) try: sys.argv[5] except: print( '{} [username] [password] [show name] [seasonstart]-[seasonend] [episodestart]-[episodeend]' .format(sys.argv[0])) server = client.Server('http://api.opensubtitles.org/xml-rpc') try: with open('token', 'r') as f: token = f.read() except: token = server.LogIn(sys.argv[1], sys.argv[2], 'en', 'TemporaryUserAgent')['token'] with open('token', 'w') as f: f.write(token) print('hit Ctrl-c when you don\' see any more subtitles being grabbed') seasons = sys.argv[4].split('-') episodes = sys.argv[5].split('-') get_all_seasons(token, server, sys.argv[3], range(int(seasons[0]), int(seasons[1]) + 1),
def get_testlink_integration(self): #enter code hereenter code here client = xc.Server('http://' + host + ':' + port + '/RPC2') client.supervisor.getState() client.supervisor.getProcessInfo('process name')
def get_peers(node): myserver = client.Server(node + '/seed') try: response = myserver.send_peers() except: raise ("ERROR getting peers")
#!/usr/bin/python3 """Get/set channel for automatic frequency fine tunning. Usage: tetrapol_cli_auto_tune.py [CH_NO]""" from xmlrpc import client import sys c = client.Server("http://localhost:60100") if len(sys.argv) == 2: c.set_auto_tune(int(sys.argv[1])) else: print(c.get_auto_tune())
# f.close() # # #Read XML file # xml_file = open(DIREC+"/XML"+trial_id+".xml","r") # # xml="" # buffer=1 # while buffer: # buffer = xml_file.read() # xml+= buffer # xml_file.close() # os.remove(DIREC+"/XML"+trial_id+".xml") #------------------------------SEND TO NEOS AND RETRIEVE RESULTS neos = xmlrpclib.Server("https://%s:%d" % (NEOS_HOST, NEOS_PORT)) xml = ''.join(xml_text) # convert from list to string (jobNumber, password) = neos.submitJob(xml) #uncomment to print out partial job while running #sys.stdout.write("JobNumber = %d " % jobNumber) offset = 0 status = "" while status != "Done": (msg, offset) = neos.getIntermediateResults(jobNumber, password, offset) #sys.stdout.write(msg.data.decode()) status = neos.getJobStatus(jobNumber, password) #------------------------------WRITE RESULTS