def recved_packets_processor(self):
try:
while True:
packet = self.queue_recv.get()
LOGGER.info("recved: %s" % packet.bindata)
except Exception as e:
LOGGER.error("recved_packets_processor: %s" % str(e))
def authorized_sfk(appid, token):
""" Request Userbase by API """
import base64
import requests
# authorize scp in userbase
b64_uid = base64.standard_b64encode(CONFIG['scp_userbase']['uid'])
b64_token = base64.standard_b64encode(CONFIG['scp_userbase']['token'])
headers = {
'Authorization' : 'Nptv %s:%s' % (b64_uid, b64_token),
'Content-Type' : 'application/json'
}
userbase_host = CONFIG['scp_userbase']['host'] if CONFIG['scp_userbase']['host'] else 'userbase.staging.nptv.home'
url = 'http://%s/v2/applications/%s/auth.json' % (userbase_host, appid)
data = json.dumps({'token' : token})
try:
resp = requests.post(url, data=data, headers=headers)
except Exception as e:
LOGGER.error('Authorization request fails: %s; appid %s; token %s' % (str(e), appid, token))
return False
if int(resp.status_code) == 204:
LOGGER.info('Authorization passed')
return True
else:
LOGGER.info('Authorization rejected: appid %s; token %s' % (appid, token))
return False
def recver(self, callback=lambda: None):
""" recieve packets from sock,
check packet's type,
put packet to recv queue
"""
f = self.sock.makefile()
try:
while True:
try:
packet_class = determine_packet_type(f)
except Disconnection as e:
raise Disconnection
if packet_class == self.NATIVE_PACKET:
packet = packet_class()
packet.read_fields(f)
self.queue_recv.put(packet)
else:
LOGGER.error(
"{0} recver: unexpected magic".format(str(self)))
raise UnexpectedProtocol
except Disconnection as e:
LOGGER.info("Disconnection: {0}".format(str(self)))
except Exception as e:
LOGGER.error("recver error: {0} {1}".format(str(self), str(e)))
LOGGER.info(str(self) + " recver terminate")
eventlet.spawn_n(callback)
def close_socket(self):
try:
self.sock.shutdown(socket.SHUT_RDWR)
self.sock.close()
LOGGER.info("{0} sockwrapper close socket".format(str(self)))
except Exception as e:
LOGGER.error("Fails socket close: %s" % str(e))
def rengine_side(self, appid, token, uri):
""" Handle rengine (client) GET requests """
if not self.rengine_authorization_ok(appid, token):
LOGGER.info('Rengine content request authorization fails')
abort(401, 'Authorization failed')
evt = Event()
request_id = str(uuid4())
self.request_id_events[request_id] = evt
headers = [
"%s: %s" % (header, val)
for (header, val) in request.headers.items()
]
packet = ScpPacket.make_sfkcontent(uri, request_id, headers)
try:
self._send(packet, appid)
except Exception as e:
abort(500, str(e))
LOGGER.debug("uri %s expected" % uri)
timeout = Timeout(TIMEOUT)
try:
resp = evt.wait()
except Timeout:
del self.request_id_events[request_id]
abort(504, 'Gateway Timeout')
finally:
timeout.cancel()
LOGGER.debug("uri %s got" % uri)
return resp
def rengine_side(self, appid, token, uri):
""" Handle rengine (client) GET requests """
if not self.rengine_authorization_ok(appid, token):
LOGGER.info('Rengine content request authorization fails')
abort(401, 'Authorization failed')
evt = Event()
request_id = str(uuid4())
self.request_id_events[request_id] = evt
headers = ["%s: %s" % (header, val) for (header, val) in request.headers.items()]
packet = ScpPacket.make_sfkcontent(uri, request_id, headers)
try:
self._send(packet, appid)
except Exception as e:
abort(500, str(e))
LOGGER.debug("uri %s expected" % uri)
timeout = Timeout(TIMEOUT)
try:
resp = evt.wait()
except Timeout:
del self.request_id_events[request_id]
abort(504, 'Gateway Timeout')
finally:
timeout.cancel()
LOGGER.debug("uri %s got" % uri)
return resp
def mainloop(self, callback=lambda: None):
try:
while True:
packet = self.sfk.get_packet()
msg_type = packet.get_msg_type()
if msg_type == 'msg':
guid = packet.get_guid()
client_sockwrap = self.client_sockwraps.get(guid, None)
if client_sockwrap is None:
# client already disconnected
LOGGER.info('Client with guid %s not connected' %
str_uuid(guid))
continue
else:
spif2packet = self._unpack_scp_to_spif2(packet)
client_sockwrap.put_packet(spif2packet)
elif msg_type == 'ping':
pong = packet.make_pong()
self.sfk.put_packet(pong)
LOGGER.debug("appid %s; sfk_id %s - recieved ping" % \
(self.appid, self.sfk_id))
else:
raise DockerError("unknown msg_type")
except Exception:
LOGGER.exception("Sfk Docker fails")
callback()
def authorized_sfk(appid, token):
""" Request Userbase by API """
import base64
import requests
# authorize scp in userbase
b64_uid = base64.standard_b64encode(CONFIG['scp_userbase']['uid'])
b64_token = base64.standard_b64encode(CONFIG['scp_userbase']['token'])
headers = {
'Authorization': 'Nptv %s:%s' % (b64_uid, b64_token),
'Content-Type': 'application/json'
}
userbase_host = CONFIG['scp_userbase']['host'] if CONFIG['scp_userbase'][
'host'] else 'userbase.staging.nptv.home'
url = 'http://%s/v2/applications/%s/auth.json' % (userbase_host, appid)
data = json.dumps({'token': token})
try:
resp = requests.post(url, data=data, headers=headers)
except Exception as e:
LOGGER.error('Authorization request fails: %s; appid %s; token %s' %
(str(e), appid, token))
return False
if int(resp.status_code) == 204:
LOGGER.info('Authorization passed')
return True
else:
LOGGER.info('Authorization rejected: appid %s; token %s' %
(appid, token))
return False
def recver(self, callback=lambda: None):
""" recieve packets from sock,
check packet's type,
put packet to recv queue
"""
f = self.sock.makefile()
try:
while True:
try:
packet_class = determine_packet_type(f)
except Disconnection as e:
raise Disconnection
if packet_class == self.NATIVE_PACKET:
packet = packet_class()
packet.read_fields(f)
self.queue_recv.put(packet)
else:
LOGGER.error("{0} recver: unexpected magic".format(
str(self)))
raise UnexpectedProtocol
except Disconnection as e:
LOGGER.info("Disconnection: {0}".format(str(self)))
except Exception as e:
LOGGER.error("recver error: {0} {1}".format(str(self), str(e)))
LOGGER.info(str(self) + " recver terminate")
eventlet.spawn_n(callback)
def close_socket(self):
try:
self.sock.shutdown(socket.SHUT_RDWR)
self.sock.close()
LOGGER.info("{0} sockwrapper close socket".format(str(self)))
except Exception as e:
LOGGER.error("Fails socket close: %s" % str(e))
def recved_packets_processor(self):
try:
while True:
packet = self.queue_recv.get()
LOGGER.info("recved: %s" % packet.bindata)
except Exception as e:
LOGGER.error("recved_packets_processor: %s" % str(e))
def send_packet(self, packet):
data = packet.assemble()
try:
self.sock.sendall(data)
except Exception as e:
LOGGER.error("Sending auth packet fails: " + str(e))
else:
LOGGER.info("Auth packet sent successfully.")
def send_packet(self, packet):
data = packet.assemble()
try:
self.sock.sendall(data)
except Exception as e:
LOGGER.error("Sending auth packet fails: " + str(e))
else:
LOGGER.info("Auth packet sent successfully.")
def pinger(self):
try:
while True:
eventlet.sleep(PING_PERIOD)
ping = self._make_ping_packet()
self.queue_send.put(ping)
LOGGER.info("PING! In sending queue %d" % self.queue_send.qsize())
except Exception as e:
LOGGER.exception("Pinger fails: %s" % str(e))
def pinger(self):
try:
while True:
eventlet.sleep(PING_PERIOD)
ping = self._make_ping_packet()
self.queue_send.put(ping)
LOGGER.info("PING! In sending queue %d" %
self.queue_send.qsize())
except Exception as e:
LOGGER.exception("Pinger fails: %s" % str(e))
def register_sfk(self, sfk_sock, sfk_addr):
auth_packet = self._recv_packet(ScpPacket, sfk_sock)
# basic auth packet check
basic_test_passed = False # just init value
error_msg = ""
if auth_packet == None:
error_msg = "Error when auth packed recved"
elif auth_packet.get_msg_type() != 'auth':
error_msg = "Unexpected message type while auth attempt"
elif len(auth_packet.data) != 0:
error_msg = "Auth packet contains unexpected data"
else:
basic_test_passed = True
if not basic_test_passed:
LOGGER.error(error_msg)
sfk_sock.close()
return
appid, token = auth_packet.get_auth_info()
# check authorization
auth_check_passed = False
if not appid or not token:
LOGGER.error("Appid or Token not supplied")
elif NEED_AUTH and not authorized_sfk(appid, token):
LOGGER.error(
"Bad appid/token pair from just connected sfk: %s %s" %
(appid, token))
else:
auth_check_passed = True
if not auth_check_passed:
sfk_sock.close()
return
sfk_id = str(uuid.uuid4())
LOGGER.info("Sfk with appid %s, sfk_id %s connected" %
(str_uuid(appid), sfk_id))
# waiting for death_event prevents eventlet.serve from closing socket
death_event = eventlet.event.Event()
sfk_supervizor = SfkSupervizor(sfk_sock=sfk_sock,
registrar=self,
appid=appid,
sfk_id=sfk_id,
sfk_addr=sfk_addr,
death_event=death_event)
self.remember_sfk(sfk_supervizor, appid, sfk_id)
self.info.add_sfk_instance(appid, sfk_id, sfk_addr)
death_event.wait()
LOGGER.info(
'Register: death_event from sfk appid {0}; sfk_id {1}'.format(
appid, sfk_id))
def _read_int(fileobj):
try:
data = fileobj.read(4)
if not data:
LOGGER.info("disconnection") # хотелось бы таки знать, что именно отвалилось
return None
return struct.unpack('!I', data)[0]
except Exception as e:
LOGGER.error(
"cannot read int field from socket: {0}".format(str(e)))
return None
def _read_int(fileobj):
try:
data = fileobj.read(4)
if not data:
LOGGER.info("disconnection"
) # хотелось бы таки знать, что именно отвалилось
return None
return struct.unpack('!I', data)[0]
except Exception as e:
LOGGER.error("cannot read int field from socket: {0}".format(
str(e)))
return None
def register_sfk(self, sfk_sock, sfk_addr):
auth_packet = self._recv_packet(ScpPacket, sfk_sock)
# basic auth packet check
basic_test_passed = False # just init value
error_msg = ""
if auth_packet == None:
error_msg = "Error when auth packed recved"
elif auth_packet.get_msg_type() != 'auth':
error_msg = "Unexpected message type while auth attempt"
elif len(auth_packet.data) != 0:
error_msg = "Auth packet contains unexpected data"
else:
basic_test_passed = True
if not basic_test_passed:
LOGGER.error(error_msg)
sfk_sock.close()
return
appid, token = auth_packet.get_auth_info()
# check authorization
auth_check_passed = False
if not appid or not token:
LOGGER.error("Appid or Token not supplied")
elif NEED_AUTH and not authorized_sfk(appid, token):
LOGGER.error("Bad appid/token pair from just connected sfk: %s %s" % (appid, token))
else:
auth_check_passed = True
if not auth_check_passed:
sfk_sock.close()
return
sfk_id = str(uuid.uuid4())
LOGGER.info("Sfk with appid %s, sfk_id %s connected" % (str_uuid(appid), sfk_id))
# waiting for death_event prevents eventlet.serve from closing socket
death_event = eventlet.event.Event()
sfk_supervizor = SfkSupervizor(sfk_sock=sfk_sock,
registrar=self,
appid=appid,
sfk_id=sfk_id,
sfk_addr=sfk_addr,
death_event=death_event)
self.remember_sfk(sfk_supervizor, appid, sfk_id)
self.info.add_sfk_instance(appid, sfk_id, sfk_addr)
death_event.wait()
LOGGER.info('Register: death_event from sfk appid {0}; sfk_id {1}'.format(appid, sfk_id))
def run(config):
global CONFIG
CONFIG = config
registrar = Registrar()
addr = (config['sfk_server']['host'], int(config['sfk_server']['port']))
LOGGER.info("Starting sfk-side server on %s:%d" % addr)
eventlet.spawn_n(eventlet.serve, eventlet.listen(addr),
registrar.register_sfk)
addr = (config['rengine_server']['host'],
int(config['rengine_server']['port']))
LOGGER.info("Starting rengine-side server on %s:%d" % addr)
eventlet.spawn_n(eventlet.serve, eventlet.listen(addr),
registrar.register_rengine)
LOGGER.info("Starting http server")
run_httpserver(
registrar,
config,
host=config['http_server']['host'],
port=config['http_server']['port'],
debug=True, # TODO remove in production!!
quiet=True,
server='eventlet')
def run(config):
global CONFIG
CONFIG = config
registrar = Registrar()
addr = (config['sfk_server']['host'],
int(config['sfk_server']['port']))
LOGGER.info("Starting sfk-side server on %s:%d" %addr)
eventlet.spawn_n(eventlet.serve,
eventlet.listen(addr),
registrar.register_sfk)
addr = (config['rengine_server']['host'],
int(config['rengine_server']['port']))
LOGGER.info("Starting rengine-side server on %s:%d" %addr)
eventlet.spawn_n(eventlet.serve,
eventlet.listen(addr),
registrar.register_rengine)
LOGGER.info("Starting http server")
run_httpserver(registrar, config,
host=config['http_server']['host'],
port=config['http_server']['port'],
debug=True, # TODO remove in production!!
quiet=True,
server='eventlet')
def register_rengine(self, sock, addr):
packet = self._recv_packet(Spif2Packet, sock)
if packet == None:
sock.close()
return
try:
appid = packet.get_appid()
except ProtocolError:
LOGGER.error(
"cannot extract appid needed for just connected client")
sock.close()
return
if not self._is_sfk_connectable(appid):
LOGGER.error(
"attempt connecting to non-connected sfk with appid " \
+ str(appid))
sock.close()
return
sfk, sfk_id = self._get_sfk(appid) # after _is_connectable check
# always correct
guid = self._generate_guid()
self.info.add_client(appid, sfk_id, guid, addr)
LOGGER.info(
'Register: Client connected to appid {0} with guid {1}'.format(
appid, str_uuid(guid)))
# waiting for death_event prevents eventlet.serve from closing socket
death_event = eventlet.event.Event()
sfk.start_client(sock=sock,
guid=guid,
addr=addr,
first_packet=packet,
death_event=death_event)
death_event.wait()
LOGGER.info('Register: death_event from rengine guid {0}'.format(
str_uuid(guid)))
def drop_client(self, guid):
# prevent to call this method from multiple threads
try:
if self.clients[guid].alive:
self.clients[guid].alive = False
else:
return
except KeyError:
return
self.clients[guid].kill_threads()
self.clients[guid].sockwrap.close_socket()
self.clients[guid].death_event.send()
self.sfk.docker.del_client(guid)
del self.clients[guid]
LOGGER.info("Client guid {0} was dropped".format(str_uuid(guid)))
self.info.drop_client(self.appid, self.sfk_id, guid)
# send signal to sfk <<session dropped>>
session_dropped = ScpPacket.make_session_dropped(guid)
self.sfk.sockwrap.put_packet(session_dropped)
def recved_packets_processor(self):
try:
while True:
packet = self.queue_recv.get()
self.guids.add(packet.guid)
mtype = packet.get_msg_type()
payload = None
if mtype == 'msg':
buf = StringIO.StringIO(packet.data)
pack_class = prot.determine_packet_type(buf)
client_pack = pack_class()
client_pack.read_fields(buf)
payload = client_pack.bindata
elif mtype == 'sfkcontent':
SfkModel.sfkcontent_handler(packet)
continue
elif mtype == 'session_dropped':
self.guids.remove(packet.guid)
LOGGER.info('session dropped guid {0}'.format(
str_uuid(packet.guid)))
continue
elif mtype == 'pong':
LOGGER.info('Pong recieved')
else:
LOGGER.error("Unknown message type: {0}".format(mtype))
LOGGER.info('recved packet guid {0}; mtype {1}'.format(
str_uuid(packet.guid),
mtype))
if payload:
LOGGER.info('message: %s' % payload)
reply = self._make_reply_packet(payload=payload,
guid=packet.guid)
self.queue_send.put(reply)
LOGGER.info('reply is sent')
except Exception as e:
LOGGER.exception("recved_packets_processor: " + str(e))
def register_rengine(self, sock, addr):
packet = self._recv_packet(Spif2Packet, sock)
if packet == None:
sock.close()
return
try:
appid = packet.get_appid()
except ProtocolError:
LOGGER.error(
"cannot extract appid needed for just connected client")
sock.close()
return
if not self._is_sfk_connectable(appid):
LOGGER.error(
"attempt connecting to non-connected sfk with appid " \
+ str(appid))
sock.close()
return
sfk, sfk_id = self._get_sfk(appid) # after _is_connectable check
# always correct
guid = self._generate_guid()
self.info.add_client(appid, sfk_id, guid, addr)
LOGGER.info(
'Register: Client connected to appid {0} with guid {1}'.format(
appid, str_uuid(guid)))
# waiting for death_event prevents eventlet.serve from closing socket
death_event = eventlet.event.Event()
sfk.start_client(sock=sock, guid=guid, addr=addr,
first_packet=packet, death_event=death_event)
death_event.wait()
LOGGER.info(
'Register: death_event from rengine guid {0}'.format(
str_uuid(guid)))
def recved_packets_processor(self):
try:
while True:
packet = self.queue_recv.get()
self.guids.add(packet.guid)
mtype = packet.get_msg_type()
payload = None
if mtype == 'msg':
buf = StringIO.StringIO(packet.data)
pack_class = prot.determine_packet_type(buf)
client_pack = pack_class()
client_pack.read_fields(buf)
payload = client_pack.bindata
elif mtype == 'sfkcontent':
SfkModel.sfkcontent_handler(packet)
continue
elif mtype == 'session_dropped':
self.guids.remove(packet.guid)
LOGGER.info('session dropped guid {0}'.format(
str_uuid(packet.guid)))
continue
elif mtype == 'pong':
LOGGER.info('Pong recieved')
else:
LOGGER.error("Unknown message type: {0}".format(mtype))
LOGGER.info('recved packet guid {0}; mtype {1}'.format(
str_uuid(packet.guid), mtype))
if payload:
LOGGER.info('message: %s' % payload)
reply = self._make_reply_packet(payload=payload,
guid=packet.guid)
self.queue_send.put(reply)
LOGGER.info('reply is sent')
except Exception as e:
LOGGER.exception("recved_packets_processor: " + str(e))
def sfk_side(self, request_id, uri):
""" Handle POST requests from sfk """
if not self.sfk_authorization_ok(request_id):
LOGGER.info('Sfk POST bad request_id')
abort(401, "Bad request_id")
body = request.body
headers = request.headers
# cut custom headers for scp
if 'X-SCP-Status' in headers: # headers case-insensitive
status = headers['X-SCP-Status']
passed_headers = dict((k, v) for (k, v) in headers.items()
if not k.startswith(_hkey('X-SCP')))
status_supplied = True
else:
status = '500 Internal Server Error'
body = ''
passed_headers = {}
status_supplied = False
LOGGER.error("X-SCP-Status was not supplied")
resp = HTTPResponse(body, status, **passed_headers)
evt = self.request_id_events.get(request_id, None)
if evt is None:
# если нет такого ожидаемого события, то уже прошел таймаут
abort(408, '') # Request Timeout
else:
evt.send(resp)
del self.request_id_events[request_id]
if status_supplied:
return '' # пустой ответ с кодом 200
else:
abort(400, 'X-Scp-Status not supplied')
def sfk_side(self, request_id, uri):
""" Handle POST requests from sfk """
if not self.sfk_authorization_ok(request_id):
LOGGER.info('Sfk POST bad request_id')
abort(401, "Bad request_id")
body = request.body
headers = request.headers
# cut custom headers for scp
if 'X-SCP-Status' in headers: # headers case-insensitive
status = headers['X-SCP-Status']
passed_headers = dict((k, v) for (k, v) in headers.items()
if not k.startswith(_hkey('X-SCP')))
status_supplied = True
else:
status = '500 Internal Server Error'
body = ''
passed_headers = {}
status_supplied = False
LOGGER.error("X-SCP-Status was not supplied")
resp = HTTPResponse(body, status, **passed_headers)
evt = self.request_id_events.get(request_id, None)
if evt is None:
# если нет такого ожидаемого события, то уже прошел таймаут
abort(408, '') # Request Timeout
else:
evt.send(resp)
del self.request_id_events[request_id]
if status_supplied:
return '' # пустой ответ с кодом 200
else:
abort(400, 'X-Scp-Status not supplied')
def drop_client(self, guid):
# prevent to call this method from multiple threads
try:
if self.clients[guid].alive:
self.clients[guid].alive = False
else:
return
except KeyError:
return
self.clients[guid].kill_threads()
self.clients[guid].sockwrap.close_socket()
self.clients[guid].death_event.send()
self.sfk.docker.del_client(guid)
del self.clients[guid]
LOGGER.info("Client guid {0} was dropped".format(str_uuid(guid)))
self.info.drop_client(self.appid, self.sfk_id, guid)
# send signal to sfk <<session dropped>>
session_dropped = ScpPacket.make_session_dropped(guid)
self.sfk.sockwrap.put_packet(session_dropped)
def kill_all_subsystems(self):
# prevent to call this method from multiple threads
if self.alive:
self.alive = False
else:
return
LOGGER.info("{0} dropping all subsystems".format(self.appid))
for guid in self.clients.keys():
self.drop_client(guid)
LOGGER.info("{0} kill sfk-related greenthreads".format(self.appid))
self.sfk.sockwrap.close_socket()
self.sfk.kill_threads()
self.sfk.death_event.send()
LOGGER.info(self.appid + " subsystem disconnected and killed")
self.registrar.forget_sfk(self.appid, self.sfk_id)
self.info.drop_sfk_instance(self.appid, self.sfk_id)
def kill_all_subsystems(self):
# prevent to call this method from multiple threads
if self.alive:
self.alive = False
else:
return
LOGGER.info("{0} dropping all subsystems".format(self.appid))
for guid in self.clients.keys():
self.drop_client(guid)
LOGGER.info("{0} kill sfk-related greenthreads".format(self.appid))
self.sfk.sockwrap.close_socket()
self.sfk.kill_threads()
self.sfk.death_event.send()
LOGGER.info(self.appid + " subsystem disconnected and killed")
self.registrar.forget_sfk(self.appid, self.sfk_id)
self.info.drop_sfk_instance(self.appid, self.sfk_id)
def run_app():
p = OptionParser()
p.add_option('--config', default='')
p.add_option('--noauth', default=False, action='store_true')
options, _ = p.parse_args()
if not options.config:
print >> sys.stderr, "Provide path to config!"
sys.exit(1)
if not options.noauth:
LOGGER.info("Userbase authorization of sfks is needed by default. \
If you want to start SCP for some debugging purposes, \
provide --noauth command line key.")
else:
LOGGER.info("Userbase authorization switched off")
config = dosca.parse_file(options.config)
LOGGER.info('Sfk Connection Point ver. %s' % __version__)
import main
main.NEED_AUTH = not options.noauth
main.run(config)
LOGGER.error("recved_packets_processor: %s" % str(e))
def test(self, interval, n):
for i in range(n):
eventlet.sleep(interval)
packet = self._make_message_packet(i)
self.queue_send.put(packet)
if __name__ == '__main__':
try:
ID = sys.argv[1]
except Exception:
LOGGER.info("Default value for ID(%s) will be used" % ID)
try:
APPID_NO = int(sys.argv[2])
except Exception:
LOGGER.info("Default value for APPID_NO(%d) will be used" % APPID_NO)
client = ClientModel(appid=appids[APPID_NO])
client.connect(ADDRESS)
client.send_packet(client._make_session_packet())
eventlet.spawn_n(client.recver)
eventlet.spawn_n(client.sender)
eventlet.spawn_n(client.recved_packets_processor)
client.test(2, 5)
def sfkcontent_handler(packet):
LOGGER.info("Got SfkContent protobuf")
uri, request_id, headers = packet.get_sfkcontent()
LOGGER.info("uri: %s" % uri)
LOGGER.info("request_id: %s" % request_id)
url = '/'.join([STATIC_SERV_URL, request_id, uri])
LOGGER.info("URL: %s" % url)
# time.sleep(2)
if uri in URI_PATH:
data = open(URI_PATH[uri], 'rb').read()
headers = {'Content-Type': 'image/jpg', 'X-SCP-Status': '200 OK'}
else:
LOGGER.error("Chpoken uri: %s" % uri)
data = 'No way!'
headers = {
'Content-Type': 'text/plain',
'X-SCP-Status': '404 Not Found'
}
r = requests.post(url, data=data, headers=headers)
LOGGER.info("Uri %s sent, with response code %s" %
(uri, r.status_code))
if int(r.status_code) != 200:
LOGGER.error(r.text)
LOGGER.info("request headers")
for header in headers:
LOGGER.info(header)
LOGGER.info("response headers")
for header, val in r.headers.items():
LOGGER.info("%s: %s" % (header, val))
return None
except Exception as e:
LOGGER.error("recved_packets_processor: %s" % str(e))
def test(self, interval, n):
for i in range(n):
eventlet.sleep(interval)
packet = self._make_message_packet(i)
self.queue_send.put(packet)
if __name__ == '__main__':
try:
ID = sys.argv[1]
except Exception:
LOGGER.info("Default value for ID(%s) will be used" % ID)
try:
APPID_NO = int(sys.argv[2])
except Exception:
LOGGER.info("Default value for APPID_NO(%d) will be used" % APPID_NO)
client = ClientModel(appid=appids[APPID_NO])
client.connect(ADDRESS)
client.send_packet(client._make_session_packet())
eventlet.spawn_n(client.recver)
eventlet.spawn_n(client.sender)
eventlet.spawn_n(client.recved_packets_processor)
client.test(2, 5)
def sfkcontent_handler(packet):
LOGGER.info("Got SfkContent protobuf")
uri, request_id, headers = packet.get_sfkcontent()
LOGGER.info("uri: %s" % uri)
LOGGER.info("request_id: %s" % request_id)
url = '/'.join([STATIC_SERV_URL, request_id, uri])
LOGGER.info("URL: %s" % url)
# time.sleep(2)
if uri in URI_PATH:
data=open(URI_PATH[uri], 'rb').read()
headers={'Content-Type': 'image/jpg',
'X-SCP-Status': '200 OK'}
else:
LOGGER.error("Chpoken uri: %s" % uri)
data='No way!'
headers={'Content-Type': 'text/plain',
'X-SCP-Status': '404 Not Found'}
r = requests.post(url,
data=data,
headers=headers)
LOGGER.info("Uri %s sent, with response code %s" % (uri, r.status_code))
if int(r.status_code) != 200:
LOGGER.error(r.text)
LOGGER.info("request headers")
for header in headers:
LOGGER.info(header)
LOGGER.info("response headers")
for header, val in r.headers.items():
LOGGER.info("%s: %s" % (header, val))
return None
