def __init__(self, user, password):
self.username = user
self.server = xmlrpc_client.Server(WEBFACTION_API_ENDPOINT)
try:
self.session_id, _ = self.server.login(self.username, password)
except xmlrpc_client.Fault as e:
raise WebFactionFault(e)
def connect(hostPort=None,
useSSL=None,
tsPath=None,
TransportClass=sslutils.VerifyingSafeTransport,
timeout=sslutils.SOCKET_DEFAULT_TIMEOUT):
hostPort = cannonizeHostPort(hostPort)
if useSSL is None:
useSSL = _USE_SSL
if tsPath is None:
tsPath = _TRUSTED_STORE_PATH
if useSSL:
KEYFILE = tsPath + '/keys/vdsmkey.pem'
CERTFILE = tsPath + '/certs/vdsmcert.pem'
CACERT = tsPath + '/certs/cacert.pem'
for f in (KEYFILE, CERTFILE, CACERT):
if not os.access(f, os.R_OK):
raise Exception("No permission to read file: %s" % f)
transport = TransportClass(key_file=KEYFILE,
cert_file=CERTFILE,
ca_certs=CACERT,
timeout=timeout)
server = xmlrpclib.ServerProxy('https://%s' % hostPort,
wrap_transport(transport))
else:
transport = wrap_transport(SingleRequestTransport(timeout=timeout))
server = xmlrpclib.Server('http://%s' % hostPort, transport)
return server
def dd_environment():
with docker_run(compose_file=os.path.join(HERE, 'compose',
'supervisord.yaml'),
endpoints=URL):
server = xmlrpclib.Server('{}/RPC2'.format(URL))
server.supervisor.startAllProcesses()
yield SUPERVISORD_CONFIG
def open_session(self):
# type: () -> Dict[str, str]
try:
self.xenserver = xmlrpclib.Server(self._base_url)
except Exception as e:
self.log.warning(str(e))
return {}
# See reference https://xapi-project.github.io/xen-api/classes/session.html
session = self._session_login(self.xenserver)
if session.get('Status') == 'Failure':
if 'SESSION_AUTHENTICATION_FAILED' in session.get(
'ErrorDescription', []):
self.log.warning('Connection failed with xmlrpc: %s',
str(session['ErrorDescription']))
return {}
if 'HOST_IS_SLAVE' in session.get('ErrorDescription', []):
# If xenserver host is a slave, open a connection with the pool master
# {'Status': 'Failure', 'ErrorDescription': ['HOST_IS_SLAVE', '192.168.101.102']}
self.log.debug(
'Host is a slave, trying to connect to the pool master')
self._additional_tags.append('server_type:slave')
return self._get_master_session(session)
self.log.warning('Unknown xmlrpc error: %s', str(session))
return {}
elif session.get('Status') == 'Success':
self._additional_tags.append('server_type:master')
return session
return {}
def __init__(self, url, user, password):
self.user = user
self.password = password
if not url.startswith('http://') and not url.startswith('https://'):
url = 'http://' + url
if not url.endswith(XMLRPC_PATH):
if not url.endswith('/'):
url += '/'
url += XMLRPC_PATH
self.service_url = url
self.server = xmlrpc_client.Server(self.service_url)
self.base_url = self.service_url.replace(XMLRPC_PATH, '')
def _connect(instance):
sock = instance.get('socket')
if sock is not None:
host = instance.get('host', DEFAULT_SOCKET_IP)
transport = supervisor.xmlrpc.SupervisorTransport(None, None, sock)
server = xmlrpclib.ServerProxy(host, transport=transport)
else:
host = instance.get('host', DEFAULT_HOST)
port = instance.get('port', DEFAULT_PORT)
user = instance.get('user')
password = instance.get('pass')
auth = '{}:{}@'.format(user, password) if user and password else ''
server = xmlrpclib.Server('http://{}{}:{}/RPC2'.format(auth, host, port))
return server.supervisor
def _get_master_session(self, session):
# type: (Dict[str, str]) -> Dict[str, str]
# {'Status': 'Failure', 'ErrorDescription': ['HOST_IS_SLAVE', '192.168.101.102']}
if len(session.get('ErrorDescription', [])) < 1:
return {}
master_address = session['ErrorDescription'][1]
if not master_address.startswith('http://'):
master_address = 'http://' + master_address
master_xenserver = xmlrpclib.Server(master_address)
# Master credentials can be different, we could specify new `master_username` and
# `master_password` options later if requested
master_session = self._session_login(master_xenserver)
if master_session.get('Status') == 'Success':
self.xenserver = master_xenserver
return master_session
return {}
def Login(self):
self.podserver = xmlrpc_client.Server('http://ssp.podnapisi.net:8000')
init = self.podserver.initiate(USER_AGENT)
hash = md5()
hash.update(settings_provider.getSetting("PNpass"))
self.password = sha256(str(hash.hexdigest()) +
str(init['nonce'])).hexdigest()
self.user = settings_provider.getSetting("PNuser")
if init['status'] == 200:
self.pod_session = init['session']
auth = self.podserver.authenticate(self.pod_session, self.user,
self.password)
if auth['status'] == 300:
log(__name__, "Authenticate [%s]" % "InvalidCredentials")
raise SubtitlesDownloadError(
SubtitlesErrors.INVALID_CREDENTIALS_ERROR,
"provided invalid credentials")
self.connected = False
else:
log(__scriptid__, "Connected to Podnapisi server")
self.connected = True
else:
self.connected = False
def get(self, name, imdb, season, episode):
try:
if not control.setting('subtitles') == 'true':
raise Exception()
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 Exception:
langs.append(langDict[control.setting('subtitles.lang.1')])
except Exception:
pass
try:
try:
langs = langs + langDict[control.setting('subtitles.lang.2')].split(',')
except Exception:
langs.append(langDict[control.setting('subtitles.lang.2')])
except Exception:
pass
try:
subLang = xbmc.Player().getSubtitles()
except Exception:
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']
sublanguageid = ','.join(langs)
imdbid = re.sub('[^0-9]', '', imdb)
if not (season == None or episode == 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 Exception:
vidPath = ''
fmt = re.split('\.|\(|\)|\[|\]|\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 Exception:
lang = filter[0]['SubLanguageID']
content = [filter[0]['IDSubtitleFile'], ]
content = server.DownloadSubtitles(token, content)
content = base64.b64decode(content['data'][0]['data'])
content = gzip.GzipFile(fileobj=six.BytesIO(content)).read()
if six.PY3: content = six.ensure_text(content)
subtitle = control.transPath('special://temp/')
subtitle = os.path.join(subtitle, 'TemporarySubs.%s.srt' % lang)
codepage = codePageDict.get(lang, '')
if codepage and control.setting('subtitles.utf') == 'true':
try:
content_encoded = codecs.decode(content, codepage)
content = codecs.encode(content_encoded, 'utf-8')
except Exception:
pass
file = control.openFile(subtitle, 'w')
file.write(str(content))
file.close()
control.sleep(1000)
xbmc.Player().setSubtitles(subtitle)
except Exception:
pass
def __init__(self, deployment, config):
super(CobblerProvider, self).__init__(deployment, config)
self.config = config
self.cobbler = xmlrpclib.Server(uri="http://%s/cobbler_api" %
config["host"])
def xmlrpcmethod(uri, method):
server = xmlrpc_client.Server(uri)
try:
return getattr(server, method)
except Exception:
raise AttributeError("Error occurred while getting server method")
def xmlrpctoken(uri, login, password):
server = xmlrpc_client.Server(uri)
try:
return server.login(login, password)
except Exception:
raise error.AuthenticationError("Error occurred while login process")
def __init__(self, user_agent=''):
self.server = xmlrpc_client.Server(BASE_URL_XMLRPC, verbose=0)
#login = self.server.LogIn("", "", "en", "%s_v%s" % (__scriptname__.replace(" ", "_"), __version__))
login = self.server.LogIn('', '', 'en', user_agent)
self.osdb_token = login["token"]
