Beispiel #1
0
def test_duplicate_loads():
    # multiple loads with same module_name returns the same module
    ab_1 = thriftpy.load("addressbook.thrift",
                         module_name="addressbook_thrift")
    ab_2 = thriftpy.load("./addressbook.thrift",
                         module_name="addressbook_thrift")
    assert ab_1 == ab_2
Beispiel #2
0
def test_isinstancecheck():
    ab = thriftpy.load("addressbook.thrift")
    ab2 = thriftpy.load("addressbook.thrift")

    assert isinstance(ab.Person(), ab2.Person)
    assert isinstance(ab.Person(name="hello"), ab2.Person)

    assert isinstance(ab.PersonNotExistsError(), ab2.PersonNotExistsError)
Beispiel #3
0
def init_conn(ip, port):
    if not os.path.exists("weightsync.thrift"):
        f = _get_thrift_file()
        weightsync_thrift = thriftpy.load(f.name, module_name="weightsync_thrift")
        f.close()
    else:
        weightsync_thrift = thriftpy.load("weightsync.thrift", module_name="weightsync_thrift")
    client = make_client(weightsync_thrift.WeightSync, ip, port)
    return client
Beispiel #4
0
def init_sender(ip, port):
    if not os.path.exists("weightsync.thrift"):
        f = _get_thrift_file()
        weightsync_thrift = thriftpy.load(f.name, module_name="weightsync_thrift")
        f.close()
    else:
        weightsync_thrift = thriftpy.load("weightsync.thrift", module_name="weightsync_thrift")
    sender = make_client(weightsync_thrift.WeightForward, ip, port)
    return sender
Beispiel #5
0
def init_receiver(ip, port, requestHandler):
    if not os.path.exists("weightsync.thrift"):
        f = _get_thrift_file()
        weightsync_thrift = thriftpy.load(f.name, module_name="weightsync_thrift")
        f.close()
    else:
        weightsync_thrift = thriftpy.load("weightsync.thrift", module_name="weightsync_thrift")
    receiver = make_server(weightsync_thrift.WeightForward, requestHandler, ip, port)
    receiver.trans.client_timeout = None
    return receiver
Beispiel #6
0
def init_server(ip, port, requestHandler):
    if not os.path.exists("weightsync.thrift"):
        f = _get_thrift_file()
        weightsync_thrift = thriftpy.load(f.name,
                                          module_name="weightsync_thrift")
        f.close()
    else:
        weightsync_thrift = thriftpy.load("weightsync.thrift",
                                          module_name="weightsync_thrift")
    server = make_server(weightsync_thrift.WeightSync, requestHandler, ip,
                         port)
    return server
Beispiel #7
0
def test_load():
    ab_1 = thriftpy.load("addressbook.thrift")
    ab_2 = thriftpy.load("addressbook.thrift",
                         module_name="addressbook_thrift")

    assert ab_1.__name__ == "addressbook"
    assert ab_2.__name__ == "addressbook_thrift"

    # load without module_name can't do pickle
    with pytest.raises(pickle.PicklingError):
        pickle.dumps(ab_1.Person(name='Bob'))

    # load with module_name set and it can be pickled
    person = ab_2.Person(name='Bob')
    assert person == pickle.loads(pickle.dumps(person))
def main():
    print("Fetching status of local gdcv server...")
    gdcv_thrift = thriftpy.load('gdcv/if/gdcv.thrift',
                                module_name='gdcv_thrift')
    client = make_client(gdcv_thrift.FrcRealtimeScoringService, '127.0.0.1',
                         6000)

    print("{} v{} is {}, since {}".format(client.getName(),
                                          client.getVersion(),
                                          client.getStatus(),
                                          client.aliveSince()))

    metadataKey = "testKey"
    print("Testing metadata server... {}={}".format(
        metadataKey, client.getMetadataValue(metadataKey)))

    print("Testing Pub/Sub...")
    testMessage = "Hello World!"
    result = client.sendPubSubMessage(testMessage)
    print("Result from pubsub send: {}".format(result))
    result = client.getPubSubMessage()
    print("Got message {} through local Pub/Sub".format(result))

    print("Testing db...")
    testMessage = "Hello World!"
    client.clearAllTestMessages()
    result = client.insertTestRow(testMessage)
    print("All rows: {}".format(client.getAllTestMessages()))

    print("Testing frc-livescore...")
    print("Test image: {}".format(client.processTestImage()))
