def _call(self, module, function, args, context):
mid = self.new_message_id()
self.port.write(
(Atom('C'), mid, module, function, map(self.encoder,
args), context))
response = self._receive(expect_id=mid)
try:
mtype, _mid, value = response
except ValueError:
raise InvalidMessage(response)
if mtype != "r":
if mtype == "e":
raise CallError(value)
raise UnknownMessage(response)
return self.decoder(value)
def _call(self, module, function, args, context):
with self.message_id() as mid:
self.port.write((
Atom(b'C'),
mid,
module,
function,
# TODO: Optimize list(map())
list(map(self.encoder, args)),
context))
response = self._receive(expect_id=mid)
try:
mtype, _mid, value = response
except ValueError:
raise InvalidMessage(response)
if mtype != b"r":
if mtype == b"e":
raise CallError(value)
raise UnknownMessage(response)
return self.decoder(value)
def _inner(protocol,
entry_point,
context=None,
uid=None,
values=None,
get_args=None,
*args):
try:
l = logger(uid)
values = dict(values)
world = World(uid, l, context, **values)
result = handler(protocol, entry_point, world, get_args)
btl_result = BtlResult(world.raw)
return btl_result.get_result(result)
except:
try:
l(traceback.format_exc())
except:
pass
return Atom("error"), json.dumps({"result": "fail"})
def write(self, data):
if not isinstance(data, str):
raise TypeError("must be str, not %s" % data.__class__.__name__)
return self.__port.write((Atom(b"P"), data))
def make_ref(self):
return self._call(Atom(b'erlang'), Atom(b'make_ref'), [], Atom(b'L'))
def cast(self, pid, message):
# It's safe to call it from multiple threads because port.write will be
# locked
self.port.write((Atom(b'M'), pid, message))
def subscribe(conn, topic, qos):
erlang.call(Atom(b'shuwa_exproto'), Atom(b'subscribe'), [conn, topic, qos])
return
def register(conn, clientinfo):
erlang.call(Atom(b'shuwa_exproto'), Atom(b'register'), [conn, clientinfo])
return
def send(conn, data):
erlang.call(Atom(b'shuwa_exproto'), Atom(b'send'), [conn, data])
return
def setup_date_types():
erlang.set_encoder(date_encoder)
erlang.set_decoder(date_decoder)
return Atom("ok")
def test_writelines(self):
stdout = RedirectedStdout(TestPort())
self.assertEqual((Atom("P"), "data"), stdout.writelines(["da", "ta"]))
self.assertRaises(TypeError, stdout.writelines, ["da", 1234])
def test_write(self):
stdout = RedirectedStdout(TestPort())
self.assertEqual((Atom("P"), "data"), stdout.write("data"))
self.assertRaises(TypeError, stdout.write, 1234)
def write(self, data):
if self.closed:
raise ValueError("I/O operation on closed file")
if not isinstance(data, str):
raise TypeError("must be str, not %s" % data.__class__.__name__)
return self.__port.write((Atom(b"P"), data))
from match3.handlers.client_data.admin_transaction_add import admin_transaction_add_handler
from match3.handlers.client_data.get_user import get_user_handler
from match3.handlers.client_data.set_user import set_user_handler
from match3.handlers.client_data.transaction_ios_pay import transaction_ios_pay_handler
from match3.handlers.client_data.transaction_ios_pay_callback import transaction_ios_pay_callback_handler
from match3.handlers.client_data.transaction_pay import transaction_pay_handler
from match3.handlers.client_data.transactions_unused_get import transactions_unused_get_handler
from match3.handlers.client_data.transactions_use import transactions_use_handler
protocol = None
entry_point = "main"
uid = 'e6f22045d9544675971b7f32950b7c07'
context = simplejson.dumps({"order": '700000172785742', "item": "crystals_30"})
values = [(Atom(
"player"
), '{"player":"ddd", "used_transactions": {"transaction_pack_5":{"new_order1":1498050271021, "new_order2":1498050271022}} }'
)]
values = [(Atom("http"),
simplejson.dumps({
"status": 0,
"environment": "Production",
"receipt": {
"receipt_type":
"Production",
"adam_id":
1042276818,
"app_item_id":
1042276818,
"bundle_id":
"ru.kefirgames",
def handle(self, port, message):
if message == Atom("stop"):
port.write(self.collected)
self.collected = []
else:
self.collected.append(message)
def switch(n):
result = 0
for i in range(n):
_, result = erlang.call(Atom("python2_tests"), Atom("test_callback"),
[(result, i)])
return n
def test_method():
return Atom("ok")
def call(self, module, function, args):
# TODO: Check all arguments
# TODO: Reraise Python related exceptions
return erlang.call(Atom("python"), Atom("call"),
[self.pid, module, function, args])
def date_encoder(value):
if isinstance(value, date):
value = Atom("date"), (value.year, value.month, value.day)
elif isinstance(value, timedelta):
value = Atom("days"), value.days
return value
def stop(self):
# TODO: Check result
erlang.call(Atom("python"), Atom("stop"), [self.pid])
def close(conn):
erlang.call(Atom(b'shuwa_exproto'), Atom(b'close'), [conn])
return
def rev_call(pid, r):
erlang.call(Atom(b'erlport_SUITE'), Atom(b'handle_call'), [pid, r])
return
def publish(conn, message):
erlang.call(Atom(b'shuwa_exproto'), Atom(b'publish'), [conn, message])
return
def write(self, data):
if self.__closed:
raise ValueError("I/O operation on closed file")
if not isinstance(data, (str, unicode, buffer)):
raise TypeError("expected a characer buffer object")
return self.__port.write((Atom("P"), data))
def unsubscribe(conn, topic):
erlang.call(Atom(b'shuwa_exproto'), Atom(b'subscribe'), [conn, topic])
return
def handler(message):
erlang.call(Atom("python2_tests"), Atom("test_callback"),
[(Atom("message"), message)])
def self(self):
if self._self is None:
self._self = self._call(Atom(b'erlang'), Atom(b'self'), [],
Atom(b'L'))
return self._self
def setup_faulty_message_handler():
def handler(message):
raise ValueError(message)
erlang.set_message_handler(handler)
return Atom("ok")
def write(self, data):
if not isinstance(data, (str, unicode, buffer)):
raise TypeError("expected a characer buffer object")
return self.__port.write((Atom("P"), data))
def recurse(python, n):
if n <= 0:
return Atom("done")
return erlang.call(Atom("python2_tests"), Atom("recurse"), [python, n - 1])
