def test__on_recv(self):
client = ZmqObject(['tcp://localhost:5555'], zmq.REQ)
msg = MBMessage('foo', 'action_bar', None, {
'first_arg': 2,
'second_arg': 3
}, {'multiplier': 6})
zmq_msg = msg.to_json()
worker = self.worker
worker_thread = threading.Thread(target=worker.start)
worker_thread.start()
time.sleep(2)
client.zmq_connect()
client.zmq_send(zmq_msg)
result = worker.decode_msg(client.zmq_recv())
client.socket.close()
self.assertEqual(result.payload, 30)
def post(self):
post_data = json.loads(self.request.body)
email = post_data.get('email')
username = post_data.get('username')
password = post_data.get('password')
api_msg = MBMessage(None, 'authenticate',
{'username': email or username},
{'password': password}, self.context())
resp = yield self.dispatch(api_msg)
resp_msg = MBMessage(resp.msg_id,
resp.action,
api_msg.target,
resp.payload,
resp.context,
merge_target=False)
self.mb_cookies(resp)
self.set_header('Content-Type', 'application/json')
self.write(resp_msg.to_json())
self.finish()
def test_repr(self):
msg = MBMessage()
msg.encode(self.msg_id,
self.action,
self.target,
self.payload,
self.context)
repr_ = "MBMessage from joe: be-awesome(foo=bar,bar=foo)"
self.assertTrue(str(msg), repr_)
def decode_api_msg(self, msg_data):
context = getattr(self, 'context', {})
if callable(context):
context = context()
if isinstance(msg_data, str):
msg = MBMessage(msg_data)
else:
msg = MBMessage(*msg_data)
msg.context = context
return msg
def _unmarshal(raw_response):
resp = GoHandler.hyperdrive_decode(go_handlers, raw_response)
if not resp:
logging.info("GO ERROR")
return None
resp_msg = MBMessage(resp.msg_id, resp.action, resp.target,
resp.payload, resp.context, merge_target=False)
self.mb_cookies(resp)
return resp_msg.to_json()
def decode_api_msg(self, msg_data):
context = getattr(self, 'context', {})
if callable(context):
context = context()
if isinstance(msg_data, str):
msg = MBMessage(msg_data)
else:
msg = MBMessage(*msg_data)
msg.context = context
return msg
def get(self, user_id, mode=None):
user_id = _smart_user_id(self, user_id)
ctx = self.context()
if not user_id:
user_id = ctx.get('current_user_id')
if mode not in ["list", "url", "lists", "urls"]:
mode = "list"
api_msg = MBMessage(None, 'fetch_user_network', {
'user_id': user_id,
'mode': mode
}, {}, ctx)
go = GoHandler.can_handle(self, api_msg)
if go:
go_resp = yield go.dispatch()
resp = go.make_response(go_resp)
else:
resp = yield self.dispatch(api_msg)
self.write(resp.payload)
self.finish()
def make_response(self, raw_response):
response_body = raw_response.body
try:
response_payload = json.loads(response_body)
except ValueError:
return None
if not isinstance(response_payload, dict):
return None
response_code = response_payload.get("ResponseCode", None)
payload = response_payload.get("Payload")
callback = response_payload.get("Callback")
if callback:
payload = "{}({});".format(callback, json.dumps(payload))
if not response_code:
action = self.action
else:
action = response_code
return MBMessage(self.api_msg.msg_id, action, {}, payload or {},
self.api_msg.context)
def test_init_encode(self):
msg = MBMessage(
self.msg_id,
self.action,
self.target,
self.payload,
self.context)
result = msg.to_json()
excepted = json.dumps([msg.msg_id,
msg.action,
self.target,
msg.payload,
{}, msg.timestamp,])
self.assertEqual(result, excepted)
def get(self):
api_msg = MBMessage(None, 'ping', {}, {}, self.context())
resp = yield self.dispatch(api_msg)
self.set_header('Content-Type', 'application/json')
self.write(resp.payload)
self.finish()
def testActionOperationalError(self):
worker = self.worker
msg = MBMessage('foo', 'op_action', None, {'foo': 2}, {})
result = worker._dispatch(msg)
self.assertEqual(result, ('OperationalError', 'You are too ugly.'))
def _mb_msg(self, action, cookies, list_hash, **kwargs):
payload = ["test01", action, {'list_hash': list_hash}, kwargs, {}]
url = '/'.join([api_url, 'motherbrain'])
r = requests.post(url, data=json.dumps(payload), cookies=cookies)
return MBMessage(r.content)
def post(self, list_id=None):
api_msg = MBMessage(None, 'fetch_list', {'list_hash': list_id},
{'url': self.get_argument('url')}, self.context())
resp = yield self.dispatch(api_msg)
self.write(resp.payload)
self.finish()
def testMessageDispatching(self):
worker = self.worker
msg = MBMessage('foo', 'action_foo', None, {'first_arg': 2}, {})
result = worker._dispatch(msg)
self.assertEqual(result, ('action_foo', 4))
def testActionFailure(self):
worker = self.worker
msg = MBMessage('foo', 'fail_action', None, {'foo': 2}, {})
result = worker._dispatch(msg)
self.assertEqual(result,
('Exception', 'integer division or modulo by zero'))
def _unmarshal(raw_response):
resp = GoHandler.hyperdrive_decode(go_handlers, raw_response)
if not resp:
logging.info("GO ERROR")
return None
resp_msg = MBMessage(resp.msg_id,
resp.action,
resp.target,
resp.payload,
resp.context,
merge_target=False)
self.mb_cookies(resp)
return resp_msg.to_json()
def post(self):
api_msg = self.decode_api_msg(self.request.body)
go = GoHandler.can_handle(self, api_msg)
if go:
resp = yield go.dispatch()
resp_msg = go.make_response(resp)
else:
resp = yield self.dispatch(api_msg)
resp_msg = MBMessage(resp.msg_id, resp.action,
api_msg.target, resp.payload, resp.context, merge_target=False)
self.mb_cookies(resp)
self.set_header('Content-Type', 'application/json')
self.write(resp_msg.to_json())
self.finish()
def get(self):
query = self.get_argument('q') or self.get_argument('query')
api_msg = MBMessage(None, 'users_autocomplete', {'query': query}, {},
self.context())
resp = yield self.dispatch(api_msg)
self.write(resp.payload)
self.finish()
def testMessageDispatchingWithContext(self):
worker = self.worker
msg = MBMessage('foo', 'action_bar', None, {
'first_arg': 2,
'second_arg': 3
}, {'multiplier': 6})
result = worker._dispatch(msg)
self.assertEqual(result, ('action_bar', 30))
def get(self, activation_code):
api_msg = MBMessage(None, 'activate_account',
{}, {'activation_code': activation_code},
self.context())
resp = yield self.dispatch(api_msg)
self.clear_all_cookies()
self.mb_cookies(resp)
webclient_url = self.user_options.get('server', 'webclient_url')
self.redirect(webclient_url)
def test_decode(self):
msg = MBMessage()
msg.encode(self.msg_id,
self.action,
self.target,
self.payload,
self.context)
json = msg.to_json()
msg.decode(json)
self.assertEqual(json, msg.to_json())
def get(self):
query = self.get_argument('q') or self.get_argument('query')
scope = self.get_argument('scope', 'me')
if scope == 'me':
api_msg = MBMessage(None, 'search_url', {'query': query}, {},
self.context())
else:
api_msg = MBMessage(None, 'beta_search_url', {'query': query},
{'scope': scope}, self.context())
go = GoHandler.can_handle(self, api_msg)
if go:
go_resp = yield go.dispatch()
resp = go.make_response(go_resp)
else:
resp = yield self.dispatch(api_msg)
self.write(resp.payload)
self.finish()
def get(self):
self.set_header('Content-Type', 'application/json')
context = self.context()
user_id = context.get('current_user_id')
api_msg = MBMessage(None, 'fetch_user', {'user_id': user_id}, {},
self.context())
resp = yield self.dispatch(api_msg)
self.write(resp.payload)
self.finish()
def get(self):
api_msg = MBMessage(None, 'fetch_hashtags', {}, {}, self.context())
go = GoHandler.can_handle(self, api_msg)
if go:
go_resp = yield go.dispatch()
resp = go.make_response(go_resp)
else:
resp = yield self.dispatch(api_msg)
self.write(resp.payload)
self.finish()
def post(self):
api_msg = self.decode_api_msg(self.request.body)
go = GoHandler.can_handle(self, api_msg)
if go:
resp = yield go.dispatch()
resp_msg = go.make_response(resp)
else:
resp = yield self.dispatch(api_msg)
resp_msg = MBMessage(resp.msg_id,
resp.action,
api_msg.target,
resp.payload,
resp.context,
merge_target=False)
self.mb_cookies(resp)
self.set_header('Content-Type', 'application/json')
self.write(resp_msg.to_json())
self.finish()
def test__on_recv(self):
client = ZmqObject(['tcp://localhost:5555'], zmq.REQ)
msg = MBMessage('foo', 'action_bar', None,
{'first_arg': 2, 'second_arg': 3},
{'multiplier': 6})
zmq_msg = msg.to_json()
worker = self.worker
worker_thread = threading.Thread(target=worker.start)
worker_thread.start()
time.sleep(2)
client.zmq_connect()
client.zmq_send(zmq_msg)
result = worker.decode_msg(client.zmq_recv())
client.socket.close()
self.assertEqual(result.payload, 30)
def get(self, categories=None):
api_msg = MBMessage(None, 'fetch_list_by_categories',
{'categories': categories}, {}, self.context())
go = GoHandler.can_handle(self, api_msg)
if go:
go_resp = yield go.dispatch()
resp = go.make_response(go_resp)
else:
resp = yield self.dispatch(api_msg)
self.guess_ctype()
self.write(resp.payload)
self.finish()
def get(self, edition=None):
ctx = self.context()
api_msg = MBMessage(None, 'fetch_followmore', {}, {}, ctx)
go = GoHandler.can_handle(self, api_msg)
if go:
go_resp = yield go.dispatch()
resp = go.make_response(go_resp)
else:
resp = yield self.dispatch(api_msg)
self.write(resp.payload)
self.finish()
def login(self, handler):
anonymous_user = handler.current_user
is_new = False
self._dump_oauth_data()
oauth_user_id = handler.get_secure_cookie('oauth_user_id')
oauth_provider = handler.get_secure_cookie('oauth_provider')
email = self.oauth_data.get('email')
handler.clear_all_cookies()
if not self.account_exist(oauth_user_id, oauth_provider, email):
origin = {
'origin_id': str(anonymous_user.get('_id')),
'origin_creation_time': anonymous_user.get('creation_time')
}
user_query = self.new(origin=origin)
is_new = True
else:
user_query = self.update(oauth_user_id, oauth_provider)
if not user_query:
return None
user = self.db.users.find_one(user_query, safe=True)
if not user:
return None
self.set_secure_cookies(handler)
if is_new:
user_id = str(user.get('_id'))
msg = MBMessage(None, 'welcome', {'user_id': user_id},
{'registered_with': oauth_provider},
{'current_user_id': user_id})
handler.dispatch_and_forget(msg)
return user
def get(self, user_id=None):
api_msg = MBMessage(None, 'fetch_user_profile', {'user_id': user_id},
{}, self.context())
go = GoHandler.can_handle(self, api_msg)
if go:
go_resp = yield go.dispatch()
resp = go.make_response(go_resp)
else:
resp = yield self.dispatch(api_msg)
self.guess_ctype()
self.write(resp.payload)
self.finish()
def get(self, key=""):
api_msg = MBMessage(None, 'fetch_landing', {}, {'key': key},
self.context())
go = GoHandler.can_handle(self, api_msg)
if go:
go_resp = yield go.dispatch()
resp = go.make_response(go_resp)
else:
resp = yield self.dispatch(api_msg)
self.guess_ctype()
self.write(resp.payload)
self.finish()
def get(self, action):
args_as_list = self.request.arguments
payload = {k: v[0] for k, v in args_as_list.iteritems()}
api_msg = MBMessage(None, action, {}, payload, self.context())
go = GoHandler.can_handle(self, api_msg)
if go:
raw_resp = yield go.dispatch()
resp = go.make_response(raw_resp)
else:
resp = yield self.dispatch(api_msg)
self.write(resp.payload)
self.finish()
def get(self, category=None):
ctx = self.context()
api_msg = MBMessage(None, 'fetch_topusers',
{'category': category or choice(CATEGORIES)}, {},
ctx)
go = GoHandler.can_handle(self, api_msg)
if go:
go_resp = yield go.dispatch()
resp = go.make_response(go_resp)
else:
resp = yield self.dispatch(api_msg)
self.write(resp.payload)
self.finish()
def get(self, user_id=None):
if not user_id:
user_id = self.context().get("current_user_id")
api_msg = MBMessage(None, 'fetch_notifications', {'user_id': user_id},
{}, self.context())
go = GoHandler.can_handle(self, api_msg)
if go:
go_resp = yield go.dispatch()
resp = go.make_response(go_resp)
else:
resp = yield self.dispatch(api_msg)
self.write(resp.payload)
self.finish()