Beispiel #9
0
def ps_job(ps_id, cluster_spec, dim):
    signal.signal(signal.SIGINT, soft_exit)
    ping_thrift = thriftpy.load("ping.thrift", module_name="ping_thrift")
    handler = Dispatcher(dim)
    server = make_server(ping_thrift.PingService, handler, '127.0.0.1', 6000)
    print "start Server(%s:%d)" % ('127.0.0.1', 6000)
    server.serve()
Beispiel #10
0
    def setUp(self):
        test_thrift   = thriftpy.load("test.thrift", module_name="test_thrift")
        self._output_dict   = dict()
        self._thrift_struct = test_thrift.meta()
        self._thrift_struct.name = "abc"
        self._thrift_struct.num  = 128
        self._thrift_struct.desc = "for_lyj_test"
        self._thrift_struct.error_type = 1
        self._thrift_struct.simple_list = [1, 2, 3, 4]
        tmp_list = []
        for i in xrange(1,5):
            tmp = test_thrift.list_test()
            tmp.l_name = "l_name%d" % i
            tmp_list.append(tmp)
        self._thrift_struct.in_list = tmp_list
        tmp = test_thrift.in_meta()
        tmp.more = "more"
        self._thrift_struct.add_more = tmp
        
        tmp_map = dict()
        map_value = test_thrift.test_map_value()
        map_value.value = "abc"
        tmp_map["a"] = map_value
        map_value = test_thrift.test_map_value()
        map_value.value = "abc1"
        tmp_map["b"] = map_value
        self._thrift_struct.test_struct_map = tmp_map

        tmp_map = {"a": 1, "b": 2}
        self._thrift_struct.test_simple_map = tmp_map

        thrift_json_convertor(self._thrift_struct, self._output_dict)
Beispiel #11
0
def serve(thrift_filename,
          service_name,
          contract_filename,
          host="127.0.0.1",
          port=6000,
          protocol=Protocol.binary,
          transport=Transport.framed):
    # Loads both the AST and the thriftpy dynamically generated data
    ast = ptcdt.thrift_parser.MappedAST.from_file(thrift_filename)
    thriftpy_module = thriftpy.load(thrift_filename,
                                    module_name=service_name + "_thrift")
    contract = ptcdt.contracts.parse_contract(contract_filename)

    # Builds the delegate class which will have all the methods to handle the requests
    # The delegate will have the methods dynamically added into them, which actually point
    # to methods in a new instance of FunctionDelegate objects
    Delegate = build_delegate(
        _ServiceExecutionContext(ast, thriftpy_module, contract, service_name))

    # Builds the server and starts serving requests
    server = make_server(service=getattr(thriftpy_module, service_name),
                         handler=Delegate(),
                         host=host,
                         port=port,
                         proto_factory=_build_protocol_factory(protocol),
                         trans_factory=_build_transport_factory(transport))

    server.serve()
Beispiel #12
0
def cn_job(cn_id, cluster_spec, times):
    signal.signal(signal.SIGINT, soft_exit)
    ping_thrift = thriftpy.load("ping.thrift", module_name="ping_thrift")
    conn = make_client(ping_thrift.PingService, '127.0.0.1', 6000)
    for i in range(times):
        compute_pi(100000)
        conn.ping(cn_id)
Beispiel #13
0
def client(thrift, host, port, service):
    calc_thrift = thriftpy.load(str(thrift))
    with client_context(getattr(calc_thrift, service),
                        host,
                        port,
                        proto_factory=TCyBinaryProtocolFactory(),
                        trans_factory=TCyBufferedTransportFactory()) as client:
        IPython.embed(header="Call client.api(*args)")
Beispiel #14
0
def main():
    '''
    '''
    example_thrift = thriftpy.load("rpc_example.thrift",
                                   module_name="pp_thrift")

    with client_context(example_thrift.example, '127.0.0.1', 6000) as c:
        print c.ping()
Beispiel #15
0
def todo_thrift():
    return thriftpy.load(
        os.path.join(
            os.path.dirname(os.path.realpath(__file__)),
            "..",
            "example-thrifts",
            "todo.thrift",
        ))
    def __init__(self):
        if thriftpy._compat.CYTHON:
            self.NAME += '+cython'

        self.module = thriftpy.load(
            'specs/test.thrift',
            include_dirs=['specs'],
        )
