def test_create_stream(self):
mockito.when(StreamsAPI).create(source_uuid=mockito.any(),
name=mockito.any(), slug=mockito.any(),
description=mockito.any()).thenReturn(None)
data = {'name': faker.lorem.sentence()}
eq_(Stream.get_by(name=data['name']), None)
self.http_client.fetch(HTTPRequest(
self.get_url('/streams'), 'POST', body=json.dumps(data),
follow_redirects=False), self.stop)
response = self.wait()
eq_(response.code, 302)
ok_(Stream.get_by(name=data['name']))
def _load_ticket(self, stream_slug, destination_uuid):
stream = Stream.get_by(slug=stream_slug)
if not destination_uuid:
return Ticket.get_by(stream=stream, destination=Node.me())
node = Node.get_by(uuid=destination_uuid)
return Ticket.query.filter_by(stream=stream, destination=node).first()
def _load_ticket(self, stream_slug, destination_uuid):
stream = Stream.get_by(slug=stream_slug)
if not destination_uuid:
return Ticket.get_by(stream=stream, destination=Node.me())
node = Node.get_by(uuid=destination_uuid)
return Ticket.query.filter_by(stream=stream, destination=node).first()
def _handle_stream(self, stream):
"""Update the enabled flag on all tunnels that are for this stream."""
# reload to get a new database session
stream = Stream.get_by(slug=stream.slug)
try:
port = self.create_tunnel(stream.slug, "127.0.0.1",
settings.RTMP_PORT, self.stream_tunnels)
except Exception, e:
log.warning("Couldn't create a tunnel for %s: %s", stream, e)
def test_get_streams(self):
Node.me()
[StreamFactory() for _ in range(3)]
response = self.fetch('/streams')
eq_(response.code, 200)
result = json.loads(response.body)
ok_('streams' in result)
for stream in result['streams']:
ok_(Stream.get_by(name=stream['name']))
def test_delete(self):
node = Node.me()
ticket = TicketFactory(destination=node)
self.http_client.fetch(HTTPRequest(
self.get_url(ticket.absolute_url()), 'DELETE'), self.stop)
response = self.wait()
eq_(response.code, 200)
eq_(Ticket.get_by(id=ticket.id), None)
ok_(Stream.get_by(slug=ticket.stream.slug))
def _handle_stream(self, stream):
"""Update the enabled flag on all tunnels that are for this stream."""
# reload to get a new database session
stream = Stream.get_by(slug=stream.slug)
try:
port = self.create_tunnel(stream.slug, "127.0.0.1",
settings.RTMP_PORT, self.stream_tunnels)
except Exception, e:
log.warning("Couldn't create a tunnel for %s: %s",
stream, e)
def test_get_tickets(self):
response = self.fetch("/tickets")
eq_(response.code, 200)
result = json.loads(response.body)
ok_("tickets" in result)
eq_(len(result["tickets"]), 3)
for ticket in result["tickets"]:
source = Node.get_by(uuid=ticket["source"])
destination = Node.get_by(uuid=ticket["destination"])
ok_(Ticket.get_by(stream=Stream.get_by(slug=ticket["stream"]), source=source, destination=destination))
def test_delete(self):
node = Node.me()
ticket = TicketFactory(destination=node)
self.http_client.fetch(
HTTPRequest(self.get_url(ticket.absolute_url()), 'DELETE'),
self.stop)
response = self.wait()
eq_(response.code, 200)
eq_(Ticket.get_by(id=ticket.id), None)
ok_(Stream.get_by(slug=ticket.stream.slug))
def put(self, stream_slug):
stream = Stream.get_by(slug=stream_slug)
if stream:
# this accepts the streaming flag as a query parameter to get around
# the same-origin policy, as we can't get PUT data from the browser.
if "streaming" in self.request.arguments:
stream.streaming = self.request.arguments["streaming"]
else:
stream.streaming = self.get_json_argument("streaming")
if stream.streaming:
log.info("Resumed streaming %s", stream)
else:
log.info("Paused streaming %s", stream)
def put(self, stream_slug):
stream = Stream.get_by(slug=stream_slug)
if stream:
# this accepts the streaming flag as a query parameter to get around
# the same-origin policy, as we can't get PUT data from the browser.
if 'streaming' in self.request.arguments:
stream.streaming = self.request.arguments['streaming']
else:
stream.streaming = self.get_json_argument('streaming')
if stream.streaming:
log.info("Resumed streaming %s", stream)
else:
log.info("Paused streaming %s", stream)
def post(self, stream_slug):
"""Return whether or not this node can forward the stream requested to
the requesting node, and start doing so if it can."""
stream = Stream.get_by(slug=stream_slug)
if not stream:
try:
log.debug("Don't know of stream with slug %s, asking the "
"origin", stream_slug)
stream_data = StreamsAPI(settings.ASTRAL_WEBSERVER).find(
stream_slug)
except RequestError, e:
log.warning("Can't connect to server: %s", e)
except ResourceNotFound:
log.debug("Origin didn't know of a stream with slug",
stream_slug)
raise HTTPError(404)
def post(self, stream_slug):
"""Return whether or not this node can forward the stream requested to
the requesting node, and start doing so if it can."""
stream = Stream.get_by(slug=stream_slug)
if not stream:
try:
log.debug(
"Don't know of stream with slug %s, asking the "
"origin", stream_slug)
stream_data = StreamsAPI(
settings.ASTRAL_WEBSERVER).find(stream_slug)
except RequestError, e:
log.warning("Can't connect to server: %s", e)
except ResourceNotFound:
log.debug("Origin didn't know of a stream with slug",
stream_slug)
raise HTTPError(404)
def post(self):
"""Register a new available stream."""
# TODO kind of messy way to handle two different data types, but for
# some reason Torando is loading the name and description as lists
# instead of strings if they are form encded
if not hasattr(self.request, 'arguments') or not self.request.arguments:
self.load_json()
else:
self.request.arguments['name'] = self.request.arguments['name'][0]
self.request.arguments['description'] = (
self.request.arguments.get('description', [''])[0])
self.request.arguments.setdefault('source', Node.me().uuid)
if Stream.get_by(name=self.request.arguments['name']):
self.redirect("%s/upload" % settings.ASTRAL_WEBSERVER)
return
stream = Stream.from_dict(self.request.arguments)
try:
StreamsAPI(settings.ASTRAL_WEBSERVER).create(
source_uuid=stream.source.uuid, name=stream.name,
slug=stream.slug, description=stream.description)
except RequestError, e:
log.warning("Unable to register stream with origin webserver: %s",
e)
def get(self, stream_slug):
"""Return metadata for the stream."""
stream = Stream.get_by(slug=stream_slug)
if not stream:
raise web.HTTPError(404)
self.write({"stream": stream.to_dict()})
def update_stream_tunnel_flags(self):
for slug, tunnel in self.stream_tunnels.items():
stream = Stream.get_by(slug=slug)
if stream:
pass
def close_expired_stream_tunnels(self):
for slug, tunnel in self.stream_tunnels.items():
if not Stream.get_by(slug=slug):
self.destroy_tunnel(slug, self.stream_tunnels)
def update_stream_tunnel_flags(self):
for slug, tunnel in self.stream_tunnels.items():
stream = Stream.get_by(slug=slug)
if stream:
pass
def get(self, stream_slug):
"""Return metadata for the stream."""
stream = Stream.get_by(slug=stream_slug)
if not stream:
raise web.HTTPError(404)
self.write({'stream': stream.to_dict()})
def close_expired_stream_tunnels(self):
for slug, tunnel in self.stream_tunnels.items():
if not Stream.get_by(slug=slug):
self.destroy_tunnel(slug, self.stream_tunnels)
