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])