Beispiel #17
0
def request_thrift(thrift_name, service, method, url, port, *args, **kwargs):
    ''' 通用的 simpled rpc client '''
    module_name = thrift_name.replace('.', '_')
    thrift_module = thriftpy.load(thrift_name, module_name=module_name)
    thrift_service = getattr(thrift_module, service)
    with client_context(thrift_service, url, port) as rt:
        res = getattr(rt, method)(*args, **kwargs)
        print(res)
 def __init__(self, api_key, host, port):
     self.api_key = api_key
     trade_thrift = thriftpy.load("traderpc.thrift",
                                  module_name="trade_thrift")
     self.client = make_client(trade_thrift.TradeRpcService,
                               host,
                               port,
                               timeout=5000)
Beispiel #19
0
def test_hashable():
    ab = thriftpy.load("addressbook.thrift")

    # exception is hashable
    hash(ab.PersonNotExistsError("test error"))

    # container struct is not hashable
    with pytest.raises(TypeError):
        hash(ab.Person(name="Tom"))
Beispiel #20
0
    def __init__(self, event_handler=EventChannelInterfaceHandler()):
        """Initialize the ThriftClient object."""
        self._event_channel = None
        self._event_channel_handler = event_handler

        _interface_file = os.path.join(
            os.path.dirname(os.path.abspath(__file__)), "interface.thrift")
        self.thrift_interface = thriftpy.load(_interface_file,
                                              module_name="zlaser_thrift")
Beispiel #21
0
    def connect(self, ip_addr, port, thrift_file_path):
        self.ui_thrift = thriftpy.load(thrift_file_path)
        self.THRIFT_SMS_FMAN_DATA = self.ui_thrift.THRIFT_SMS_FMAN_DATA
        self.THRIFT_MAP_IMAGE = self.ui_thrift.THRIFT_MAP_IMAGE
        self.THRIFT_SENSOR_DATA = self.ui_thrift.THRIFT_SENSOR_DATA
        self.THRIFT_IPLIMAGE = self.ui_thrift.THRIFT_IPLIMAGE
        self.THRIFT_QIMAGE = self.ui_thrift.THRIFT_QIMAGE

        self.client = make_client(self.ui_thrift.Control, ip_addr, port)
Beispiel #22
0
def _load_thrifts(thrift_directory):
    thrifts = {}
    thrift_paths = {}
    search_path = os.path.join(thrift_directory, "**/*thrift")
    for thrift_path in glob.iglob(search_path, recursive=True):
        thrift_filename = os.path.basename(thrift_path)
        thrifts[thrift_filename] = thriftpy.load(thrift_path)
        thrift_paths[thrift_filename] = thrift_path
    return thrifts, thrift_paths
Beispiel #23
0
def _start_thrift_service():
    import thriftpy
    tutor_thrift = thriftpy.load('thriftfiles/tutor.thrift', 'tutor_thrift',
                                 include_dirs=['thriftfiles'])
    tutor_urge_thrift = thriftpy.load('thriftfiles/tutor_urge.thrift',
                                      'tutor_urge_thrift',
                                      include_dirs=['thriftfiles'])

    from etutorservice.services.season import SeasonService
    from etutorservice.services.period import PeriodService
    from etutorservice.services.class_template import ClassTemplateService
    from etutorservice.services.coach import CoachService
    from etutorservice.services.student import StudentService
    from etutorservice.services.quota import QuotaService
    from etutorservice.services.tutor_client import TutorClientService
    from etutorservice.services.class_admin import ClassAdminService
    from etutorservice.services.class_service import ClassService
    from etutorservice.services.coach_client import CoachClientService
    from etutorservice.services.monitor import MonitorService
    from etutorservice.services.urge_class import UrgeClassService
    from etutorservice.services.sms_code import SmsCodeService
    from etutorservice.services.experience_center import ExperienceService
    from etutorservice.services.payment import PaymentService

    thrift_config = config.data['thrift_service']['tutor']
    server = create_multiplexed_server(
        [
            (tutor_thrift.SeasonService, SeasonService(), 'season_service'),
            (tutor_thrift.PeriodService, PeriodService(), 'period_service'),
            (tutor_thrift.ClassTemplateService, ClassTemplateService(), 'class_template_service'),
            (tutor_thrift.CoachService, CoachService(), 'coach_service'),
            (tutor_thrift.StudentService, StudentService(), 'student_service'),
            (tutor_thrift.ClassAdminService, ClassAdminService(), 'class_admin_service'),
            (tutor_thrift.ClassService, ClassService(), 'class_service'),
            (tutor_thrift.QuotaService, QuotaService(), 'quota_service'),
            (tutor_thrift.TutorClientService, TutorClientService(), 'tutor_client_service'),
            (tutor_thrift.CoachClientService, CoachClientService(), 'coach_client_service'),
            (tutor_thrift.MonitorService, MonitorService(), 'monitor_service'),
            (tutor_thrift.SmsCodeService, SmsCodeService(), 'sms_code_service'),
            (tutor_thrift.PaymentService, PaymentService(), 'payment_service'),
            (tutor_urge_thrift.UrgeClassService, UrgeClassService(), 'urge_class_service'),
            (tutor_thrift.ExperienceService, ExperienceService(), 'experience_service'),
        ], thrift_config)
    server.serve()
