def test_basic(self):
"""
"""
msg = remoting.Envelope(pyamf.AMF0)
self.assertEqual(remoting.encode(msg).getvalue(), '\x00' * 6)
msg = remoting.Envelope(pyamf.AMF3)
self.assertEqual(
remoting.encode(msg).getvalue(), '\x00\x03' + '\x00' * 4)
def test_basic(self):
"""
"""
msg = remoting.Envelope(pyamf.AMF0, pyamf.ClientTypes.Flash6)
self.assertEquals(remoting.encode(msg).getvalue(), '\x00' * 6)
msg = remoting.Envelope(pyamf.AMF3, pyamf.ClientTypes.FlashCom)
self.assertEquals(
remoting.encode(msg).getvalue(), '\x03\x01' + '\x00' * 4)
def test_service_request(self):
gw = gateway.BaseGateway({'test': TestService})
envelope = remoting.Envelope()
message = remoting.Request('spam', [], envelope=envelope)
self.assertRaises(gateway.UnknownServiceError, gw.getServiceRequest,
message, 'spam')
message = remoting.Request('test.spam', [], envelope=envelope)
sr = gw.getServiceRequest(message, 'test.spam')
self.assertTrue(isinstance(sr, gateway.ServiceRequest))
self.assertEqual(sr.request, envelope)
self.assertEqual(sr.service, TestService)
self.assertEqual(sr.method, 'spam')
message = remoting.Request('test')
sr = gw.getServiceRequest(message, 'test')
self.assertTrue(isinstance(sr, gateway.ServiceRequest))
self.assertEqual(sr.request, None)
self.assertEqual(sr.service, TestService)
self.assertEqual(sr.method, None)
gw = gateway.BaseGateway({'test': TestService})
envelope = remoting.Envelope()
message = remoting.Request('test')
sr = gw.getServiceRequest(message, 'test')
self.assertTrue(isinstance(sr, gateway.ServiceRequest))
self.assertEqual(sr.request, None)
self.assertEqual(sr.service, TestService)
self.assertEqual(sr.method, None)
# try to access an unknown service
message = remoting.Request('spam')
self.assertRaises(gateway.UnknownServiceError, gw.getServiceRequest,
message, 'spam')
# check x.x calls
message = remoting.Request('test.test')
sr = gw.getServiceRequest(message, 'test.test')
self.assertTrue(isinstance(sr, gateway.ServiceRequest))
self.assertEqual(sr.request, None)
self.assertEqual(sr.service, TestService)
self.assertEqual(sr.method, 'test')
def playBrightCoveStream(bc_videoID):
bc_playerID = 29323562001
bc_publisherID = 293884104
bc_const = "7aa45a3f2e7aadf8fa76da04bef79fb11f4a3fc2"
conn = httplib.HTTPConnection("c.brightcove.com")
envelope = remoting.Envelope(amfVersion=3)
envelope.bodies.append(
("/1",
remoting.Request(
target=
"com.brightcove.player.runtime.PlayerMediaFacade.findMediaById",
body=[bc_const, bc_playerID, bc_videoID, bc_publisherID],
envelope=envelope)))
conn.request("POST",
"/services/messagebroker/amf?playerId=" + str(bc_playerID),
str(remoting.encode(envelope).read()),
{'content-type': 'application/x-amf'})
response = conn.getresponse().read()
response = remoting.decode(response).bodies[0][1].body
streamUrl = ""
for item in sorted(response['renditions'],
key=lambda item: item['encodingRate'],
reverse=False):
encRate = item['encodingRate']
if encRate < maxBitRate:
streamUrl = item['defaultURL']
if streamUrl == "":
streamUrl = response['FLVFullLengthURL']
if streamUrl != "":
url = streamUrl[0:streamUrl.find("&")]
playpath = streamUrl[streamUrl.find("&") + 1:]
listItem = xbmcgui.ListItem(path=url + ' playpath=' + playpath)
xbmcplugin.setResolvedUrl(pluginhandle, True, listItem)
def __BuildBrightCoveAmfRequest(self, playerKey, contentId, url, experienceId, seed):
""" Builds a AMF request compatible with BrightCove
Arguments:
playerKey : string - Key identifying the current request
contentId : int - ID of the content to retrieve
url : string - Url of the page that calls the video SWF
seed : string - Constant which depends on the website
Keyword Arguments:
experienceId : id - <unknown parameter>
Returns a valid Brightcove request
"""
if self.logger:
self.logger.Debug("Creating BrightCover request for ContentId=%s, Key=%s, ExperienceId=%s, url=%s", contentId, playerKey, experienceId, url)
else:
print "Creating BrightCover request for ContentId=%s, Key=%s, ExperienceId=%s, url=%s" % (contentId, playerKey, experienceId, url)
# const = '686a10e2a34ec3ea6af8f2f1c41788804e0480cb'
pyamf.register_class(ViewerExperienceRequest, 'com.brightcove.experience.ViewerExperienceRequest')
pyamf.register_class(ContentOverride, 'com.brightcove.experience.ContentOverride')
contentOverrides = [ContentOverride(int(contentId))]
viewerExperienceRequest = ViewerExperienceRequest(url, contentOverrides, int(experienceId), playerKey)
envelope = remoting.Envelope(amfVersion=self.amfVersion)
remotingRequest = remoting.Request(target="com.brightcove.experience.ExperienceRuntimeFacade.getDataForExperience", body=[seed, viewerExperienceRequest], envelope=envelope)
envelope.bodies.append(("/1", remotingRequest))
return envelope
def _makeRequestBody(self, service, body, raw=False):
if not raw:
body = [body]
e = remoting.Envelope(pyamf.AMF3)
e['/1'] = remoting.Request(service, body=body)
return remoting.encode(e)
def BuildAmfRequest(self,
key,
url,
exp_id,
contentRefId=None,
contentId=None):
self.log(u'ContentRefId:' + str(contentRefId) + u'contentId:' +
str(contentId) + u', ExperienceId:' + str(exp_id) +
u', URL:' + url)
method = u"com.brightcove.experience.ExperienceRuntimeFacade.getDataForExperience"
className = method[0:method.rfind('.')]
hashValue = self.GetAmfClassHash(className)
self.log(u'hashValue:' + str(hashValue))
pyamf.register_class(
ViewerExperienceRequest,
u'com.brightcove.experience.ViewerExperienceRequest')
pyamf.register_class(ContentOverride,
u'com.brightcove.experience.ContentOverride')
content_override = ContentOverride(contentRefId=contentRefId,
contentId=contentId)
viewer_exp_req = ViewerExperienceRequest(url, [content_override],
int(exp_id), key)
self.log(content_override.tostring())
self.log(viewer_exp_req.tostring())
env = remoting.Envelope(amfVersion=3)
env.bodies.append(("/1",
remoting.Request(target=method,
body=[hashValue, viewer_exp_req],
envelope=env)))
return env
def BuildAmfRequest_FindRelated(self, key, exp_id, pubId, videoPlayer,
pageSize, pageNumber, getItemCount):
self.log(u'ExperienceId:' + str(exp_id))
method = "com.brightcove.player.runtime.PlayerSearchFacade.findRelatedVideos"
className = method[0:method.rfind('.')]
hashValue = self.GetAmfClassHash(className)
self.log(u'hashValue:' + str(hashValue))
pageSize = 12
pageNumber = 0
getItemCount = False
env = remoting.Envelope(amfVersion=3)
env.bodies.append((
"/1",
remoting.Request(
target=method,
body=[
hashValue,
int(exp_id), pubId, videoPlayer, pageSize, pageNumber,
getItemCount
],
# body=[hashValue, "Nuacht", 1, 0, False, None, None, None, None, None],
envelope=env)))
return env
def playLiveStream():
bc_playerID = 3546024667001
bc_publisherID = 3213846503001
content = opener.open(urlMain + "/" + siteVersion + "/Live").read()
match = re.compile('name="@videoPlayer" value="(.+?)"',
re.DOTALL).findall(content)
bc_const = "AQ~~,AAAC7Egt3lk~,ef2hDIwZtHuA9aR9af3pB4XK5IWi-srn"
conn = httplib.HTTPConnection("c.brightcove.com")
envelope = remoting.Envelope(amfVersion=3)
envelope.bodies.append(
("/1",
remoting.Request(
target=
"com.brightcove.player.runtime.PlayerMediaFacade.findMediaById",
body=[bc_const, bc_playerID, match[0], bc_publisherID],
envelope=envelope)))
conn.request("POST",
"/services/messagebroker/amf?playerId=" + str(bc_playerID),
str(remoting.encode(envelope).read()),
{'content-type': 'application/x-amf'})
response = conn.getresponse().read()
response = remoting.decode(response).bodies[0][1].body
streamUrl = response['FLVFullLengthURL'].replace("/z/",
"/i/") + "/master.m3u8"
content = opener.open(streamUrl).read()
match = re.compile('RESOLUTION=(.+?)x(.+?),.*?\n(.+?)\n',
re.DOTALL).findall(content)
for resX, resY, url in match:
if int(resY) <= qualityLive:
streamUrl = url
if streamUrl:
listitem = xbmcgui.ListItem(path=streamUrl)
xbmcplugin.setResolvedUrl(pluginhandle, True, listitem)
def getResponse(self, http_request, amf_request):
"""
Processes the AMF request, returning an AMF L{Response}.
@param http_request: The underlying HTTP Request
@type http_request: C{twisted.web.http.Request}
@param amf_request: The AMF Request.
@type amf_request: L{Envelope<pyamf.remoting.Envelope>}
"""
response = remoting.Envelope(amf_request.amfVersion, amf_request.clientType)
dl = []
def cb(body, name):
response[name] = body
for name, message in amf_request:
processor = self.getProcessor(message)
d = defer.maybeDeferred(processor, message, http_request=http_request)
d.addCallback(cb, name)
dl.append(d)
def cb2(result):
return response
d = defer.DeferredList(dl)
return d.addCallback(cb2)
def test_response(self):
"""
Test encoding of request body.
"""
msg = remoting.Envelope(pyamf.AMF0)
msg['/1'] = remoting.Response(body=[1, 2, 3])
self.assertEqual(len(msg), 1)
x = msg['/1']
self.assertTrue(isinstance(x, remoting.Response))
self.assertEqual(x.envelope, msg)
self.assertEqual(x.body, [1, 2, 3])
self.assertEqual(x.status, 0)
self.assertEqual(x.headers, msg.headers)
self.assertEqual(
remoting.encode(msg).getvalue(),
'\x00\x00\x00\x00'
'\x00\x01\x00\x0b/1/onResult\x00\x04null\x00\x00\x00\x00\n\x00\x00'
'\x00\x03\x00?\xf0\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00'
'\x00\x00\x00\x00@\x08\x00\x00\x00\x00\x00\x00'
)
def get_data(self):
data = {
"clientId": None,
"destination": "GenericDestination",
"correlationId": None,
"source":
"com.backendless.services.persistence.PersistenceService",
"operation": "first",
"messageRefType": None,
"headers": {
"application-type": "ANDROID",
"api-version": "1.0"
},
"timestamp": 0,
"body": ["ConfigCharlie"],
"timeToLive": 0,
"messageId": None,
}
msg = messaging.RemotingMessage(**data)
req = remoting.Request(target="null", body=[msg])
ev = remoting.Envelope(pyamf.AMF3)
ev["null"] = req
resp = requests.post(self.url,
data=remoting.encode(ev).getvalue(),
headers={"Content-Type": "application/x-amf"})
resp_msg = remoting.decode(resp.content)
config = json.dumps(resp_msg.bodies[0][1].body.body,
default=lambda obj: repr(obj))
return json.loads(config)
def test_expose_request(self):
self.gw.expose_request = True
self.executed = False
env = remoting.Envelope(pyamf.AMF0, pyamf.ClientTypes.Flash9)
request = remoting.Request('echo', body=['hello'])
env['/1'] = request
def echo(http_request, data):
self.assertTrue(isinstance(http_request, http.Request))
self.assertTrue(hasattr(http_request, 'amf_request'))
amf_request = http_request.amf_request
self.assertEquals(request.target, 'echo')
self.assertEquals(request.body, ['hello'])
self.executed = True
return data
self.gw.addService(echo)
d = client.getPage("http://127.0.0.1:%d/" % (self.port, ),
method="POST",
postdata=remoting.encode(env).getvalue())
return d.addCallback(lambda x: self.assertTrue(self.executed))
def test_timezone(self):
import datetime
self.executed = False
td = datetime.timedelta(hours=-5)
now = datetime.datetime.utcnow()
def echo(d):
self.assertEquals(d, now + td)
self.executed = True
return d
self.gw.addService(echo)
self.gw.timezone_offset = -18000
msg = remoting.Envelope(amfVersion=pyamf.AMF0, clientType=0)
msg['/1'] = remoting.Request(target='echo', body=[now])
stream = remoting.encode(msg)
env = {
'REQUEST_METHOD': 'POST',
'CONTENT_LENGTH': str(len(stream)),
'wsgi.input': stream
}
response = self.gw(env, lambda *args: None)
envelope = remoting.decode(''.join(response))
message = envelope['/1']
self.assertEquals(message.body, now)
def build_amf_request(clip_name):
env = remoting.Envelope(amfVersion=3)
env.bodies.append(("/1",
remoting.Request(target="tele5.getContentPlayer",
body=[clip_name],
envelope=env)))
return env
def test_timezone(self):
import datetime
self.executed = False
td = datetime.timedelta(hours=-5)
now = datetime.datetime.utcnow()
def echo(d):
self.assertEqual(d, now + td)
self.executed = True
return d
self.gw.addService(echo)
self.gw.timezone_offset = -18000
msg = remoting.Envelope(amfVersion=pyamf.AMF0)
msg['/1'] = remoting.Request(target='echo', body=[now])
stream = remoting.encode(msg)
self.environ['wsgi.input'] = stream
self.gw.post()
envelope = remoting.decode(self.response.out.getvalue())
message = envelope['/1']
self.assertEqual(message.body, now)
self.assertTrue(self.executed)
def test_expose_request(self):
self.gw.expose_request = True
self.executed = False
env = remoting.Envelope(pyamf.AMF0, pyamf.ClientTypes.Flash9)
request = remoting.Request('echo', body=['hello'])
env['/1'] = request
request = remoting.encode(env)
env = {
'REQUEST_METHOD': 'POST',
'CONTENT_LENGTH': str(len(request)),
'wsgi.input': request
}
def echo(http_request, data):
self.assertTrue('pyamf.request' in http_request)
request = http_request['pyamf.request']
self.assertTrue(isinstance(request, remoting.Request))
self.assertEquals(request.target, 'echo')
self.assertEquals(request.body, ['hello'])
self.executed = True
return data
self.gw.addService(echo)
response = self.gw(env, lambda *args: None)
self.assertTrue(self.executed)
def test_error_deferred_body(self):
d = defer.Deferred()
def echo(x):
d2 = defer.Deferred()
def cb(result):
raise IndexError
reactor.callLater(0, lambda: d2.callback(None))
d2.addCallback(cb)
return d2
p = self.getProcessor({'echo': echo}, expose_request=False)
request = remoting.Request('echo', envelope=remoting.Envelope())
request.body = ['a']
def cb(result):
self.assertTrue(isinstance(result, remoting.Response))
self.assertTrue(result.status, remoting.STATUS_ERROR)
self.assertTrue(isinstance(result.body, remoting.ErrorFault))
self.assertEqual(result.body.code, 'IndexError')
return p(request).addCallback(cb).addErrback(lambda x: d.errback())
def test_timezone(self):
import datetime
self.executed = False
td = datetime.timedelta(hours=-5)
now = datetime.datetime.utcnow()
def echo(d):
self.assertEqual(d, now + td)
self.executed = True
return d
gw = django.DjangoGateway({'test.test': echo},
timezone_offset=-18000,
expose_request=False)
msg = remoting.Envelope(amfVersion=pyamf.AMF0)
msg['/1'] = remoting.Request(target='test.test', body=[now])
http_request = make_http_request('POST',
remoting.encode(msg).getvalue())
res = remoting.decode(gw(http_request).content)
self.assertTrue(self.executed)
self.assertEqual(res['/1'].body, now)
def test_deferred_service(self):
def echo(data):
x = defer.Deferred()
reactor.callLater(0, x.callback, data)
return x
self.gw.addService(echo)
env = remoting.Envelope(pyamf.AMF0, pyamf.ClientTypes.Flash9)
request = remoting.Request('echo', body=['hello'])
env['/1'] = request
d = client.getPage("http://127.0.0.1:%d/" % (self.port, ),
method="POST",
postdata=remoting.encode(env).getvalue())
def cb(result):
response = remoting.decode(result)
self.assertEquals(response.amfVersion, pyamf.AMF0)
self.assertEquals(response.clientType, pyamf.ClientTypes.Flash9)
self.assertTrue('/1' in response)
body_response = response['/1']
self.assertEquals(body_response.status, remoting.STATUS_OK)
self.assertEquals(body_response.body, 'hello')
return d.addCallback(cb)
def test_timezone(self):
import datetime
self.executed = False
td = datetime.timedelta(hours=-5)
now = datetime.datetime.utcnow()
def echo(d):
self.assertEquals(d, now + td)
self.executed = True
return d
self.gw.addService(echo)
self.gw.timezone_offset = -18000
msg = remoting.Envelope(amfVersion=pyamf.AMF0, clientType=0)
msg['/1'] = remoting.Request(target='echo', body=[now])
stream = remoting.encode(msg)
d = client.getPage("http://127.0.0.1:%d/" % (self.port, ),
method="POST",
postdata=stream.getvalue())
def cb(response):
envelope = remoting.decode(''.join(response))
message = envelope['/1']
self.assertEquals(message.status, remoting.STATUS_OK)
self.assertEquals(message.body, now)
return d.addCallback(cb)
def test_encoding_error(self):
encode = _twisted.remoting.encode
def force_error(amf_request, context=None):
raise pyamf.EncodeError
def echo(request, data):
return data
self.gw.addService(echo)
env = remoting.Envelope(pyamf.AMF0, pyamf.ClientTypes.Flash9)
request = remoting.Request('echo', body=['hello'])
env['/1'] = request
d = client.getPage("http://127.0.0.1:%d/" % (self.port, ),
method="POST",
postdata=remoting.encode(env).getvalue())
_twisted.remoting.encode = force_error
def switch(x):
_twisted.remoting.encode = encode
d = self.assertFailure(d, error.Error)
def check(exc):
self.assertEquals(int(exc.args[0]), http.INTERNAL_SERVER_ERROR)
self.assertTrue(
exc.args[1].startswith('500 Internal Server Error'))
d.addCallback(check)
return d.addBoth(switch)
def call(self, cmd, callback=None, error_callback=None, args=[]):
req = remoting.Request(target=cmd, body=args)
env = remoting.Envelope(pyamf.AMF0)
env['/0'] = req
req_data = remoting.encode(env).getvalue()
resp = self._session.post(
self.__url,
data=req_data,
headers={'Content-Type': 'application/x-amf'})
if resp.status_code == 200:
resp_msg = remoting.decode(resp.content)['/0']
resp_status = resp_msg.status
if resp_status == STATUS_OK:
if callback != None:
callback(resp_msg.body)
return (resp_status, resp_msg.body)
elif resp_status == STATUS_ERROR:
if error_callback != None:
error_callback(resp_msg.body)
return (resp_status, resp_msg.body)
elif resp_status == STATUS_DEBUG:
print('Amf DEBUG response:')
print(resp_msg.body)
return (resp_status, resp_msg.body)
return (-1, None)
def test_request(self):
msg = remoting.Envelope(pyamf.AMF0)
msg['/1'] = remoting.Request('test.test', body=['hello'])
self.assertEqual(remoting.encode(msg, strict=True).getvalue(),
'\x00\x00\x00\x00\x00\x01\x00\ttest.test\x00\x02/1\x00\x00\x00'
'\r\n\x00\x00\x00\x01\x02\x00\x05hello')
def test_response(self):
msg = remoting.Envelope(pyamf.AMF0)
msg['/1'] = remoting.Response(['spam'])
self.assertEqual(remoting.encode(msg, strict=True).getvalue(),
'\x00\x00\x00\x00\x00\x01\x00\x0b/1/onResult\x00\x04null\x00\x00'
'\x00\x0c\n\x00\x00\x00\x01\x02\x00\x04spam')
def test_header(self):
"""
Test encoding of header.
"""
msg = remoting.Envelope(pyamf.AMF0)
msg.headers['spam'] = (False, 'eggs')
self.assertEqual(remoting.encode(msg).getvalue(),
'\x00\x00\x00\x01\x00\x04spam\x00\x00\x00\x00\x00\n\x00\x00\x00\x02'
'\x01\x00\x02\x00\x04eggs\x00\x00')
msg = remoting.Envelope(pyamf.AMF0)
msg.headers['spam'] = (True, ['a', 'b', 'c'])
self.assertEqual(remoting.encode(msg).getvalue(),
'\x00\x00\x00\x01\x00\x04spam\x00\x00\x00\x00\x00\n\x00\x00\x00\x02'
'\x01\x01\n\x00\x00\x00\x03\x02\x00\x01a\x02\x00\x01b\x02\x00\x01c'
'\x00\x00')
def test_create(self):
sw = gateway.ServiceWrapper(TestService)
request = remoting.Envelope()
x = gateway.ServiceRequest(request, sw, None)
self.assertEqual(x.request, request)
self.assertEqual(x.service, sw)
self.assertEqual(x.method, None)
def test_request(self):
msg = remoting.Envelope(pyamf.AMF0, pyamf.ClientTypes.Flash6)
msg['/1'] = remoting.Request('test.test', body='hello')
self.assertEquals(
remoting.encode(msg, strict=True).getvalue(),
'\x00\x00\x00\x00\x00\x01\x00\ttest.test\x00\x02/1\x00\x00\x00\x08'
'\x02\x00\x05hello')
def test_stream_pos(self):
"""
Ensure that the stream pointer is placed at the beginning.
"""
msg = remoting.Envelope(pyamf.AMF0, pyamf.ClientTypes.Flash6)
msg['/1'] = remoting.Response(body=[1, 2, 3])
stream = remoting.encode(msg)
self.assertEquals(stream.tell(), 0)
def build_amf_request(const, playerID, videoPlayer, publisherID):
env = remoting.Envelope(amfVersion=3)
env.bodies.append(
("/1",
remoting.Request(
target=
"com.brightcove.player.runtime.PlayerMediaFacade.findMediaById",
body=[const, playerID, videoPlayer, publisherID],
envelope=env)))
return env
