class DummyPlayer(providers.MediaPlayer):
'''
classdocs
'''
manifest = Manifest("Dummy Player", "CoCy Dummy Media Player")
def __init__(self):
super(DummyPlayer, self).__init__(self.manifest)
self._timer = None
@handler("provider_updated")
def _on_provider_updated_handler(self, provider, changed):
if "state" in changed:
state = changed["state"]
if state == "PLAYING":
self.current_track_duration = 60
if self._timer:
self._timer.unregister()
self._timer = Timer(self.current_track_duration,
MediaPlayer.EndOfMedia()).register(self)
elif state == "IDLE":
if self._timer:
self._timer.unregister()
def current_position(self):
if self._timer is None:
return None
return self._current_track_duration - (self._timer.expiry - time.time())
def test_persistent(self):
timer = Timer(0.1, test(), "timer", persist=True)
timer.register(self.app)
for _ in range(2):
wait_for(self.app, "flag")
self.app.reset()
timer.unregister()
def test_persistent(self):
timer = Timer(0.1, test(), "timer", persist=True)
timer.register(self.app)
for _ in range(2):
wait_for(self.app, "flag")
self.app.reset()
timer.unregister()
class ServerTimePortlet(TemplatePortlet):
def __init__(self, *args, **kwargs):
super(ServerTimePortlet, self) \
.__init__("templates", "servertime", *args, **kwargs)
self._portal_channel = None
self._time_channel = self.channel + "-time"
self._timer = None
def description(self, locales=[]):
return Portlet.Description\
(self._handle, self.translation(locales) \
.ugettext("Server Time Portlet"),
events=[(on_off_changed, self.channel)])
@handler("portlet_added")
def _on_portlet_added(self, portal, portlet):
self._portal_channel = portal.channel
@handler("portal_client_connect", channel=portal.channel)
def _on_ws_connect(self, session):
self._update_time(session)
self.addHandler(_on_ws_connect)
def _update_time(self, session):
td = datetime.datetime.utcnow() - datetime.datetime(1970, 1, 1)
td = td.microseconds / 1000 + (td.seconds + td.days * 86400) * 1000
td = int(td)
self.fire(portal_update(self, session, "new_time", str(td)), \
self._portal_channel)
@property
def updating(self):
return getattr(self, "_timer", None) is not None
@handler("on_off_changed")
def _on_off_changed(self, value, session=None, **kwargs):
if value and self._timer is None:
evt = Event.create("time_over", session)
evt.channels = (self.channel, )
self._timer = Timer(1, evt, persist=True).register(self)
locales = kwargs.get("locales", [])
self.fire(portal_message \
(session, self.translation(locales) \
.ugettext("TimeUpdateOn")), self._portal_channel)
if not value and self._timer is not None:
self._timer.unregister()
self._timer = None
@handler("time_over")
def _on_time_over(self, session):
self._update_time(session)
class ServerTimePortlet(TemplatePortlet):
def __init__(self, *args, **kwargs):
super(ServerTimePortlet, self) \
.__init__("templates", "servertime", *args, **kwargs)
self._portal_channel = None
self._time_channel = self.channel + "-time"
self._timer = None
def description(self, locales=[]):
return Portlet.Description\
(self._handle, self.translation(locales) \
.ugettext("Server Time Portlet"),
events=[(on_off_changed, self.channel)])
@handler("portlet_added")
def _on_portlet_added(self, portal, portlet):
self._portal_channel=portal.channel
@handler("portal_client_connect", channel=portal.channel)
def _on_ws_connect(self, session):
self._update_time(session)
self.addHandler(_on_ws_connect)
def _update_time(self, session):
td = datetime.datetime.utcnow() - datetime.datetime(1970, 1, 1)
td = td.microseconds / 1000 + (td.seconds + td.days * 86400) * 1000
td = int(td)
self.fire(portal_update(self, session, "new_time", str(td)), \
self._portal_channel)
@property
def updating(self):
return getattr(self, "_timer", None) is not None
@handler("on_off_changed")
def _on_off_changed(self, value, session=None, **kwargs):
if value and self._timer is None:
evt = Event.create("time_over", session)
evt.channels = (self.channel,)
self._timer = Timer(1, evt, persist=True).register(self)
locales = kwargs.get("locales", [])
self.fire(portal_message \
(session, self.translation(locales) \
.ugettext("TimeUpdateOn")), self._portal_channel)
if not value and self._timer is not None:
self._timer.unregister()
self._timer = None
@handler("time_over")
def _on_time_over(self, session):
self._update_time(session)
class DummyPlayer(providers.MediaPlayer):
'''
classdocs
'''
manifest = Manifest("Dummy Player", "CoCy Dummy Media Player")
def __init__(self):
super(DummyPlayer, self).__init__(self.manifest)
self._timer = None
def supportedMediaTypes(self):
return ["http-get:*:audio/mpeg:*", "http-get:*:audio/ogg:*",
"http-get:*:audio/3gpp:*", "http-get:*:video/3gpp:*",
"http-get:*:audio/3gpp2:*", "http-get:*:video/3gpp2:*"]
@handler("provider_updated")
def _on_provider_updated_handler(self, provider, changed):
if "source" in changed:
if self.state == "PLAYING":
if self._timer:
self._timer.unregister()
from cocy.upnp import DIDL_LITE_NS
duration = self.source_meta_dom.find(
str(QName(DIDL_LITE_NS, "item")) + "/" + str(QName(DIDL_LITE_NS, "res"))) \
.get("duration")
self.current_track_duration = duration_to_secs(duration)
self._timer = Timer(self.current_track_duration,
end_reached()).register(self)
if "state" in changed:
state = changed["state"]
if state == "IDLE":
if self._timer:
self._timer.unregister()
@handler("play", override=True)
@combine_events
def _on_play(self):
if self.source is None or self.state == "PLAYING":
return
if self._timer:
self._timer.unregister()
from cocy.upnp import DIDL_LITE_NS
duration = self.source_meta_dom.find(
str(QName(DIDL_LITE_NS, "item")) + "/" + str(QName(DIDL_LITE_NS, "res"))) \
.get("duration")
self.current_track_duration = duration_to_secs(duration)
self._timer = Timer(self.current_track_duration,
end_reached()).register(self)
self.state = "PLAYING"
@handler("end_reached")
def _on_end_reached(self, event):
if self._timer:
self._timer.unregister()
self._timer = None
self.fire(MediaPlayer.end_of_media())
@handler("seek", override=True)
def _on_seek(self, position):
if self.state != "PLAYING":
return
self._timer.unregister()
self._timer = Timer(self.current_track_duration - position,
end_reached()).register(self)
def current_position(self):
if self._timer is None:
return None
return self._current_track_duration - (self._timer.expiry - time.time())
class Client(BaseComponent):
"""
This is a variation of the Client class from circuits that
fixes a problem with channel names and provides a slightly
simplified interface that doesn't need explicit connect events.
"""
channel = "web"
def __init__(self, url, channel=channel, timeout=-1):
super(Client, self).__init__(channel=channel)
self._host, self._port, self._resource, self._secure = parse_url(url)
self._response = None
self._transport = None
self._outstanding = 0
self._pending = deque()
self._timeout = None
self._timer = None
@handler("request")
def request(self, event, method, url, body=None, headers={}, timeout=None):
timeout = timeout or self._timeout
if self._transport == None or not self._transport.connected:
self._transport = TCPClient(channel=self.channel).register(self)
HTTP(channel=self.channel).register(self._transport)
self.fire(connect(self._host, self._port, self._secure),
self._transport)
self._pending.append((method, url, body, headers, timeout))
else:
self._send_request(method, url, body, headers, timeout)
@handler("connected")
def _on_connected(self, host, port):
if len(self._pending) > 0:
args = self._pending.popleft()
self._send_request(*args)
@handler("disconnected")
def _on_disconnected(self):
if len(self._pending) > 0:
self.fire(connect(self._host, self._port, self._secure),
self._transport)
def _send_request(self, method, url, body=None, headers=None, timeout=None):
p = urlparse(url)
if p.hostname and p.hostname != self._host \
or p.scheme == "http" and self._secure \
or p.scheme == "https" and not self._secure \
or p.port and p.port != self._port:
self.fire(NotConnected())
return
resource = p.path
if p.query:
resource += "?" + p.query
if headers is None:
headers = Headers([])
else:
headers = Headers([(k, v) for k, v in headers.items()])
# Clients MUST include Host header in HTTP/1.1 requests (RFC 2616)
if not headers.has_key("Host"):
headers["Host"] = self._host \
+ (":" + str(self._port)) if self._port else ""
command = "%s %s HTTP/1.1" % (method, resource)
if body is not None:
headers["Content-Length"] = len(body)
message = "%s\r\n%s" % (command, headers)
self._outstanding += 1
if timeout is not None:
self._timer = Timer(timeout, SocketError(ETIMEDOUT), self.channel) \
.register(self)
self.fire(write(message.encode('utf-8')), self._transport)
if body is not None:
self.fire(write(body), self._transport)
def _clear_timer(self):
if self._timer is not None:
self._timer.unregister()
self._timer = None
@handler("response")
def _on_response(self, response):
self._response = response
self._outstanding -= 1
self._clear_timer()
if response.headers.get("Connection") == "Close":
self.fire(close(), self._transport)
@handler("close")
def close(self):
self._clear_timer()
if self._transport.connected:
self.fire(close(), self._transport)
@property
def connected(self):
return getattr(self._transport, "connected", False) \
if hasattr(self, "_transport") else False
@property
def response(self):
return getattr(self, "_response", None)
class DummyPlayer(providers.MediaPlayer):
'''
classdocs
'''
manifest = Manifest("Dummy Player", "CoCy Dummy Media Player")
def __init__(self):
super(DummyPlayer, self).__init__(self.manifest)
self._timer = None
def supportedMediaTypes(self):
return [
"http-get:*:audio/mpeg:*", "http-get:*:audio/ogg:*",
"http-get:*:audio/3gpp:*", "http-get:*:video/3gpp:*",
"http-get:*:audio/3gpp2:*", "http-get:*:video/3gpp2:*"
]
@handler("provider_updated")
def _on_provider_updated_handler(self, provider, changed):
if "source" in changed:
if self.state == "PLAYING":
if self._timer:
self._timer.unregister()
from cocy.upnp import DIDL_LITE_NS
duration = self.source_meta_dom.find(
str(QName(DIDL_LITE_NS, "item")) + "/" + str(QName(DIDL_LITE_NS, "res"))) \
.get("duration")
self.current_track_duration = duration_to_secs(duration)
self._timer = Timer(self.current_track_duration,
end_reached()).register(self)
if "state" in changed:
state = changed["state"]
if state == "IDLE":
if self._timer:
self._timer.unregister()
@handler("play", override=True)
@combine_events
def _on_play(self):
if self.source is None or self.state == "PLAYING":
return
if self._timer:
self._timer.unregister()
from cocy.upnp import DIDL_LITE_NS
duration = self.source_meta_dom.find(
str(QName(DIDL_LITE_NS, "item")) + "/" + str(QName(DIDL_LITE_NS, "res"))) \
.get("duration")
self.current_track_duration = duration_to_secs(duration)
self._timer = Timer(self.current_track_duration,
end_reached()).register(self)
self.state = "PLAYING"
@handler("end_reached")
def _on_end_reached(self, event):
if self._timer:
self._timer.unregister()
self._timer = None
self.fire(MediaPlayer.end_of_media())
@handler("seek", override=True)
def _on_seek(self, position):
if self.state != "PLAYING":
return
self._timer.unregister()
self._timer = Timer(self.current_track_duration - position,
end_reached()).register(self)
def current_position(self):
if self._timer is None:
return None
return self._current_track_duration - (self._timer.expiry -
time.time())
class Client(BaseComponent):
"""
This is a variation of the Client class from circuits that
fixes a problem with channel names and provides a slightly
simplified interface that doesn't need explicit connect events.
"""
channel = "web"
def __init__(self, url, channel=channel, timeout=-1):
super(Client, self).__init__(channel=channel)
self._host, self._port, self._resource, self._secure = parse_url(url)
self._response = None
self._transport = None
self._outstanding = 0
self._pending = deque()
self._timeout = None
self._timer = None
@handler("request")
def request(self, event, method, url, body=None, headers={}, timeout=None):
timeout = timeout or self._timeout
if self._transport == None or not self._transport.connected:
self._transport = TCPClient(channel=self.channel).register(self)
HTTP(channel=self.channel).register(self._transport)
self.fire(connect(self._host, self._port, self._secure),
self._transport)
self._pending.append((method, url, body, headers, timeout))
else:
self._send_request(method, url, body, headers, timeout)
@handler("connected")
def _on_connected(self, host, port):
if len(self._pending) > 0:
args = self._pending.popleft()
self._send_request(*args)
@handler("disconnected")
def _on_disconnected(self):
if len(self._pending) > 0:
self.fire(connect(self._host, self._port, self._secure),
self._transport)
def _send_request(self, method, url, body=None, headers={}, timeout=None):
p = urlparse(url)
if p.hostname and p.hostname != self._host \
or p.scheme == "http" and self._secure \
or p.scheme == "https" and not self._secure \
or p.port and p.port != self._port:
self.fire(NotConnected())
return
resource = p.path
if p.query:
resource += "?" + p.query
headers = Headers([(k, v) for k, v in list(headers.items())])
# Clients MUST include Host header in HTTP/1.1 requests (RFC 2616)
if "Host" not in headers:
headers["Host"] = self._host \
+ (":" + str(self._port)) if self._port else ""
command = "%s %s HTTP/1.1" % (method, resource)
if body is not None:
headers["Content-Length"] = len(body)
message = "%s\r\n%s" % (command, headers)
self._outstanding += 1
if timeout is not None:
self._timer = Timer(timeout, SocketError(ETIMEDOUT), self.channel) \
.register(self)
self.fire(write(message.encode('utf-8')), self._transport)
if body is not None:
self.fire(write(body), self._transport)
def _clear_timer(self):
if self._timer is not None:
self._timer.unregister()
self._timer = None
@handler("response")
def _on_response(self, response):
self._response = response
self._outstanding -= 1
self._clear_timer()
if response.headers.get("Connection") == "Close":
self.fire(close(), self._transport)
@handler("close")
def close(self):
self._clear_timer()
if self._transport.connected:
self.fire(close(), self._transport)
@property
def connected(self):
return getattr(self._transport, "connected", False) \
if hasattr(self, "_transport") else False
@property
def response(self):
return getattr(self, "_response", None)