Beispiel #24
0
def request_thrift(thrift_name,service, method, url, port, *args, **kwargs):
    ''' 通用的 multiplexed '''
    module_name = thrift_name.replace('.', '_')
    thrift_module = thriftpy.load(thrift_name, module_name=module_name)
    thrift_service = getattr(thrift_module, service)
    binary_factory = TBinaryProtocolFactory()
    thrift_factory = TMultiplexedProtocolFactory(binary_factory, module_name)
    with client_context(thrift_service, url, port, proto_factory=thrift_factory) as rt:
        res = getattr(rt, method)(*args, **kwargs)
        print(res)
Beispiel #25
0
 def __init__(self):
     super(ThriftLocust, self).__init__()
     socket = TSocket('127.0.0.1', 9999)
     proto_factory = TBinaryProtocolFactory()
     trans_factory = TBufferedTransportFactory()
     transport = trans_factory.get_transport(socket)
     protocol = proto_factory.get_protocol(transport)
     transport.open()
     hash_thrift = thriftpy.load("hash.thrift", module_name="hash_thrift")
     self.client = ThriftClient(hash_thrift.HashService, protocol)
Beispiel #26
0
    def put(self, *args, **kwargs):
        self.project = make_client(
            thriftpy.load(pjoin(protocols, "project.thrift"),
                          module_name="project_thrift").ProjectHandle,
            port=6000)

        # program = kwargs.get("program")
        body = json.loads(self.request.body)
        self.write(self.project.update_project(json.dumps(body)))
        self.project.close()
def pingpong_thrift_service(request, pingpong_service_key):
    import thriftpy
    thrift_service = thriftpy.load(
        os.path.join(
            os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
            "examples/pingpong_app/pingpong.thrift"), "pingpong_thrift")
    service = thrift_service.PingService
    service.AboutToShutDownException = \
        thrift_service.AboutToShutDownException
    return service
Beispiel #28
0
def load_thrift(grammar_file=None):

    """
    Loads and compiles an Apache Thrift file into a module.
    :param grammar_file: The file path to the Apache Thrift file.
    :return: The compiled module.
    """

    import os

    return thriftpy.load(grammar_file, module_name=os.path.splitext(os.path.basename(grammar_file))[0] + '_thrift')
Beispiel #29
0
def main():
    host            = '127.0.0.1' if len(sys.argv) < 2 else sys.argv[1]
    port            = 9090 if len(sys.argv) < 3 else int(sys.argv[2])
    uniqueid_thrift = thriftpy.load('../protocol/uniqueid.thrift', module_name='uniqueid_thrift')
    client          = make_client(uniqueid_thrift.Uniqueid, host, port)
    request         = uniqueid_thrift.UniqueidRequest()
    request.logid   = random.randint(-2147483648, 2147483647)
    request.serial  = random.randint(0, 9)
    request.length  = random.randint(1, 10)
    response        = client.uniqueid(request)
    print(response)
Beispiel #30
0
    def post(self, *args, **kwargs):
        self.project = make_client(
            thriftpy.load(pjoin(protocols, "project.thrift"),
                          module_name="project_thrift").ProjectHandle,
            port=6000)

        self.write(
            self.project.do_actions(
                json.dumps(
                    dict(programs=self.get_argument("programs", []),
                         actions=self.get_argument("actions", [])))))
        self.project.close()
Beispiel #31
0
    def delete(self, *args, **kwargs):
        self.project = make_client(
            thriftpy.load(pjoin(protocols, "project.thrift"),
                          module_name="project_thrift").ProjectHandle,
            port=6000)

        if __debug__:
            print self.request.body

        body = json.loads(self.request.body)
        self.write(
            self.project.remove_projects(json.dumps(body.get("programs", []))))
        self.project.close()
