1
0
mirror of https://github.com/moparisthebest/SickRage synced 2024-12-12 11:02:21 -05:00
SickRage/sickbeard/notifiers/kodi.py
2015-02-20 15:59:17 -02:00

571 lines
24 KiB
Python

# Author: Nic Wolfe <nic@wolfeden.ca>
# URL: http://code.google.com/p/sickbeard/
#
# This file is part of SickRage.
#
# SickRage is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# SickRage is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with SickRage. If not, see <http://www.gnu.org/licenses/>.
import urllib
import urllib2
import socket
import base64
import time
import sickbeard
from sickbeard import logger
from sickbeard import common
from sickbeard.exceptions import ex
from sickbeard import encodingKludge as ek
try:
import xml.etree.cElementTree as etree
except ImportError:
import xml.etree.ElementTree as etree
try:
import json
except ImportError:
from lib import simplejson as json
class KODINotifier:
sb_logo_url = 'https://raw.githubusercontent.com/SiCKRAGETV/SickRage/master/gui/slick/images/sickrage-shark-mascot.png'
def _get_kodi_version(self, host, username, password):
"""Returns KODI JSON-RPC API version (odd # = dev, even # = stable)
Sends a request to the KODI host using the JSON-RPC to determine if
the legacy API or if the JSON-RPC API functions should be used.
Fallback to testing legacy HTTPAPI before assuming it is just a badly configured host.
Args:
host: KODI webserver host:port
username: KODI webserver username
password: KODI webserver password
Returns:
Returns API number or False
List of possible known values:
API | KODI Version
-----+---------------
2 | v10 (Dharma)
3 | (pre Eden)
4 | v11 (Eden)
5 | (pre Frodo)
6 | v12 (Frodo) / v13 (Gotham)
"""
# since we need to maintain python 2.5 compatability we can not pass a timeout delay to urllib2 directly (python 2.6+)
# override socket timeout to reduce delay for this call alone
socket.setdefaulttimeout(10)
checkCommand = '{"jsonrpc":"2.0","method":"JSONRPC.Version","id":1}'
result = self._send_to_kodi_json(checkCommand, host, username, password)
# revert back to default socket timeout
socket.setdefaulttimeout(sickbeard.SOCKET_TIMEOUT)
if result:
return result["result"]["version"]
else:
# fallback to legacy HTTPAPI method
testCommand = {'command': 'Help'}
request = self._send_to_kodi(testCommand, host, username, password)
if request:
# return a fake version number, so it uses the legacy method
return 1
else:
return False
def _notify_kodi(self, message, title="SickRage", host=None, username=None, password=None, force=False):
"""Internal wrapper for the notify_snatch and notify_download functions
Detects JSON-RPC version then branches the logic for either the JSON-RPC or legacy HTTP API methods.
Args:
message: Message body of the notice to send
title: Title of the notice to send
host: KODI webserver host:port
username: KODI webserver username
password: KODI webserver password
force: Used for the Test method to override config saftey checks
Returns:
Returns a list results in the format of host:ip:result
The result will either be 'OK' or False, this is used to be parsed by the calling function.
"""
# fill in omitted parameters
if not host:
host = sickbeard.KODI_HOST
if not username:
username = sickbeard.KODI_USERNAME
if not password:
password = sickbeard.KODI_PASSWORD
# suppress notifications if the notifier is disabled but the notify options are checked
if not sickbeard.USE_KODI and not force:
logger.log("Notification for KODI not enabled, skipping this notification", logger.DEBUG)
return False
result = ''
for curHost in [x.strip() for x in host.split(",")]:
logger.log(u"Sending KODI notification to '" + curHost + "' - " + message, logger.INFO)
kodiapi = self._get_kodi_version(curHost, username, password)
if kodiapi:
if (kodiapi <= 4):
logger.log(u"Detected KODI version <= 11, using KODI HTTP API", logger.DEBUG)
command = {'command': 'ExecBuiltIn',
'parameter': 'Notification(' + title.encode("utf-8") + ',' + message.encode(
"utf-8") + ')'}
notifyResult = self._send_to_kodi(command, curHost, username, password)
if notifyResult:
result += curHost + ':' + str(notifyResult)
else:
logger.log(u"Detected KODI version >= 12, using KODI JSON API", logger.DEBUG)
command = '{"jsonrpc":"2.0","method":"GUI.ShowNotification","params":{"title":"%s","message":"%s", "image": "%s"},"id":1}' % (
title.encode("utf-8"), message.encode("utf-8"), self.sb_logo_url)
notifyResult = self._send_to_kodi_json(command, curHost, username, password)
if notifyResult.get('result'):
result += curHost + ':' + notifyResult["result"].decode(sickbeard.SYS_ENCODING)
else:
if sickbeard.KODI_ALWAYS_ON or force:
logger.log(
u"Failed to detect KODI version for '" + curHost + "', check configuration and try again.",
logger.ERROR)
result += curHost + ':False'
return result
def _send_update_library(self, host, showName=None):
"""Internal wrapper for the update library function to branch the logic for JSON-RPC or legacy HTTP API
Checks the KODI API version to branch the logic to call either the legacy HTTP API or the newer JSON-RPC over HTTP methods.
Args:
host: KODI webserver host:port
showName: Name of a TV show to specifically target the library update for
Returns:
Returns True or False, if the update was successful
"""
logger.log(u"Sending request to update library for KODI host: '" + host + "'", logger.INFO)
kodiapi = self._get_kodi_version(host, sickbeard.KODI_USERNAME, sickbeard.KODI_PASSWORD)
if kodiapi:
if (kodiapi <= 4):
# try to update for just the show, if it fails, do full update if enabled
if not self._update_library(host, showName) and sickbeard.KODI_UPDATE_FULL:
logger.log(u"Single show update failed, falling back to full update", logger.WARNING)
return self._update_library(host)
else:
return True
else:
# try to update for just the show, if it fails, do full update if enabled
if not self._update_library_json(host, showName) and sickbeard.KODI_UPDATE_FULL:
logger.log(u"Single show update failed, falling back to full update", logger.WARNING)
return self._update_library_json(host)
else:
return True
else:
logger.log(u"Failed to detect KODI version for '" + host + "', check configuration and try again.",
logger.DEBUG)
return False
return False
# #############################################################################
# Legacy HTTP API (pre KODI 12) methods
##############################################################################
def _send_to_kodi(self, command, host=None, username=None, password=None):
"""Handles communication to KODI servers via HTTP API
Args:
command: Dictionary of field/data pairs, encoded via urllib and passed to the KODI API via HTTP
host: KODI webserver host:port
username: KODI webserver username
password: KODI webserver password
Returns:
Returns response.result for successful commands or False if there was an error
"""
# fill in omitted parameters
if not username:
username = sickbeard.KODI_USERNAME
if not password:
password = sickbeard.KODI_PASSWORD
if not host:
logger.log(u'No KODI host passed, aborting update', logger.DEBUG)
return False
for key in command:
if type(command[key]) == unicode:
command[key] = command[key].encode('utf-8')
enc_command = urllib.urlencode(command)
logger.log(u"KODI encoded API command: " + enc_command, logger.DEBUG)
url = 'http://%s/kodiCmds/kodiHttp/?%s' % (host, enc_command)
try:
req = urllib2.Request(url)
# if we have a password, use authentication
if password:
base64string = base64.encodestring('%s:%s' % (username, password))[:-1]
authheader = "Basic %s" % base64string
req.add_header("Authorization", authheader)
logger.log(u"Contacting KODI (with auth header) via url: " + ek.ss(url), logger.DEBUG)
else:
logger.log(u"Contacting KODI via url: " + ek.ss(url), logger.DEBUG)
response = urllib2.urlopen(req)
result = response.read().decode(sickbeard.SYS_ENCODING)
response.close()
logger.log(u"KODI HTTP response: " + result.replace('\n', ''), logger.DEBUG)
return result
except (urllib2.URLError, IOError), e:
logger.log(u"Warning: Couldn't contact KODI HTTP at " + ek.ss(url) + " " + ex(e),
logger.WARNING)
return False
def _update_library(self, host=None, showName=None):
"""Handles updating KODI host via HTTP API
Attempts to update the KODI video library for a specific tv show if passed,
otherwise update the whole library if enabled.
Args:
host: KODI webserver host:port
showName: Name of a TV show to specifically target the library update for
Returns:
Returns True or False
"""
if not host:
logger.log(u'No KODI host passed, aborting update', logger.DEBUG)
return False
logger.log(u"Updating KODI library via HTTP method for host: " + host, logger.DEBUG)
# if we're doing per-show
if showName:
logger.log(u"Updating library in KODI via HTTP method for show " + showName, logger.DEBUG)
pathSql = 'select path.strPath from path, tvshow, tvshowlinkpath where ' \
'tvshow.c00 = "%s" and tvshowlinkpath.idShow = tvshow.idShow ' \
'and tvshowlinkpath.idPath = path.idPath' % (showName)
# use this to get xml back for the path lookups
xmlCommand = {
'command': 'SetResponseFormat(webheader;false;webfooter;false;header;<xml>;footer;</xml>;opentag;<tag>;closetag;</tag>;closefinaltag;false)'}
# sql used to grab path(s)
sqlCommand = {'command': 'QueryVideoDatabase(%s)' % (pathSql)}
# set output back to default
resetCommand = {'command': 'SetResponseFormat()'}
# set xml response format, if this fails then don't bother with the rest
request = self._send_to_kodi(xmlCommand, host)
if not request:
return False
sqlXML = self._send_to_kodi(sqlCommand, host)
request = self._send_to_kodi(resetCommand, host)
if not sqlXML:
logger.log(u"Invalid response for " + showName + " on " + host, logger.DEBUG)
return False
encSqlXML = urllib.quote(sqlXML, ':\\/<>')
try:
et = etree.fromstring(encSqlXML)
except SyntaxError, e:
logger.log(u"Unable to parse XML returned from KODI: " + ex(e), logger.ERROR)
return False
paths = et.findall('.//field')
if not paths:
logger.log(u"No valid paths found for " + showName + " on " + host, logger.DEBUG)
return False
for path in paths:
# we do not need it double-encoded, gawd this is dumb
unEncPath = urllib.unquote(path.text).decode(sickbeard.SYS_ENCODING)
logger.log(u"KODI Updating " + showName + " on " + host + " at " + unEncPath, logger.DEBUG)
updateCommand = {'command': 'ExecBuiltIn', 'parameter': 'KODI.updatelibrary(video, %s)' % (unEncPath)}
request = self._send_to_kodi(updateCommand, host)
if not request:
logger.log(u"Update of show directory failed on " + showName + " on " + host + " at " + unEncPath,
logger.ERROR)
return False
# sleep for a few seconds just to be sure kodi has a chance to finish each directory
if len(paths) > 1:
time.sleep(5)
# do a full update if requested
else:
logger.log(u"Doing Full Library KODI update on host: " + host, logger.INFO)
updateCommand = {'command': 'ExecBuiltIn', 'parameter': 'KODI.updatelibrary(video)'}
request = self._send_to_kodi(updateCommand, host)
if not request:
logger.log(u"KODI Full Library update failed on: " + host, logger.ERROR)
return False
return True
##############################################################################
# JSON-RPC API (KODI 12+) methods
##############################################################################
def _send_to_kodi_json(self, command, host=None, username=None, password=None):
"""Handles communication to KODI servers via JSONRPC
Args:
command: Dictionary of field/data pairs, encoded via urllib and passed to the KODI JSON-RPC via HTTP
host: KODI webserver host:port
username: KODI webserver username
password: KODI webserver password
Returns:
Returns response.result for successful commands or False if there was an error
"""
# fill in omitted parameters
if not username:
username = sickbeard.KODI_USERNAME
if not password:
password = sickbeard.KODI_PASSWORD
if not host:
logger.log(u'No KODI host passed, aborting update', logger.DEBUG)
return False
command = command.encode('utf-8')
logger.log(u"KODI JSON command: " + command, logger.DEBUG)
url = 'http://%s/jsonrpc' % (host)
try:
req = urllib2.Request(url, command)
req.add_header("Content-type", "application/json")
# if we have a password, use authentication
if password:
base64string = base64.encodestring('%s:%s' % (username, password))[:-1]
authheader = "Basic %s" % base64string
req.add_header("Authorization", authheader)
logger.log(u"Contacting KODI (with auth header) via url: " + ek.ss(url), logger.DEBUG)
else:
logger.log(u"Contacting KODI via url: " + ek.ss(url), logger.DEBUG)
try:
response = urllib2.urlopen(req)
except urllib2.URLError, e:
logger.log(u"Error while trying to retrieve KODI API version for " + host + ": " + ex(e),
logger.WARNING)
return False
# parse the json result
try:
result = json.load(response)
response.close()
logger.log(u"KODI JSON response: " + str(result), logger.DEBUG)
return result # need to return response for parsing
except ValueError, e:
logger.log(u"Unable to decode JSON: " + str(response.read()), logger.WARNING)
return False
except IOError, e:
logger.log(u"Warning: Couldn't contact KODI JSON API at " + ek.ss(url) + " " + ex(e),
logger.WARNING)
return False
def _update_library_json(self, host=None, showName=None):
"""Handles updating KODI host via HTTP JSON-RPC
Attempts to update the KODI video library for a specific tv show if passed,
otherwise update the whole library if enabled.
Args:
host: KODI webserver host:port
showName: Name of a TV show to specifically target the library update for
Returns:
Returns True or False
"""
if not host:
logger.log(u'No KODI host passed, aborting update', logger.DEBUG)
return False
logger.log(u"Updating KODI library via JSON method for host: " + host, logger.INFO)
# if we're doing per-show
if showName:
tvshowid = -1
logger.log(u"Updating library in KODI via JSON method for show " + showName, logger.DEBUG)
# get tvshowid by showName
showsCommand = '{"jsonrpc":"2.0","method":"VideoLibrary.GetTVShows","id":1}'
showsResponse = self._send_to_kodi_json(showsCommand, host)
if showsResponse and "result" in showsResponse and "tvshows" in showsResponse["result"]:
shows = showsResponse["result"]["tvshows"]
else:
logger.log(u"KODI: No tvshows in KODI TV show list", logger.DEBUG)
return False
for show in shows:
if (show["label"] == showName):
tvshowid = show["tvshowid"]
break # exit out of loop otherwise the label and showname will not match up
# this can be big, so free some memory
del shows
# we didn't find the show (exact match), thus revert to just doing a full update if enabled
if (tvshowid == -1):
logger.log(u'Exact show name not matched in KODI TV show list', logger.DEBUG)
return False
# lookup tv-show path
pathCommand = '{"jsonrpc":"2.0","method":"VideoLibrary.GetTVShowDetails","params":{"tvshowid":%d, "properties": ["file"]},"id":1}' % (
tvshowid)
pathResponse = self._send_to_kodi_json(pathCommand, host)
path = pathResponse["result"]["tvshowdetails"]["file"]
logger.log(u"Received Show: " + showName + " with ID: " + str(tvshowid) + " Path: " + path,
logger.DEBUG)
if (len(path) < 1):
logger.log(u"No valid path found for " + showName + " with ID: " + str(tvshowid) + " on " + host,
logger.WARNING)
return False
logger.log(u"KODI Updating " + showName + " on " + host + " at " + path, logger.DEBUG)
updateCommand = '{"jsonrpc":"2.0","method":"VideoLibrary.Scan","params":{"directory":%s},"id":1}' % (
json.dumps(path))
request = self._send_to_kodi_json(updateCommand, host)
if not request:
logger.log(u"Update of show directory failed on " + showName + " on " + host + " at " + path,
logger.ERROR)
return False
# catch if there was an error in the returned request
for r in request:
if 'error' in r:
logger.log(
u"Error while attempting to update show directory for " + showName + " on " + host + " at " + path,
logger.ERROR)
return False
# do a full update if requested
else:
logger.log(u"Doing Full Library KODI update on host: " + host, logger.INFO)
updateCommand = '{"jsonrpc":"2.0","method":"VideoLibrary.Scan","id":1}'
request = self._send_to_kodi_json(updateCommand, host, sickbeard.KODI_USERNAME, sickbeard.KODI_PASSWORD)
if not request:
logger.log(u"KODI Full Library update failed on: " + host, logger.ERROR)
return False
return True
##############################################################################
# Public functions which will call the JSON or Legacy HTTP API methods
##############################################################################
def notify_snatch(self, ep_name):
if sickbeard.KODI_NOTIFY_ONSNATCH:
self._notify_kodi(ep_name, common.notifyStrings[common.NOTIFY_SNATCH])
def notify_download(self, ep_name):
if sickbeard.KODI_NOTIFY_ONDOWNLOAD:
self._notify_kodi(ep_name, common.notifyStrings[common.NOTIFY_DOWNLOAD])
def notify_subtitle_download(self, ep_name, lang):
if sickbeard.KODI_NOTIFY_ONSUBTITLEDOWNLOAD:
self._notify_kodi(ep_name + ": " + lang, common.notifyStrings[common.NOTIFY_SUBTITLE_DOWNLOAD])
def notify_git_update(self, new_version = "??"):
if sickbeard.USE_KODI:
update_text=common.notifyStrings[common.NOTIFY_GIT_UPDATE_TEXT]
title=common.notifyStrings[common.NOTIFY_GIT_UPDATE]
self._notify_kodi(update_text + new_version, title)
def test_notify(self, host, username, password):
return self._notify_kodi("Testing KODI notifications from SickRage", "Test Notification", host, username,
password, force=True)
def update_library(self, showName=None):
"""Public wrapper for the update library functions to branch the logic for JSON-RPC or legacy HTTP API
Checks the KODI API version to branch the logic to call either the legacy HTTP API or the newer JSON-RPC over HTTP methods.
Do the ability of accepting a list of hosts deliminated by comma, only one host is updated, the first to respond with success.
This is a workaround for SQL backend users as updating multiple clients causes duplicate entries.
Future plan is to revist how we store the host/ip/username/pw/options so that it may be more flexible.
Args:
showName: Name of a TV show to specifically target the library update for
Returns:
Returns True or False
"""
if sickbeard.USE_KODI and sickbeard.KODI_UPDATE_LIBRARY:
if not sickbeard.KODI_HOST:
logger.log(u"No KODI hosts specified, check your settings", logger.DEBUG)
return False
# either update each host, or only attempt to update until one successful result
result = 0
for host in [x.strip() for x in sickbeard.KODI_HOST.split(",")]:
if self._send_update_library(host, showName):
if sickbeard.KODI_UPDATE_ONLYFIRST:
logger.log(u"Successfully updated '" + host + "', stopped sending update library commands.",
logger.DEBUG)
return True
else:
if sickbeard.KODI_ALWAYS_ON:
logger.log(
u"Failed to detect KODI version for '" + host + "', check configuration and try again.",
logger.ERROR)
result = result + 1
# needed for the 'update kodi' submenu command
# as it only cares of the final result vs the individual ones
if result == 0:
return True
else:
return False
notifier = KODINotifier