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