Beispiel #32
0
class SpotifakeServerLibraryHandler(LibraryService.Iface):

    connection: SqlServerLibraryManagement = SqlServerLibraryManagement()
    spotifakeManagement_thrift = thriftpy.load(
        '../Thrift/SpotifakeManagement.thrift',
        module_name='spotifakeManagement_thrift')
    spotifakeServices_thrift = thriftpy.load(
        '../Thrift/SpotifakeServices.thrift',
        module_name='spotifakeServices_thrift')
    Library = spotifakeManagement_thrift.Library

    def __init__(self):
        pass

    def getLibraryByIdConsumer(self, idConsumer):
        idLibrary = SqlServerLibraryManagement.GetLibraryByIdConsumer(
            self, idConsumer)
        return idLibrary

    def AddLibrary(self, idConsumer):
        idLibrary = SqlServerLibraryManagement.AddLibrary(self, idConsumer)
        return True
Beispiel #33
0
def test_delegate_simple_param_return():
    filename = utils.test_resource_path("thrifts/echo.thrift")
    ast = MappedAST.from_file(filename)
    thriftpy_module = thriftpy.load(filename, module_name="echo_thrift")

    contract = Contract(Provider("provider"), Consumer("consumer"), [
        Interaction("provider state", "description", "Echo",
                    Request("echo", ["hello"]), Response("hello"))
    ])

    Delegate = build_delegate(
        ptcdt.server._ServiceExecutionContext(ast, thriftpy_module, contract,
                                              "Echo"))
    assert Delegate().echo("hello") == "hello"
Beispiel #34
0
def test_parse_spec():
    ab = thriftpy.load("addressbook.thrift")

    cases = [
        ((TType.I32, None), "I32"),
        ((TType.STRUCT, ab.PhoneNumber), "PhoneNumber"),
        ((TType.LIST, TType.I32), "LIST<I32>"),
        ((TType.LIST, (TType.STRUCT, ab.PhoneNumber)), "LIST<PhoneNumber>"),
        ((TType.MAP, (TType.STRING, (
            TType.LIST, (TType.MAP, (TType.STRING, TType.STRING))))),
         "MAP<STRING, LIST<MAP<STRING, STRING>>>")
    ]

    for spec, res in cases:
        assert parse_spec(*spec) == res
Beispiel #35
0
def test_import_hook():
    ab_1 = thriftpy.load("addressbook.thrift")
    print("Load file succeed.")
    assert ab_1.DEFAULT_LIST_SIZE == 10

    try:
        import addressbook_thrift as ab  # noqa
    except ImportError:
        print("Import hook not installed.")

    thriftpy.install_import_hook()

    import addressbook_thrift as ab_2
    print("Magic import succeed.")
    assert ab_2.DEFAULT_LIST_SIZE == 10
Beispiel #36
0
def pingpong_thrift_service(request, pingpong_service_key):
    import thriftpy
    thrift_service = thriftpy.load(
        os.path.join(
            os.path.dirname(
                os.path.dirname(
                    os.path.dirname(__file__)
                    )
                ),
            "examples/pingpong_app/pingpong.thrift"),
        "pingpong_thrift")
    service = thrift_service.PingService
    service.AboutToShutDownException = \
        thrift_service.AboutToShutDownException
    return service
    def setUp(self):
        self._input_json = '{ \
            "name": "abc", \
            "num": 128, \
            "desc": "for_lyj_test", \
            "simple_list": [1,2,3,4], \
            "add_more": {"more": "more"}, \
            "in_list": [{"l_name": "l_name1"}, {"l_name": "l_name2"}, {"l_name": "l_name3"}], \
            "error_type": "SUCCESS", \
            "test_struct_map" : {\
                "a": {"value": "abc"}, \
                "b": {"value": "abc1"} \
            }, \
            "test_simple_map" : {"a": 1, "b": 2} \
        }'

        test_thrift        = thriftpy.load("test.thrift", module_name="test_thrift")
        self._json_struct   = json.loads(self._input_json)
        self._thrift_struct = test_thrift.meta()
        json_thrift_convertor(self._json_struct, self._thrift_struct)
