def _checkIdle(self):
if self.doidle is False:
return
XBMCit = xbmc.getGlobalIdleTime()
if self.player.isPlaying():
self._playeridle = False
self._startidle = XBMCit
else: # player is not playing
if self._playeridle is False: # if the first pass with player idle, start timing here
self._playeridle = True
self._startidle = XBMCit
myit = XBMCit - self._startidle # amount of time idle and not playing
for it in self.idleTs:
if myit > it[0]: # if time exceeded idle timer
if it[2] is False: # idle task has NOT been executed
msg = Message(Topic('onIdle', it[1]))
self.publish(msg)
it[2] = True
else: # if time has not exceeded timer
it[2] = False # reset task executed flag
for it in self.afterIdles:
if myit > it[0]: # time has exceeded timer
it[2] = True # set flag that task needs to be executed when exiting idle
else: # time has not exceeded idle timer
if it[2] is True: # if flag to execute has been set
msg = Message(Topic('afterIdle', it[1]))
self.publish(msg)
it[2] = False # reset flag to execute
def start(self):
oldsnapshots = WatchdogStartup.getPickle()
newsnapshots = {}
for setting in self.settings:
folder = translatepath(setting['ws_folder'])
if os.path.exists(folder):
newsnapshot = DirectorySnapshot(
folder, recursive=setting['ws_recursive'])
newsnapshots[folder] = newsnapshot
if oldsnapshots is not None:
if folder in oldsnapshots.keys():
oldsnapshot = oldsnapshots[folder]
diff = DirectorySnapshotDiff(oldsnapshot, newsnapshot)
changes = self.getChangesFromDiff(diff)
if len(changes) > 0:
eh = EventHandler(
patterns=setting['ws_patterns'].split(','),
ignore_patterns=setting['ws_ignore_patterns'].
split(','),
ignore_directories=setting[
'ws_ignore_directories'])
observer = Observer()
try:
observer.schedule(
eh,
folder,
recursive=setting['ws_recursive'])
time.sleep(0.5)
for change in changes:
eh.dispatch(change)
time.sleep(0.25)
try:
observer.unschedule_all()
except Exception:
pass
except Exception:
raise
if len(eh.data) > 0:
message = Message(Topic(
'onStartupFileChanges', setting['key']),
listOfChanges=eh.data)
self.publish(message)
else:
message = Message(Topic('onStartupFileChanges',
setting['key']),
listOfChanges=[{
'DirsDeleted': folder
}])
log(msg=_('Watchdog Startup folder not found: %s') % folder)
self.publish(message)
def testBuiltin(self):
start_debug = is_xbmc_debug()
self.task = taskdict['builtin']['class']
taskKwargs = {
'builtin': 'ToggleDebug',
'type': 'builtin',
'notify': False
}
userargs = ''
tm = TaskManager(self.task,
1,
None,
-1,
taskid='T1',
userargs=userargs,
**taskKwargs)
topic = Topic('onPlayBackStarted')
runKwargs = events['onPlayBackStarted']['expArgs']
self.clear_q()
tm.start(topic, **runKwargs)
time.sleep(3)
debug = is_xbmc_debug()
tm.start(topic, **runKwargs)
if debug == start_debug:
raise AssertionError(_('Builtin test failed'))
def testDailyAlarm(self):
from time import strftime
self.topics = [Topic('onDailyAlarm', 'E1')]
hour, minute = strftime('%H:%M').split(':')
xsettings = [{
'hour': int(hour),
'minute': int(minute) + 1,
'key': 'E1'
}]
settings = Settings()
flexmock(settings, getEventsByType=xsettings)
self.publisher = SchedulePublisher(self.dispatcher, settings)
self.publisher.intervalAlarms = []
self.publisher.sleep = time.sleep
self.publisher.sleepinterval = 1
self.subscriber.addTopic(self.topics[0])
self.dispatcher.addSubscriber(self.subscriber)
self.dispatcher.start()
self.publisher.start()
self.subscriber.waitForMessage(count=1, timeout=65)
self.publisher.abort()
self.dispatcher.abort()
messages = self.subscriber.retrieveMessages()
msgtopics = [msg.topic for msg in messages]
time.sleep(1)
for topic in self.topics:
assert topic in msgtopics
def testScriptShell(self):
self.task = taskdict['script']['class']
if sys.platform.startswith('win'):
testfile = 'tstScript.bat'
else:
testfile = 'tstScript.sh'
taskKwargs = {'scriptfile':'"%s"' % os.path.join(testdir, testfile),
'use_shell':True, 'type':'script', 'waitForCompletion': True, 'notify':False}
userargs = 'abc def:ghi'
self.task.validate(taskKwargs)
tm = TaskManager(self.task, 1, None, -1, taskid='T1', userargs=userargs, **taskKwargs)
tm.returnHandler = self.returnHandler
topic = Topic('onPlaybackStarted')
runKwargs = events['onPlayBackStarted']['expArgs']
self.clear_q()
tm.start(topic, **runKwargs)
try:
tr = self.q.get(timeout=2)
except Queue.Empty:
raise AssertionError(_('Timed out waiting for return'))
else:
if tr.iserror is True:
log(loglevel=xbmc.LOGERROR, msg=_('testScriptShell returned with an error: %s') % tr.msg)
raise AssertionError(_('Script with shell test failed'))
else:
retArgs = re.findall(r'Process returned data: \[(.+)\]', tr.msg)[0]
if retArgs != userargs:
raise AssertionError(_('Script with shell test failed'))
def testPythonExternal(self):
self.task = taskdict['python']['class']
taskKwargs = {'pythonfile':os.path.join(testdir, 'tstPythonGlobal.py'),
'import':True, 'type':'python', 'notify':False}
userargs = 'jkl mno:pqr'
tm = TaskManager(self.task, 1, None, -1, taskid='T1', userargs=userargs, **taskKwargs)
tm.returnHandler = self.returnHandler
topic = Topic('onPlaybackStarted')
runKwargs = events['onPlayBackStarted']['expArgs']
self.clear_q()
tm.start(topic, **runKwargs)
try:
tr = self.q.get(timeout=1)
except Queue.Empty:
raise AssertionError(_('Timed out waiting for return'))
if tr.iserror is True:
log(loglevel=xbmc.LOGERROR, msg=_('testPythonExternal returned with an error: %s') % tr.msg)
if isAndroid:
raise AssertionError(_('Cannot fully test pythonExternal on Android'))
try:
retArgs = sys.modules['__builtin__'].__dict__['testReturn']
except KeyError:
retArgs = sys.modules['builtins'].__dict__['testReturn']
finally:
try:
sys.modules['__builtin__'].__dict__.pop('testReturn', None)
except KeyError:
sys.modules['builtins'].__dict__.pop('testReturn', None)
if ' '.join(retArgs[0]) != userargs:
raise AssertionError(_('Python external test failed'))
def onNotification(self, sender, method, data):
for criterion in self.jsoncriteria:
if criterion['sender'] == sender and criterion[
'method'] == method and criterion['data'] == data:
topic = Topic('onNotification', criterion['eventId'])
kwargs = {'sender': sender, 'method': method, 'data': data}
self.publish(Message(topic, **kwargs))
def onPlayBackStarted(self):
self.getInfo()
try:
self.totalTime = self.getTotalTime()
except RuntimeError:
self.totalTime = -1
topic = Topic('onPlayBackStarted')
self.publish(Message(topic, **self.info))
def run(self):
lastwindowid = xbmcgui.getCurrentWindowId()
lastprofile = getProfileString()
laststereomode = getStereoscopicMode()
interval = self.interval
firstloop = True
starttime = time.time()
while not self.abort_evt.is_set():
self._checkIdle()
newprofile = getProfileString()
if newprofile != lastprofile:
self.publish(
Message(Topic('onProfileChange'), profilePath=newprofile))
lastprofile = newprofile
newstereomode = getStereoscopicMode()
if newstereomode != laststereomode:
self.publish(
Message(Topic('onStereoModeChange'),
stereoMode=newstereomode))
laststereomode = newstereomode
newwindowid = xbmcgui.getCurrentWindowId()
if newwindowid != lastwindowid:
if lastwindowid in self.closewindowsids.keys():
self.publish(
Message(
Topic('onWindowClose',
self.closewindowsids[lastwindowid])))
if newwindowid in self.openwindowids:
self.publish(
Message(
Topic('onWindowOpen',
self.openwindowids[newwindowid])))
lastwindowid = newwindowid
if firstloop:
endtime = time.time()
interval = int(interval - (endtime - starttime) * 1000)
interval = max(5, interval)
firstloop = False
xbmc.sleep(interval)
del self.player
def __init__(self, match, nomatch, subtopic, publish):
super(LogCheckSimple, self).__init__(name='LogCheckSimple')
self.match = match
self.nomatch = nomatch
self.publish = publish
self.queue = Queue()
self._abort_evt = threading.Event()
self._abort_evt.clear()
self.topic = Topic('onLogSimple', subtopic)
def testLoopIdle(self):
self.topics = [Topic('onIdle', 'E1'), Topic('onIdle', 'E2')]
for topic in self.topics:
self.subscriber.addTopic(topic)
self.dispatcher.addSubscriber(self.subscriber)
idleSettings = {'E1': 3, 'E2': 5}
settings = Settings()
flexmock(settings, getIdleTimes=idleSettings)
flexmock(settings, general={'LoopFreq': 100})
self.publisher = LoopPublisher(self.dispatcher, settings)
self.dispatcher.start()
self.publisher.start()
time.sleep(7)
self.publisher.abort()
self.dispatcher.abort()
messages = self.subscriber.retrieveMessages()
msgtopics = [msg.topic for msg in messages]
for topic in self.topics:
assert topic in msgtopics
def onAVStarted(self):
self.getInfo()
try:
self.totalTime = self.getTotalTime()
except RuntimeError:
self.totalTime = -1
finally:
if self.totalTime == 0:
self.totalTime = -1
topic = Topic('onAVStarted')
self.publish(Message(topic, **self.info))
def onPlayBackEnded(self):
topic = Topic('onPlayBackEnded')
try:
tt = self.totalTime
tp = self.playingTime
pp = int(100 * tp / tt)
except RuntimeError:
pp = -1
self.publish(Message(topic, percentPlayed=str(pp), **self.info))
self.totalTime = -1.0
self.playingTime = 0.0
self.info = {}
def testScriptNoShell(self):
self.task = taskdict['script']['class']
outfile = os.path.join(testdir, 'scriptoutput.txt')
try:
os.remove(outfile)
except OSError:
pass
if sys.platform.startswith('win'):
testfile = 'tstScript.bat'
else:
testfile = 'tstScript.sh'
taskKwargs = {
'scriptfile': '"%s"' % os.path.join(testdir, testfile),
'use_shell': False,
'type': 'script',
'waitForCompletion': True,
'notify': False
}
self.task.validate(taskKwargs)
userargs = 'abc def:ghi'
tm = TaskManager(self.task,
1,
None,
-1,
taskid='T1',
userargs=userargs,
**taskKwargs)
tm.returnHandler = self.returnHandler
topic = Topic('onPlaybackStarted')
runKwargs = events['onPlayBackStarted']['expArgs']
tm.start(topic, **runKwargs)
try:
tr = self.q.get(timeout=2)
except Queue.Empty:
raise AssertionError(_('Timed out waiting for return'))
else:
if tr.iserror is True:
log(loglevel=xbmc.LOGERROR,
msg=_('testScriptNoShell returned with an error: %s') %
tr.msg)
try:
with open(outfile, 'r') as f:
retArgs = f.readline()
except OSError:
retArgs = ''
try:
os.remove(outfile)
except OSError:
pass
if retArgs.strip('\n') != userargs:
raise AssertionError(_('Script without shell test failed'))
def initialize(self):
for setting in self.watchdogSettings:
patterns = setting['patterns'].split(',')
ignore_patterns = setting['ignore_patterns'].split(',')
eh = EventHandler(patterns=patterns,
ignore_patterns=ignore_patterns,
ignore_directories=setting['ignore_directories'],
topic=Topic('onFileSystemChange',
setting['key']),
publish=self.publish)
self.event_handlers.append(eh)
folder = translatepath(setting['folder'])
mysetting = [eh, folder, setting['recursive']]
self.observersettings.append(mysetting)
def testStereoModeChange(self):
self.topics = [Topic('onStereoModeChange')]
self.subscriber.addTopic(self.topics[0])
self.dispatcher.addSubscriber(self.subscriber)
settings = Settings()
flexmock(settings, general={'LoopFreq': 100})
self.publisher = LoopPublisher(self.dispatcher, settings)
self.dispatcher.start()
self.publisher.start()
self.subscriber.waitForMessage(count=1, timeout=5)
self.publisher.abort()
self.dispatcher.abort()
messages = self.subscriber.retrieveMessages()
msgtopics = [msg.topic for msg in messages]
for topic in self.topics:
assert topic in msgtopics
def testProfileChange(self):
self.topics = [Topic('onProfileChange')]
self.subscriber.addTopic(self.topics[0])
self.dispatcher.addSubscriber(self.subscriber)
settings = Settings()
flexmock(settings, general={'LoopFreq': 100})
self.publisher = LoopPublisher(self.dispatcher, settings)
self.dispatcher.start()
self.publisher.start()
time.sleep(5)
self.publisher.abort()
self.dispatcher.abort()
messages = self.subscriber.retrieveMessages()
msgtopics = [msg.topic for msg in messages]
for topic in self.topics:
assert topic in msgtopics
def onPlayBackStarted(self):
self.playingFile = self.getPlayingFileX()
try:
self.totalTime = self.getTotalTime()
except Exception:
self.totalTime = -1
self.playingType = self.playing_type()
self.playingTitle = self.getTitle()
topic = Topic('onPlayBackStarted')
kwargs = {
'mediaType': self.playingType,
'fileName': self.playingFile,
'title': self.playingTitle,
'aspectRatio': self.getAspectRatio(),
'resolution': self.getResoluion()
}
self.publish(Message(topic, **kwargs))
def testOnWindowOpen(self):
self.topics = [Topic('onWindowOpen', 'E1')]
self.subscriber.addTopic(self.topics[0])
self.dispatcher.addSubscriber(self.subscriber)
settings = Settings()
flexmock(settings, general={'LoopFreq': 100})
flexmock(settings, getOpenwindowids={10001: 'E1'})
self.publisher = LoopPublisher(self.dispatcher, settings)
self.dispatcher.start()
self.publisher.start()
self.subscriber.waitForMessage(count=1, timeout=5)
self.publisher.abort()
self.dispatcher.abort()
messages = self.subscriber.retrieveMessages()
msgtopics = [msg.topic for msg in messages]
for topic in self.topics:
assert topic in msgtopics
def testOnWindowClose(self):
self.topics = [Topic('onWindowClose', 'E1')]
self.subscriber.addTopic(self.topics[0])
self.dispatcher.addSubscriber(self.subscriber)
settings = Settings()
flexmock(settings, general={'LoopFreq': 100})
flexmock(settings, getClosewindowids={10001: 'E1'})
self.publisher = LoopPublisher(self.dispatcher, settings)
self.dispatcher.start()
self.publisher.start()
time.sleep(5)
self.publisher.abort()
self.dispatcher.abort()
messages = self.subscriber.retrieveMessages()
msgtopics = [msg.topic for msg in messages]
for topic in self.topics:
assert topic in msgtopics
def __init__(self, match, nomatch, subtopic, publish):
super(LogCheckRegex, self).__init__(name='LogCheckRegex')
try:
re_match = re.compile(match, flags=re.IGNORECASE)
except re.error:
raise
if nomatch != '':
try:
re_nomatch = re.compile(nomatch, flags=re.IGNORECASE)
except re.error:
raise
else:
re_nomatch = None
self.match = re_match
self.nomatch = re_nomatch
self.publish = publish
self.queue = Queue()
self._abort_evt = threading.Event()
self._abort_evt.clear()
self.topic = Topic('onLogRegex', subtopic)
def setup(self):
self.folder = translatepath('special://addon/resources/lib/tests')
watchdogStartupSettings = [{
'ws_folder': self.folder,
'ws_patterns': '*',
'ws_ignore_patterns': '',
'ws_ignore_directories': True,
'ws_recursive': False,
'key': 'E1'
}]
self.saveduserpickle = WatchdogStartup.getPickle()
self.dispatcher = Dispatcher()
self.subscriber = testSubscriber()
self.topic = Topic('onStartupFileChanges', 'E1')
self.subscriber.addTopic(self.topic)
self.dispatcher.addSubscriber(self.subscriber)
settings = Settings()
flexmock(settings, getWatchdogStartupSettings=watchdogStartupSettings)
self.publisher = WatchdogStartup(self.dispatcher, settings)
self.dispatcher.start()
def setup(self):
self.folder = translatepath('special://addon/resources/lib/tests')
setPathRW(self.folder)
watchdogSettings = [{
'folder': self.folder,
'patterns': '*',
'ignore_patterns': '',
'ignore_directories': True,
'recursive': False,
'key': 'E1'
}]
self.dispatcher = Dispatcher()
self.subscriber = testSubscriber()
self.topic = Topic('onFileSystemChange', 'E1')
self.subscriber.addTopic(self.topic)
self.dispatcher.addSubscriber(self.subscriber)
settings = Settings()
flexmock(settings, getWatchdogSettings=watchdogSettings)
self.publisher = WatchdogPublisher(self.dispatcher, settings)
self.dispatcher.start()
def onPlayBackEnded(self):
topic = Topic('onPlayBackEnded')
try:
tt = self.totalTime
tp = self.playingTime
pp = int(100 * tp / tt)
except Exception:
pp = -1
kwargs = {
'mediaType': self.playingType,
'fileName': self.playingFile,
'title': self.playingTitle,
'percentPlayed': str(pp)
}
self.publish(Message(topic, **kwargs))
self.playingTitle = ''
self.playingFile = ''
self.playingType = ''
self.totalTime = -1.0
self.playingTime = 0.0
def testHttp(self):
serverEnabled, serverPort, serverUser, serverPassword = getWebserverInfo(
)
if serverEnabled:
self.task = taskdict['http']['class']
taskKwargs = {
'http': 'http://localhost:%s/jsonrpc' % str(serverPort),
'user': serverUser,
'pass': serverPassword,
'type': 'http',
'request-type': 'GET',
'notify': False
}
userargs = '?request={"jsonrpc":%__"2.0"%_%__"id": 1%_%__"method":"Application.Setmute"%_%__"params":{"mute":"toggle"}}'
tm = TaskManager(self.task,
1,
None,
-1,
taskid='T1',
userargs=userargs,
**taskKwargs)
tm.returnHandler = self.returnHandler
topic = Topic('onPlaybackStarted')
runKwargs = events['onPlayBackStarted']['expArgs']
self.clear_q()
tm.start(topic, **runKwargs)
try:
tr = self.q.get(timeout=1)
except Queue.Empty:
raise Queue.Empty(_('testHttp never returned'))
else:
tm.start(topic, **runKwargs) # Toggle Mute again
if tr.iserror is True:
log(loglevel=xbmc.LOGERROR,
msg=_('testHttp returned with an error: %s') % tr.msg)
if '{"id":1,"jsonrpc":"2.0","result":' not in tr.msg:
raise AssertionError(_('Http test failed'))
else:
raise AssertionError(
'Http test cannot be run because webserver not enabled')
def testIntervalAlarm(self):
self.topics = [Topic('onIntervalAlarm', 'E1')]
xsettings = [{'hours': 0, 'minutes': 0, 'seconds': 10, 'key': 'E1'}]
settings = Settings()
self.dispatcher = Dispatcher()
self.subscriber = MockSubscriber()
flexmock(settings, getEventsByType=xsettings)
self.publisher = SchedulePublisher(self.dispatcher, settings)
self.publisher.dailyAlarms = []
self.publisher.sleep = time.sleep
self.publisher.sleepinterval = 1
self.subscriber.testq = Queue.Queue()
self.subscriber.addTopic(self.topics[0])
self.dispatcher.addSubscriber(self.subscriber)
self.dispatcher.start()
self.publisher.start()
self.subscriber.waitForMessage(count=1, timeout=20)
self.publisher.abort()
self.dispatcher.abort()
messages = self.subscriber.retrieveMessages()
msgtopics = [msg.topic for msg in messages]
for topic in self.topics:
assert topic in msgtopics
def testLogRegex(self):
self.topics = [Topic('onLogRegex', 'E1')]
xsettings = [{
'matchIf': 'kodi_callbacks',
'rejectIf': '',
'eventId': 'E1'
}]
settings = Settings()
flexmock(settings, getLogRegexes=xsettings)
flexmock(settings, general={'LogFreq': 100})
self.publisher = LogPublisher(self.dispatcher, settings)
try:
os.remove(testLog.fn)
except OSError:
pass
finally:
with open(testLog.fn, 'w') as f:
f.writelines('')
self.subscriber.addTopic(self.topics[0])
self.dispatcher.addSubscriber(self.subscriber)
self.dispatcher.start()
self.publisher.start()
t = threading.Thread(target=testLog.logSimulate)
t.start()
t.join()
self.publisher.abort()
self.dispatcher.abort()
time.sleep(2)
try:
os.remove(testLog.fn)
except OSError:
pass
messages = self.subscriber.retrieveMessages()
msgtopics = [msg.topic for msg in messages]
for topic in self.topics:
assert topic in msgtopics
def prePublishDailyAlarm(self, key):
meseage = Message(Topic('onDailyAlarm', key))
self.publish(meseage)
def prePublishIntervalAlarm(self, key):
meseage = Message(Topic('onIntervalAlarm', key))
self.publish(meseage)
def onScanFinished(self, library):
topic = Topic('onScanFinished')
kwargs = {'library': library}
self.publish(Message(topic, **kwargs))
