419 lines
No EOL
16 KiB
Python
419 lines
No EOL
16 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
###############################################################################
|
|
|
|
# import json
|
|
import requests
|
|
# import logging
|
|
|
|
# import xbmc
|
|
import xbmcgui
|
|
|
|
import utils
|
|
import clientinfo
|
|
|
|
import PlexAPI
|
|
try:
|
|
import xml.etree.cElementTree as etree
|
|
except ImportError:
|
|
import xml.etree.ElementTree as etree
|
|
|
|
###############################################################################
|
|
|
|
# Disable requests logging
|
|
from requests.packages.urllib3.exceptions import InsecureRequestWarning
|
|
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
|
|
# logging.getLogger('requests').setLevel(logging.WARNING)
|
|
|
|
###############################################################################
|
|
|
|
|
|
@utils.logging
|
|
class DownloadUtils():
|
|
|
|
# Borg - multiple instances, shared state
|
|
_shared_state = {}
|
|
clientInfo = clientinfo.ClientInfo()
|
|
|
|
# Requests session
|
|
s = None
|
|
timeout = 10
|
|
|
|
def __init__(self):
|
|
|
|
self.__dict__ = self._shared_state
|
|
|
|
def setUsername(self, username):
|
|
# Reserved for userclient only
|
|
self.username = username
|
|
self.logMsg("Set username: %s" % username, 2)
|
|
|
|
def setUserId(self, userId):
|
|
# Reserved for userclient only
|
|
self.userId = userId
|
|
self.logMsg("Set userId: %s" % userId, 2)
|
|
|
|
def setServer(self, server):
|
|
# Reserved for userclient only
|
|
self.server = server
|
|
self.logMsg("Set server: %s" % server, 2)
|
|
|
|
def setToken(self, token):
|
|
# Reserved for userclient only
|
|
self.token = token
|
|
self.logMsg("Set token: xxxxxxx", 2)
|
|
|
|
def setSSL(self, ssl, sslclient):
|
|
# Reserved for userclient only
|
|
self.sslverify = ssl
|
|
self.sslclient = sslclient
|
|
self.logMsg("Verify SSL host certificate: %s" % ssl, 2)
|
|
self.logMsg("SSL client side certificate: %s" % sslclient, 2)
|
|
|
|
|
|
def postCapabilities(self, deviceId):
|
|
|
|
# Post settings to session
|
|
url = "{server}/emby/Sessions/Capabilities/Full?format=json"
|
|
data = {
|
|
|
|
'PlayableMediaTypes': "Audio,Video",
|
|
'SupportsMediaControl': True,
|
|
'SupportedCommands': (
|
|
|
|
"MoveUp,MoveDown,MoveLeft,MoveRight,Select,"
|
|
"Back,ToggleContextMenu,ToggleFullscreen,ToggleOsdMenu,"
|
|
"GoHome,PageUp,NextLetter,GoToSearch,"
|
|
"GoToSettings,PageDown,PreviousLetter,TakeScreenshot,"
|
|
"VolumeUp,VolumeDown,ToggleMute,SendString,DisplayMessage,"
|
|
"SetAudioStreamIndex,SetSubtitleStreamIndex,"
|
|
|
|
"Mute,Unmute,SetVolume,"
|
|
"Play,Playstate,PlayNext"
|
|
)
|
|
}
|
|
|
|
self.logMsg("Capabilities URL: %s" % url, 2)
|
|
self.logMsg("Postdata: %s" % data, 2)
|
|
|
|
self.downloadUrl(url, postBody=data, type="POST")
|
|
self.logMsg("Posted capabilities to %s" % self.server, 2)
|
|
|
|
# Attempt at getting sessionId
|
|
url = "{server}/emby/Sessions?DeviceId=%s&format=json" % deviceId
|
|
result = self.downloadUrl(url)
|
|
try:
|
|
sessionId = result[0]['Id']
|
|
|
|
except (KeyError, TypeError):
|
|
self.logMsg("Failed to retrieve sessionId.", 1)
|
|
|
|
else:
|
|
self.logMsg("Session: %s" % result, 2)
|
|
self.logMsg("SessionId: %s" % sessionId, 1)
|
|
utils.window('emby_sessionId', value=sessionId)
|
|
|
|
# Post any permanent additional users
|
|
# additionalUsers = utils.settings('additionalUsers')
|
|
# if additionalUsers:
|
|
|
|
# additionalUsers = additionalUsers.split(',')
|
|
# self.logMsg(
|
|
# "List of permanent users added to the session: %s"
|
|
# % additionalUsers, 1)
|
|
|
|
# # Get the user list from server to get the userId
|
|
# url = "{server}/emby/Users?format=json"
|
|
# result = self.downloadUrl(url)
|
|
|
|
# for additional in additionalUsers:
|
|
# addUser = additional.decode('utf-8').lower()
|
|
|
|
# # Compare to server users to list of permanent additional users
|
|
# for user in result:
|
|
# username = user['Name'].lower()
|
|
|
|
# if username in addUser:
|
|
# userId = user['Id']
|
|
# url = (
|
|
# "{server}/emby/Sessions/%s/Users/%s?format=json"
|
|
# % (sessionId, userId)
|
|
# )
|
|
# self.downloadUrl(url, postBody={}, type="POST")
|
|
|
|
|
|
def startSession(self):
|
|
|
|
log = self.logMsg
|
|
|
|
self.deviceId = self.clientInfo.getDeviceId()
|
|
|
|
# User is identified from this point
|
|
# Attach authenticated header to the session
|
|
verify = False
|
|
header = self.getHeader()
|
|
|
|
# If user enabled host certificate verification
|
|
try:
|
|
verify = self.sslverify
|
|
if self.sslclient is not None:
|
|
verify = self.sslclient
|
|
except:
|
|
log("Could not load SSL settings.", 1)
|
|
|
|
# Start session
|
|
self.s = requests.Session()
|
|
self.s.headers = header
|
|
self.s.verify = verify
|
|
# Retry connections to the server
|
|
self.s.mount("http://", requests.adapters.HTTPAdapter(max_retries=1))
|
|
self.s.mount("https://", requests.adapters.HTTPAdapter(max_retries=1))
|
|
|
|
log("Requests session started on: %s" % self.server, 1)
|
|
|
|
def stopSession(self):
|
|
try:
|
|
self.s.close()
|
|
except:
|
|
self.logMsg("Requests session could not be terminated.", 1)
|
|
|
|
def getHeader(self, authenticate=True, options={}):
|
|
plx = PlexAPI.PlexAPI()
|
|
if authenticate:
|
|
options['X-Plex-Token'] = self.token
|
|
header = plx.getXArgsDeviceInfo(options=options)
|
|
else:
|
|
header = plx.getXArgsDeviceInfo(options=options)
|
|
return header
|
|
|
|
def downloadUrl(self, url, postBody=None, type="GET", parameters=None, authenticate=True, headerOptions={}):
|
|
|
|
# self.logMsg("=== ENTER downloadUrl ===", 2)
|
|
|
|
timeout = self.timeout
|
|
default_link = ""
|
|
|
|
try:
|
|
# If user is authenticated
|
|
if (authenticate):
|
|
# Get requests session
|
|
try:
|
|
s = self.s
|
|
# Replace for the real values
|
|
url = url.replace("{server}", self.server)
|
|
url = url.replace("{UserId}", self.userId)
|
|
header = self.getHeader(options=headerOptions)
|
|
# Prepare request
|
|
if type == "GET":
|
|
r = s.get(url, json=postBody, params=parameters, timeout=timeout, headers=header)
|
|
elif type == "POST":
|
|
r = s.post(url, json=postBody, timeout=timeout, headers=header)
|
|
elif type == "DELETE":
|
|
r = s.delete(url, json=postBody, timeout=timeout, headers=header)
|
|
elif type == "OPTIONS":
|
|
r = s.options(url, json=postBody, timeout=timeout, headers=header)
|
|
# For Plex Companion
|
|
elif type == "POSTXML":
|
|
r = s.post(url, postBody, timeout=timeout, headers=header)
|
|
elif type == "PUT":
|
|
r = s.put(url, timeout=timeout, headers=header)
|
|
|
|
except AttributeError:
|
|
# request session does not exists
|
|
self.logMsg("Request session does not exist: start one", 1)
|
|
# Get user information
|
|
self.userId = utils.window('currUserId')
|
|
self.server = utils.window('pms_server')
|
|
self.token = utils.window('pms_token')
|
|
header = self.getHeader(options=headerOptions)
|
|
verifyssl = False
|
|
cert = None
|
|
|
|
# IF user enables ssl verification
|
|
if utils.settings('sslverify') == "true":
|
|
verifyssl = True
|
|
if utils.settings('sslcert') != "None":
|
|
verifyssl = utils.settings('sslcert')
|
|
|
|
# Replace for the real values
|
|
url = url.replace("{server}", self.server)
|
|
url = url.replace("{UserId}", self.userId)
|
|
|
|
# Prepare request
|
|
if type == "GET":
|
|
r = requests.get(url,
|
|
json=postBody,
|
|
params=parameters,
|
|
headers=header,
|
|
timeout=timeout,
|
|
verify=verifyssl)
|
|
|
|
elif type == "POST":
|
|
r = requests.post(url,
|
|
json=postBody,
|
|
headers=header,
|
|
timeout=timeout,
|
|
verify=verifyssl)
|
|
|
|
elif type == "DELETE":
|
|
r = requests.delete(url,
|
|
json=postBody,
|
|
headers=header,
|
|
timeout=timeout,
|
|
verify=verifyssl)
|
|
|
|
elif type == "OPTIONS":
|
|
r = requests.options(url,
|
|
json=postBody,
|
|
headers=header,
|
|
timeout=timeout,
|
|
cert=cert,
|
|
verify=verifyssl)
|
|
|
|
elif type == "PUT":
|
|
r = requests.put(url,
|
|
json=postBody,
|
|
headers=header,
|
|
timeout=timeout,
|
|
cert=cert,
|
|
verify=verifyssl)
|
|
# If user is not authenticated
|
|
elif not authenticate:
|
|
|
|
header = self.getHeader(authenticate=False, options=headerOptions)
|
|
|
|
# If user enables ssl verification
|
|
try:
|
|
verifyssl = self.sslverify
|
|
if self.sslclient is not None:
|
|
verifyssl = self.sslclient
|
|
except AttributeError:
|
|
if utils.settings('sslverify') == "true":
|
|
verifyssl = True
|
|
else:
|
|
verifyssl = False
|
|
self.logMsg("Set SSL verification to: %s" % verifyssl, 2)
|
|
|
|
# Prepare request
|
|
if type == "GET":
|
|
r = requests.get(url,
|
|
json=postBody,
|
|
params=parameters,
|
|
headers=header,
|
|
timeout=timeout,
|
|
verify=verifyssl)
|
|
|
|
elif type == "POST":
|
|
r = requests.post(url,
|
|
json=postBody,
|
|
headers=header,
|
|
timeout=timeout,
|
|
verify=verifyssl)
|
|
|
|
elif type == "PUT":
|
|
r = requests.put(url,
|
|
json=postBody,
|
|
headers=header,
|
|
timeout=timeout,
|
|
verify=verifyssl)
|
|
##### THE RESPONSE #####
|
|
# self.logMsg(r.url, 2)
|
|
if r.status_code == 204:
|
|
# No body in the response
|
|
# self.logMsg("====== 204 Success ======", 2)
|
|
pass
|
|
|
|
elif r.status_code == requests.codes.ok:
|
|
|
|
try:
|
|
# Allow for xml responses
|
|
r = etree.fromstring(r.content)
|
|
# self.logMsg("====== 200 Success ======", 2)
|
|
# self.logMsg("Received an XML response for: %s" % url, 2)
|
|
|
|
return r
|
|
|
|
except:
|
|
try:
|
|
# UNICODE - JSON object
|
|
r = r.json()
|
|
# self.logMsg("====== 200 Success ======", 2)
|
|
# self.logMsg("Response: %s" % r, 2)
|
|
return r
|
|
except:
|
|
try:
|
|
if r.text == '' and r.status_code == 200:
|
|
# self.logMsg("====== 200 Success ======", 2)
|
|
# self.logMsg("Answer from PMS does not contain a body", 2)
|
|
pass
|
|
# self.logMsg("Unable to convert the response for: %s" % url, 2)
|
|
# self.logMsg("Content-type was: %s" % r.headers['content-type'], 2)
|
|
except:
|
|
self.logMsg("Unable to convert the response for: %s" % url, 2)
|
|
self.logMsg("Content-type was: %s" % r.headers['content-type'], 2)
|
|
else:
|
|
r.raise_for_status()
|
|
|
|
##### EXCEPTIONS #####
|
|
|
|
except requests.exceptions.ConnectionError as e:
|
|
# Make the addon aware of status
|
|
if utils.window('emby_online') != "false":
|
|
self.logMsg("Server unreachable at: %s" % url, -1)
|
|
self.logMsg(e, 2)
|
|
utils.window('emby_online', value="false")
|
|
|
|
except requests.exceptions.ConnectTimeout as e:
|
|
self.logMsg("Server timeout at: %s" % url, 0)
|
|
self.logMsg(e, 1)
|
|
|
|
except requests.exceptions.HTTPError as e:
|
|
|
|
if r.status_code == 401:
|
|
# Unauthorized
|
|
status = utils.window('emby_serverStatus')
|
|
|
|
if 'X-Application-Error-Code' in r.headers:
|
|
# Emby server errors
|
|
if r.headers['X-Application-Error-Code'] == "ParentalControl":
|
|
# Parental control - access restricted
|
|
self.logMsg('Setting emby_serverStatus to restricted')
|
|
utils.window('emby_serverStatus', value="restricted")
|
|
xbmcgui.Dialog().notification(
|
|
heading=self.addonName,
|
|
message="Access restricted.",
|
|
icon=xbmcgui.NOTIFICATION_ERROR,
|
|
time=5000)
|
|
return False
|
|
|
|
elif r.headers['X-Application-Error-Code'] == "UnauthorizedAccessException":
|
|
# User tried to do something his emby account doesn't allow
|
|
pass
|
|
|
|
elif status not in ("401", "Auth"):
|
|
# Tell userclient token has been revoked.
|
|
self.logMsg('Setting emby_serverStatus to 401')
|
|
utils.window('emby_serverStatus', value="401")
|
|
self.logMsg("HTTP Error: %s" % e, 0)
|
|
xbmcgui.Dialog().notification(
|
|
heading=self.addonName,
|
|
message="Error connecting: Unauthorized.",
|
|
icon=xbmcgui.NOTIFICATION_ERROR)
|
|
return 401
|
|
|
|
elif r.status_code in (301, 302):
|
|
# Redirects
|
|
pass
|
|
elif r.status_code == 400:
|
|
# Bad requests
|
|
pass
|
|
|
|
except requests.exceptions.SSLError as e:
|
|
self.logMsg("Invalid SSL certificate for: %s" % url, 0)
|
|
self.logMsg(e, 1)
|
|
|
|
except requests.exceptions.RequestException as e:
|
|
self.logMsg("Unknown error connecting to: %s" % url, 0)
|
|
self.logMsg(e, 1)
|
|
|
|
return default_link |