Beispiel #38
0
def _load_thrift():
    """Load the Scribe Thrift specification.

    The Thrift files we have are borrowed from the facebook-scribe repository here:
    https://github.com/tomprimozic/scribe-python

    As Scribe is now abandoned (per https://github.com/facebookarchive/scribe),
    it's highly unlikely that the scribe format will ever change.
    """
    # In the event that pkg_resources has to extract the thrift files from e.g.
    # a zip file to some temporary place, this asks it to clean them up
    atexit.register(pkg_resources.cleanup_resources)

    # Call this and discard the return value, just to ensure that this file is
    # available on the filesystem; it's included by scribe.thrift
    pkg_resources.resource_filename('clog', 'fb303.thrift')

    path = pkg_resources.resource_filename('clog', 'scribe.thrift')
    include_dir, fn = os.path.split(path)
    return thriftpy.load(
        fn, module_name='scribe_thrift', include_dirs=[include_dir])
Beispiel #39
0
    from impala._thrift_gen.beeswax import BeeswaxService
    from impala._thrift_gen.ImpalaService import ImpalaService
    from impala._thrift_gen.Status.ttypes import TStatus, TStatusCode
    from impala._thrift_gen.ExecStats.ttypes import TExecStats
    from impala._thrift_gen.beeswax.BeeswaxService import QueryState
    ThriftClient = ImpalaService.Client


if six.PY3:
    # import thriftpy code
    from thriftpy import load
    from thriftpy.thrift import TClient, TApplicationException

    # dynamically load the beeswax modules
    from impala._thrift_api import thrift_dir
    ExecStats = load(os.path.join(thrift_dir, 'ExecStats.thrift'),
                     include_dirs=[thrift_dir])
    Status = load(os.path.join(thrift_dir, 'Status.thrift'),
                  include_dirs=[thrift_dir])
    ImpalaService = load(os.path.join(thrift_dir, 'ImpalaService.thrift'),
                         include_dirs=[thrift_dir])
    beeswax = load(os.path.join(thrift_dir, 'beeswax.thrift'),
                   include_dirs=[thrift_dir])
    sys.modules[ExecStats.__name__] = ExecStats
    sys.modules[Status.__name__] = Status
    sys.modules[ImpalaService.__name__] = ImpalaService
    sys.modules[beeswax.__name__] = beeswax

    # import the beeswax objects
    from ExecStats import TExecStats
    from Status import TStatus, TStatusCode
    from ImpalaService import ImpalaService
Beispiel #40
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-

__author__ = 'Jack River'

import warnings
import json
import os
import thriftpy
from thrift_connector import ClientPool, ThriftPyCyClient

_thrift_file = thriftpy.load(
    os.path.join(os.path.dirname(os.path.realpath(__file__)), 'hermes.thrift')
)

HermesSystemException = _thrift_file.HermesSystemException
HermesUserException = _thrift_file.HermesUserException
HermesUnknownException = _thrift_file.HermesUnknownException

HermesErrorCode = _thrift_file.HermesErrorCode


def deprecated(func):
    """This is a decorator which can be used to mark functions
    as deprecated. It will result in a warning being emitted
    when the function is used."""
    def new_func(*args, **kwargs):
        warnings.warn("Call to deprecated function {}.".format(func.__name__),
                      category=DeprecationWarning)
        return func(*args, **kwargs)
    new_func.__name__ = func.__name__
Beispiel #41
0
if six.PY3:
    # import thriftpy code
    from thriftpy import load
    from thriftpy.thrift import TClient
    # TODO: reenable cython
    # from thriftpy.protocol import TBinaryProtocol
    from thriftpy.protocol.binary import TBinaryProtocol  # noqa
    from thriftpy.transport import TSocket, TTransportException  # noqa
    # TODO: reenable cython
    # from thriftpy.transport import TBufferedTransport
    from thriftpy.transport.buffered import TBufferedTransport  # noqa
    thrift_dir = os.path.join(os.path.dirname(__file__), 'thrift')

    # dynamically load the HS2 modules
    ExecStats = load(os.path.join(thrift_dir, 'ExecStats.thrift'),
                     include_dirs=[thrift_dir])
    TCLIService = load(os.path.join(thrift_dir, 'TCLIService.thrift'),
                       include_dirs=[thrift_dir])
    ImpalaService = load(os.path.join(thrift_dir, 'ImpalaService.thrift'),
                         include_dirs=[thrift_dir])
    sys.modules[ExecStats.__name__] = ExecStats
    sys.modules[TCLIService.__name__] = TCLIService
    sys.modules[ImpalaService.__name__] = ImpalaService

    # import the HS2 objects
    from TCLIService import (  # noqa
        TOpenSessionReq, TFetchResultsReq, TCloseSessionReq,
        TExecuteStatementReq, TGetInfoReq, TGetInfoType, TTypeId,
        TFetchOrientation, TGetResultSetMetadataReq, TStatusCode,
        TGetColumnsReq, TGetSchemasReq, TGetTablesReq, TGetFunctionsReq,
        TGetOperationStatusReq, TOperationState, TCancelOperationReq,
# -*- coding: utf-8 -*-

import thriftpy
from thriftpy.protocol import TBinaryProtocolFactory
from thriftpy.server import TThreadedServer
from thriftpy.thrift import TProcessor, TMultiplexedProcessor
from thriftpy.transport import TBufferedTransportFactory, TServerSocket


dd_thrift = thriftpy.load("dingdong.thrift", module_name="dd_thrift")
pp_thrift = thriftpy.load("pingpong.thrift", module_name="pp_thrift")

DD_SERVICE_NAME = "dd_thrift"
PP_SERVICE_NAME = "pp_thrift"


class DingDispatcher(object):
    def ding(self):
        print("ding dong!")
        return 'dong'


class PingDispatcher(object):
    def ping(self):
        print("ping pong!")
        return 'pong'


def main():
    dd_proc = TProcessor(dd_thrift.DingService, DingDispatcher())
    pp_proc = TProcessor(pp_thrift.PingService, PingDispatcher())
Beispiel #43
0
import thriftpy
import os.path
import thriftpy

thrift_file = os.path.join(os.path.dirname(__file__), "lang.thrift")
lang_thrift = thriftpy.load(thrift_file, module_name="lang_thrift")
 def __init__(self, address, port=9196):
     thrift = load(resource_filename(__name__, "static/yaoguang.thrift"), module_name="yaoguang_thrift")
     self._client = make_client(thrift.ThriftInterface, address, port)
Beispiel #45
0
import thriftpy
pingpong_thrift = thriftpy.load("pingpong.thrift", module_name="pingpong_thrift")

from thriftpy.rpc import make_client

client = make_client(pingpong_thrift.PingPong, '127.0.0.1', 6000)
client.ping()
Beispiel #46
0
from __future__ import absolute_import

import os
import thriftpy

cassandra_thrift = thriftpy.load(os.path.join(os.path.dirname(os.path.realpath(__file__)), "cassandra-v20.thrift"), module_name="cassandra_thrift")
from os import path
from unittest import TestCase

from tornado import ioloop

import thriftpy
from thriftpy.tornado import make_server
from thriftpy.rpc import make_client
from thriftpy.transport.framed import TFramedTransportFactory
from thriftpy.protocol.binary import TBinaryProtocolFactory

from thriftpy._compat import CYTHON
logging.basicConfig(level=logging.INFO)

addressbook = thriftpy.load(path.join(path.dirname(__file__),
                                      "addressbook.thrift"))


class Dispatcher(object):
    def __init__(self, io_loop):
        self.io_loop = io_loop
        self.registry = {}

    def add(self, person):
        """
        bool add(1: Person person);
        """
        if person.name in self.registry:
            return False
        self.registry[person.name] = person
        return True
# -*- coding: utf-8 -*-
import os
import socket
import struct

import thriftpy
import ipaddress
from thriftpy.transport import TMemoryBuffer
from thriftpy.protocol.binary import TBinaryProtocol

thrift_filepath = os.path.join(os.path.dirname(__file__),
                               'zipkinCore.thrift')
zipkin_core = thriftpy.load(thrift_filepath, module_name="zipkinCore_thrift")



def create_annotation(timestamp, value, host):
    """
    Create a zipkin annotation object

    :param timestamp: timestamp of when the annotation occured in microseconds
    :param value: name of the annotation
    :param host: zipkin endpoint object

    :returns: zipkin annotation object
    """
    return zipkin_core.Annotation(timestamp=timestamp, value=value, host=host)


def create_binary_annotation(key, value, annotation_type, host):
    """
Beispiel #49
0
from sys import argv
from uuid import uuid4
from multiprocessing import Process, Value
from thriftpy import load
from thriftpy.rpc import make_client
from thriftpy.transport import TFramedTransportFactory
echo_thrift = load("/app/sh/echo.thrift", module_name="echo_thrift")


def handleClient(num, actual):
    # Open independent client connection
    client = make_client(service=echo_thrift.Echo, host='127.0.0.1',
                         port=9999, trans_factory=TFramedTransportFactory())

    # UUID
    uid = str(uuid4())

    for i in range(num):
        # Make thrift call and increment atomic count
        txt = uid + str(i)
        ret = client.echo(echo_thrift.Message(text=txt))
        if (txt == ret):
            with actual.get_lock():
                actual.value += 1


# Parse command line arguments
# Number of requests each client will make
num = int(argv[1])

# Number of concurrent clients to run
Beispiel #50
0
def test_init_func():
    thriftpy.load("addressbook.thrift")
    assert linecache.getline('<generated PhoneNumber.__init__>', 1) != ''
import time

import thriftpy

play_thrift = thriftpy.load("play.thrift", module_name="play_thrift")

#from thriftpy.rpc import make_server

from thriftpy.tornado import make_server
from thriftpy.tornado import make_client
from tornado import ioloop


class PlayHandler(object):
    def __init__(self):
        self._count = 0
        self._st_time = time.time()

    def ping(self):
        self._count += 1
        if self._count % 10000 == 0:
            right_now = time.time()
            print self._count / (right_now - self._st_time)
            self._st_time = right_now
            self._count = 0

        #print "ping!"
        return 123

Beispiel #52
0
import time

import pytest

import thriftpy
from thriftpy.protocol import (
    TBinaryProtocolFactory,
    TMultiplexedProtocolFactory
)
from thriftpy.rpc import client_context
from thriftpy.server import TThreadedServer
from thriftpy.thrift import TProcessor, TMultiplexedProcessor
from thriftpy.transport import TBufferedTransportFactory, TServerSocket


mux = thriftpy.load(os.path.join(os.path.dirname(__file__),
                                 "multiplexed.thrift"))
sock_path = "./thriftpy_test.sock"


class DispatcherOne(object):
    def doThingOne(self):
        return True


class DispatcherTwo(object):
    def doThingTwo(self):
        return True


@pytest.fixture(scope="module")
def server(request):
Beispiel #53
0
# coding: utf-8

import os
import thriftpy
import json
import logging

from thriftpy.rpc import make_client

LIMIT = 1000

logger = logging.getLogger(__name__)


articlemeta_thrift = thriftpy.load(
    os.path.join(os.path.dirname(__file__)) + '/articlemeta.thrift')


class ServerError(Exception):
    def __init__(self, message=None):
        self.message = message or 'thirftclient: ServerError'

    def __str__(self):
        return repr(self.message)


class ArticleMeta(object):

    def __init__(self, address, port):
        """
        Cliente thrift para o Articlemeta.
Beispiel #54
0
# coding: utf-8
import os
import thriftpy
import json
import logging

from thriftpy.rpc import make_client
from xylose.scielodocument import Article, Journal

LIMIT = 1000

logger = logging.getLogger(__name__)

ratchet_thrift = thriftpy.load(
    os.path.join(os.path.dirname(__file__))+'/ratchet.thrift')

articlemeta_thrift = thriftpy.load(
    os.path.join(os.path.dirname(__file__))+'/articlemeta.thrift')

citedby_thrift = thriftpy.load(
    os.path.join(os.path.dirname(__file__))+'/citedby.thrift')

accessstats_thrift = thriftpy.load(
    os.path.join(os.path.dirname(__file__))+'/access_stats.thrift')

publication_stats_thrift = thriftpy.load(
    os.path.join(os.path.dirname(__file__))+'/publication_stats.thrift')

class ServerError(Exception):
    def __init__(self, message=None):
        self.message = message or 'thirftclient: ServerError'
# coding=utf-8
import os

import thriftpy
from thriftpy.rpc import client_context
from thriftpy.protocol import TBinaryProtocolFactory
from thriftpy.transport import TBufferedTransportFactory

HERE = os.path.abspath(os.path.dirname(__file__))

calc_thrift = thriftpy.load(
    os.path.join(HERE, 'calc.thrift'),
    module_name='calc_thrift')

with client_context(calc_thrift.CalcService,
                    '127.0.0.1', 8300,
                    proto_factory=TBinaryProtocolFactory(),
                    trans_factory=TBufferedTransportFactory(),
                    timeout=None) as calc:
    rs = calc.add(1, 2)
    print 'Result is: {}'.format(rs)