Exemple #1
0
 def read(self, iprot):
   if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and TBinaryProtocol is not None:
     TBinaryProtocol.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
     return
   iprot.readStructBegin()
   while True:
     (fname, ftype, fid) = iprot.readFieldBegin()
     if ftype == TType.STOP:
       break
     if fid == 0:
       if ftype == TType.I32:
         self.success = iprot.readI32();
       else:
         iprot.skip(ftype)
     else:
       iprot.skip(ftype)
     iprot.readFieldEnd()
   iprot.readStructEnd()
Exemple #2
0
 def write(self, oprot):
   if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and TBinaryProtocol is not None:
     oprot.trans.write(TBinaryProtocol.encode_binary(self, (self.__class__, self.thrift_spec)))
     return
   oprot.writeStructBegin('add_result')
   if self.success is not None:
     oprot.writeFieldBegin('success', TType.I32, 0)
     oprot.writeI32(self.success)
     oprot.writeFieldEnd()
   oprot.writeFieldStop()
   oprot.writeStructEnd()
Exemple #3
0
 def write(self, oprot):
   if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and TBinaryProtocol is not None:
     oprot.trans.write(TBinaryProtocol.encode_binary(self, (self.__class__, self.thrift_spec)))
     return
   oprot.writeStructBegin('add_args')
   if self.a is not None:
     oprot.writeFieldBegin('a', TType.I32, 1)
     oprot.writeI32(self.a)
     oprot.writeFieldEnd()
   if self.b is not None:
     oprot.writeFieldBegin('b', TType.I32, 2)
     oprot.writeI32(self.b)
     oprot.writeFieldEnd()
   oprot.writeFieldStop()
   oprot.writeStructEnd()
Exemple #4
0
 def write_it(stream):
     transportOut = TMemoryBuffer()
     protocolOut = TBinaryProtocol.TBinaryProtocol(transportOut)
     topology.write(protocolOut)
     bytes = transportOut.getvalue()
     stream.write(bytes)
def get_binary_protocol(transport):
    return TBinaryProtocol.TBinaryProtocol(transport)
Exemple #6
0
from thrift.protocol import TBinaryProtocol

try:
    # Read Airavata Client properties
    airavataConfig = ConfigParser.RawConfigParser()
    airavataConfig.read('../conf/airavata-client.properties')

    # Create a socket to the Airavata Server
    transport = TSocket.TSocket(airavataConfig.get('AiravataServer', 'host'),
                                airavataConfig.get('AiravataServer', 'port'))

    # Use Buffered Protocol to speedup over raw sockets
    transport = TTransport.TBufferedTransport(transport)

    # Airavata currently uses Binary Protocol
    protocol = TBinaryProtocol.TBinaryProtocol(transport)

    # Create a Airavata client to use the protocol encoder
    airavataClient = Airavata.Client(protocol)

    # Connect to Airavata Server
    transport.open()

    computeResourceNames = airavataClient.getAllComputeResourceNames()

    print computeResourceNames

    # Close Connection to Airavata Server
    transport.close()

except Thrift.TException, tx:
Exemple #7
0
 def _create_connection(self):
     self.transport = TTransport.TBufferedTransport(TFramedTransport(TSocket.TSocket(self.host, self.port)))
     self.protocol = TBinaryProtocol.TBinaryProtocolAccelerated(self.transport)
     self.client = Hbase.Client(self.protocol)
     self.transport.open()
 def factory(transport):
     protocol = TBinaryProtocol.TBinaryProtocol(transport)
     multiplex_prot = TMultiplexedProtocol(protocol, cls.service_name)
     return multiplex_prot
 def __init__(self):
     self.transport = TSocket.TSocket('127.0.0.1', 7748)
     self.transport = TTransport.TBufferedTransport(self.transport)
     self.protocol = TBinaryProtocol.TBinaryProtocol(self.transport)
     self.client = Ping.Client(self.protocol)
     self.transport.open()
Exemple #10
0
sys.path.append('/usr/lib/python2.6/site-packages/')

from conf_crawler import DownloaderService
from conf_crawler import DCService
from conf_crawler.ttypes import *

from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from thrift.transport.TTransport import TFramedTransport

transport = TSocket.TSocket('localhost', 44002)
framed_transport = TFramedTransport(transport)
framed_transport.open()
protocol = TBinaryProtocol.TBinaryProtocol(framed_transport)

client = DCService.Client(protocol)


def PushDownloadTask():
    try:
        url = 'http://www.coo8.com/interfaces/showReviewsByGoodsId.action<%param%>flag=all&goodsId=P145484&pageIndex=1'
        referer = "http://www.coo8.com/product/145484.html"
        download_task = DownloadTask()
        download_task.req_item = DownloadReqItem()
        download_task.req_item.url = url
        download_task.req_item.referer = referer
        download_task.req_item.time_out = 1000
        download_task.prop_item = DownloadPropItem()
        download_task.prop_item.is_friendly = True
Exemple #11
0
def get_client(host, port):
    trans = TSocket.TSocket(host, port)
    trans = TTransport.TBufferedTransport(trans)
    proto = TBinaryProtocol.TBinaryProtocolAccelerated(trans)
    client = KnnThriftService.Client(proto)
    return client, trans
Exemple #12
0
def correlate_dfe(data, size_timeseries, num_timeseries, correlations):
    """Calculates correlations on DFE."""
    start_time = time.time()

    # Make socket
    socket = TSocket.TSocket('localhost', 9090)

    # Buffering is critical. Raw sockets are very slow
    transport = TTransport.TBufferedTransport(socket)

    # Wrap in a protocol
    protocol = TBinaryProtocol.TBinaryProtocol(transport)

    # Create a client to use the protocol encoder
    client = correlationService.Client(protocol)

    current_time = time.time() - start_time
    print 'Creating a client:\t\t\t\t%.5lfs' % current_time

    try:
        # Connect!
        start_time = time.time()
        transport.open()
        current_time = time.time() - start_time
        print 'Opening connection:\t\t\t\t%.5lfs' % current_time

        num_timesteps = size_timeseries
        window_size = size_timeseries
        num_bursts = calc_num_bursts(num_timeseries)

        # Get loop length
        start_time = time.time()
        loop_length = client.correlation_get_CorrelationKernel_loopLength()
        current_time = time.time() - start_time
        print 'Getting Correlation Kernel loopLength:\t\t%.5lfs' % current_time

        # Prepare data for DFE
        start_time = time.time()

        burst_size = 384 / 2  # for anything other than ISCA this should be 384
        in_mem_load = [0] * (num_bursts * burst_size)

        precalculations, data_pairs = prepare_data_for_dfe(
            data, size_timeseries, num_timeseries)

        current_time = time.time() - start_time
        print 'Data reordering time:\t\t\t\t%.5lfs' % current_time

        # Allocate and send input streams to server
        start_time = time.time()
        loop_length_size = 1
        address_loop_length = client.malloc_int32_t(loop_length_size)
        client.send_data_int32_t(address_loop_length, [loop_length])
        loop_length_time = time.time() - start_time
        print('\tSending LoopLength:\t\t(size = %d bit)\t\t%.5lfs' %
              (32 * loop_length_size, loop_length_time))

        start_time = time.time()
        in_mem_load_size = num_bursts * burst_size
        address_in_mem_load = client.malloc_int32_t(in_mem_load_size)
        client.send_data_int32_t(address_in_mem_load, in_mem_load)
        in_mem_load_time = time.time() - start_time
        print('\tSending InMemLoad:\t\t(size = %d bit)\t%.5lfs' %
              (32 * in_mem_load_size, in_mem_load_time))

        start_time = time.time()
        precalculations_size = 2 * num_timeseries * num_timesteps
        address_precalculations = client.malloc_double(precalculations_size)
        client.send_data_double(address_precalculations, precalculations)
        precalculations_time = time.time() - start_time
        print('\tSending Precalculations:\t(size = %d bit)\t%.5lfs' %
              (64 * precalculations_size, precalculations_time))

        start_time = time.time()
        data_pairs_size = 2 * num_timeseries * num_timesteps
        address_data_pairs = client.malloc_double(data_pairs_size)
        client.send_data_double(address_data_pairs, data_pairs)
        data_pairs_time = time.time() - start_time
        print('\tSending DataPairs:\t\t(size = %d bit)\t%.5lfs' %
              (64 * data_pairs_size, data_pairs_time))

        current_time = (loop_length_time + in_mem_load_time +
                        precalculations_time + data_pairs_time)
        speed = ((32 * loop_length_size + 32 * in_mem_load_size +
                  64 * precalculations_size + 64 * data_pairs_size) /
                 (current_time * 1000000))
        print(
            'Sending input streams to server total time:\t%.5lfs' %
            current_time + '\t(average speed = %.5lfMb/s)' % (speed))

        # Allocate memory for output stream on server
        start_time = time.time()
        out_correlation_size = (num_timesteps * CORRELATION_NUM_TOP_SCORES *
                                CORRELATION_NUM_PIPES * loop_length +
                                num_bursts * 24
                                )  # for anything other than ISCA
        # 48 should be instead of 24
        address_out_correlation = client.malloc_double(out_correlation_size)
        out_indices_size = (2 * num_timesteps * loop_length *
                            CORRELATION_NUM_TOP_SCORES * CORRELATION_NUM_PIPES)
        address_out_indices = client.malloc_int32_t(out_indices_size)
        current_time = time.time() - start_time
        print('Allocating memory for output stream on server:\t%.5lfs' %
              current_time)

        # Initialize LMem
        start_time = time.time()
        client.correlation_loadLMem(num_bursts, address_loop_length,
                                    address_in_mem_load)
        current_time = time.time() - start_time
        print 'LMem initialization:\t\t\t\t%.5lfs' % current_time

        # Executing correlation action
        start_time = time.time()
        client.correlation(
            num_bursts,  # scalar input
            num_timesteps,  # scalar input
            num_timeseries,  # scalar input
            1,  # scalar input
            float(window_size),  # scalar input
            address_precalculations,  # streaming reordered input
            address_data_pairs,  # streaming reordered input
            address_out_correlation,  # streaming unordered output
            address_out_indices)  # streaming unordered output
        current_time = time.time() - start_time
        print 'Correlation time:\t\t\t\t%.5lfs' % current_time

        # Get output stream from server
        start_time = time.time()
        out_correlation = client.receive_data_double(address_out_correlation,
                                                     out_correlation_size)
        out_correlation_time = time.time() - start_time
        print('\tGet output stream Correlation:\t(size = %d bit)\t%.5lfs' %
              (64 * out_correlation_size, out_correlation_time))

        start_time = time.time()
        _ = client.receive_data_int32_t(address_out_indices, out_indices_size)
        out_indices_time = time.time() - start_time
        print('\tGet output stream outIndices:\t(size = %d bit)\t%.5lfs' %
              (32 * out_indices_size, out_indices_time))

        start_time = time.time()
        loop_length_size = 1
        loop_length = client.receive_data_int32_t(address_loop_length,
                                                  loop_length_size)
        loop_length_time = time.time() - start_time
        print('\tGet output stream loopLength:\t(size = %d bit)\t\t%.5lfs' %
              (32 * loop_length_size, loop_length_time))

        current_time = (out_indices_time + out_correlation_time +
                        loop_length_time)
        speed = ((32 * loop_length_size + 32 * out_indices_time +
                  64 * out_correlation_size) / (current_time * 1000000))
        print(
            'Getting output stream from server total time:\t%.5lfs' %
            current_time + '\t(average speed = %.5lfMb/s)' % (speed))

        # Free allocated memory for streams on server
        start_time = time.time()
        client.free(address_loop_length)
        client.free(address_in_mem_load)
        client.free(address_precalculations)
        client.free(address_data_pairs)
        client.free(address_out_correlation)
        client.free(address_out_indices)
        current_time = time.time() - start_time
        print('Freeing allocated memory for streams on server:\t%.5lfs' %
              current_time)

        # Close!
        start_time = time.time()
        transport.close()
        current_time = time.time() - start_time
        print 'Closing connection:\t\t\t\t%.5lfs' % current_time

        # Store data
        start_time = time.time()

        position = 0
        index = 0
        start = ((num_timesteps - 1) * loop_length[0] *
                 CORRELATION_NUM_TOP_SCORES * CORRELATION_NUM_PIPES)

        for i in range(num_timeseries):
            for j in range(i):
                correlations[index + j] = out_correlation[start + position + j]
            index += i
            position += ((i / 12) + 1) * 12

        current_time = time.time() - start_time
        print 'Storing time:\t\t\t\t\t%.5lfs' % current_time

    except Thrift.TException, thrift_exception:
        print '%s' % (thrift_exception.message)
        sys.exit(-1)
def simple_dfe(size, data_in):
    """Simple DFE implementation."""
    try:
        start_time = time.time()

        # Make socket
        socket = TSocket.TSocket('localhost', 9090)

        # Buffering is critical. Raw sockets are very slow
        transport = TTransport.TBufferedTransport(socket)

        # Wrap in a protocol
        protocol = TBinaryProtocol.TBinaryProtocol(transport)

        # Create a client to use the protocol encoder
        client = SimpleService.Client(protocol)
        print('Creating a client:\t\t\t\t%.5lfs' % (time.time() - start_time))

        # Connect!
        start_time = time.time()
        transport.open()
        print('Opening connection:\t\t\t\t%.5lfs' % (time.time() - start_time))

        size_bytes = size * 4

        # Initialize maxfile
        start_time = time.time()
        max_file = client.Simple_init()
        print('Initializing maxfile:\t\t\t\t%.5lfs' %
              (time.time() - start_time))

        # Load DFE
        start_time = time.time()
        max_engine = client.max_load(max_file, '*')
        print('Loading DFE:\t\t\t\t\t%.5lfs' % (time.time() - start_time))

        # Allocate and send input streams to server
        start_time = time.time()
        address_data_in = client.malloc_float(size)
        client.send_data_float(address_data_in, data_in)
        print('Sending input data:\t\t\t\t%.5lfs' % (time.time() - start_time))

        # Allocate memory for output stream on server
        start_time = time.time()
        address_data_out = client.malloc_float(size)
        print('Allocating memory for output stream on server:\t%.5lfs' %
              (time.time() - start_time))

        # Action default
        start_time = time.time()
        actions = client.max_actions_init(max_file, "default")
        client.max_set_param_uint64t(actions, "N", size)
        client.max_queue_input(actions, "x", address_data_in, size_bytes)
        client.max_queue_output(actions, "y", address_data_out, size_bytes)
        client.max_run(max_engine, actions)
        print('Simple time:\t\t\t\t\t%.5lfs' % (time.time() - start_time))

        # Unload DFE
        start_time = time.time()
        client.max_unload(max_engine)
        print('Unloading DFE:\t\t\t\t\t%.5lfs' % (time.time() - start_time))

        # Get output stream from server
        start_time = time.time()
        data_out = client.receive_data_float(address_data_out, size)
        print('Getting output stream:\t(size = %d bit)\t%.5lfs' %
              ((size * 32), (time.time() - start_time)))

        # Free allocated memory for streams on server
        start_time = time.time()
        client.free(address_data_in)
        client.free(address_data_out)
        client.free(actions)
        print('Freeing allocated memory for streams on server:\t%.5lfs' %
              (time.time() - start_time))

        # Free allocated maxfile data
        start_time = time.time()
        client.Simple_free()
        print('Freeing allocated maxfile data:\t\t\t%.5lfs' %
              (time.time() - start_time))

        # Close!
        start_time = time.time()
        transport.close()
        print('Closing connection:\t\t\t\t%.5lfs' % (time.time() - start_time))

    except Thrift.TException, thrift_exceptiion:
        print '%s' % (thrift_exceptiion.message)
        sys.exit(-1)
Exemple #14
0
class TestChord:
    transport = TSocket.TSocket(sys.argv[1], int(sys.argv[2]))
    transport = TTransport.TBufferedTransport(transport)
    protocol = TBinaryProtocol.TBinaryProtocol(transport)
    filestore = FileStore.Client(protocol)
    transport.open()

    def __init__(self):
        pass

    def test_write_file(self, rfile):
        node = self.filestore.findSucc(rfile.meta.contentHash)
        print "node id: ", node
        assert node.id == "162f2ef78020a93545457290a21d4ea634d4bca22aff8530e2011209be88ff82", "Test_Write_file - Node returned is wrong"
        print "Test case passed 1 -- get successor node for key: ", rfile.meta.contentHash

        file_store = make_socket(node.ip, node.port)
        file_store.writeFile(rfile)
        read_file = file_store.readFile(rfile.meta.filename, rfile.meta.owner)
        assert str(read_file.meta.filename) == str(
            rfile.meta.filename), "Test_Write_file - Filename mismatch"
        assert str(read_file.meta.version) == str(
            rfile.meta.version), "Test_Write_file - version mismatch"
        assert str(read_file.meta.owner) == str(
            rfile.meta.owner), "Test_Write_file - owner mismatch"
        assert str(read_file.meta.contentHash) == str(
            rfile.meta.contentHash), "Test_Write_file - contentHash mismatch"
        assert str(read_file.content) == str(
            rfile.content), "Test_Write_file - Content mismatch"
        print "Test case passed 2 -- Write file: file name - %s, owner - %s" % (
            rfile.meta.filename, rfile.meta.owner)
        """try:
            self.filestore.writeFile(rfile)
            raise AssertionError("Test_Write_file - No Exception on invalid write")
        except SystemException as err:
            assert err.message == "Key is not associated with the node", "Test_Write_file - Message Content Mismatch"
            print "Test case passed 3 -- ", err.message"""

    def test_read_file(self, filename, owner):

        node = self.filestore.findSucc(
            sha256(owner + ":" + filename).hexdigest())
        assert node.id == "162f2ef78020a93545457290a21d4ea634d4bca22aff8530e2011209be88ff82", "Test_Read_File - Node returned is wrong"
        print "Test case passed 4 -- get successor node for key: ", sha256(
            owner + ":" + filename).hexdigest()

        file_store = make_socket(node.ip, node.port)
        rfile.content = "This is a test program"
        file_store.writeFile(rfile)
        read_file = file_store.readFile(filename, owner)
        assert read_file.meta.filename == rfile.meta.filename, "Test_Read_file - Filename mismatch"
        assert str(read_file.meta.version) == str(
            int(rfile.meta.version) + 1), "Test_Read_file - version mismatch"
        assert read_file.meta.owner == rfile.meta.owner, "Test_Read_file - owner mismatch"
        assert read_file.meta.contentHash == rfile.meta.contentHash, "Test_Read_file - contentHash mismatch"
        assert read_file.content == rfile.content, "Test_Read_file - Content mismatch"
        print "Test case passed 5 -- write file: file name - %s, owner - %s" % (
            filename, owner)

        rfile.meta.filename = "test_p2.txt"
        rfile.meta.contentHash = sha256(owner + ":" +
                                        rfile.meta.filename).hexdigest()
        node = self.filestore.findSucc(rfile.meta.contentHash)
        assert node.id == "162f2ef78020a93545457290a21d4ea634d4bca22aff8530e2011209be88ff82", "Test_Read_File - Node returned is wrong"
        print "Test case passed 6 -- get successor node for key: ", rfile.meta.contentHash

        file_store = make_socket(node.ip, node.port)
        file_store.writeFile(rfile)
        read_file = file_store.readFile(rfile.meta.filename, owner)
        assert read_file.meta.filename == rfile.meta.filename, "Test_Read_file - Filename mismatch"
        assert read_file.meta.version == rfile.meta.version, "Test_Read_file - version mismatch"
        assert read_file.meta.owner == rfile.meta.owner, "Test_Read_file - owner mismatch"
        assert read_file.meta.contentHash == rfile.meta.contentHash, "Test_Read_file - contentHash mismatch"
        assert read_file.content == rfile.content, "Test_Read_file - Content mismatch"
        print "Test case passed 7 -- write file: file name - %s, owner - %s" % (
            rfile.meta.filename, owner)

        rfile.meta.filename = "p2.txt"
        rfile.meta.owner = "AravindKumar"
        rfile.meta.contentHash = sha256(rfile.meta.owner + ":" +
                                        rfile.meta.filename).hexdigest()
        node = self.filestore.findSucc(rfile.meta.contentHash)
        assert node.id == "162f2ef78020a93545457290a21d4ea634d4bca22aff8530e2011209be88ff82", "Test_Read_File - Node returned is wrong"
        print "Test case passed 8 -- get successor node for key: ", rfile.meta.contentHash

        file_store = make_socket(node.ip, node.port)
        file_store.writeFile(rfile)
        read_file = file_store.readFile(rfile.meta.filename, rfile.meta.owner)
        assert read_file.meta.filename == rfile.meta.filename, "Test_Read_file - Filename mismatch"
        assert read_file.meta.version == rfile.meta.version, "Test_Read_file - version mismatch"
        assert read_file.meta.owner == rfile.meta.owner, "Test_Read_file - owner mismatch"
        assert read_file.meta.contentHash == rfile.meta.contentHash, "Test_Read_file - contentHash mismatch"
        assert read_file.content == rfile.content, "Test_Read_file - Content mismatch"
        print "Test case passed 9 -- write file: file name - %s, owner - %s" % (
            rfile.meta.filename, rfile.meta.owner)

        rfile.meta.filename = "p2_p2.txt"
        rfile.meta.owner = "AravindKumarDhinagaran"
        rfile.meta.contentHash = sha256(rfile.meta.owner + ":" +
                                        rfile.meta.filename).hexdigest()
        node = self.filestore.findSucc(rfile.meta.contentHash)
        assert node.id == "162f2ef78020a93545457290a21d4ea634d4bca22aff8530e2011209be88ff82", "Test_Read_File - Node returned is wrong"
        print "Test case passed 10 -- get successor node for key: ", rfile.meta.contentHash

        file_store = make_socket(node.ip, node.port)
        file_store.writeFile(rfile)
        read_file = file_store.readFile(rfile.meta.filename, rfile.meta.owner)
        assert read_file.meta.filename == rfile.meta.filename, "Test_Read_file - Filename mismatch"
        assert read_file.meta.version == rfile.meta.version, "Test_Read_file - version mismatch"
        assert read_file.meta.owner == rfile.meta.owner, "Test_Read_file - owner mismatch"
        assert read_file.meta.contentHash == rfile.meta.contentHash, "Test_Read_file - contentHash mismatch"
        assert read_file.content == rfile.content, "Test_Read_file - Content mismatch"
        print "Test case passed 11 -- write file: file name - %s, owner - %s" % (
            rfile.meta.filename, rfile.meta.owner)

        try:
            file_store.readFile(filename, 'invalid')
            raise AssertionError(
                "Test_Read_file - No Exception on invalid owner name")
        except SystemException as err:
            print "Test case passed 12 -- ", err.message

        try:
            file_store.readFile('invalid', owner)
            raise AssertionError(
                "Test_Read_file - No Exception on invalid filename")
        except SystemException as err:
            print "Test case passed 13 -- ", err.message

        try:
            self.filestore.readFile(filename, owner)
            raise AssertionError(
                "Test_Read_file - No Exception on invalid read")
        except SystemException as err:
            assert err.message == "Key is not associated with the node", "Test_Read_file - Message Content Mismatch"
            print "Test case passed 14 -- ", err.message

    def test_negative_cases(self, filestore, key):

        try:
            filestore.findSucc(key)
            raise AssertionError(
                "Test_Find_Succ - No Exception on empty finger table")
        except SystemException as err:
            assert err.message == "Fingertable not exist for the current node", "Test_Find_Succ - message content mismatch"
            print "Test case passed 15 -- ", err.message

        try:
            filestore.findPred(key)
            raise AssertionError(
                "Test_Find_Pred - No Exception on empty finger table")
        except SystemException as err:
            assert err.message == "Fingertable not exist for the current node", "Test_Find_Pred - message content mismatch"
            print "Test case passed 16 -- ", err.message

        try:
            filestore.getNodeSucc()
            raise AssertionError(
                "Test_Get_Node_Succ - No Exception on empty finger table")
        except SystemException as err:
            assert err.message == "Fingertable not exist for the current node", "Test_Node_Succ - message content mismatch"
            print "Test case passed 17 -- ", err.message
 def testBinaryProtocolAcceleratedEof(self):
     """Test that TBinaryProtocolAccelerated throws an EOFError when it reaches the end of the stream"""
     self.eofTestHelper(TBinaryProtocol.TBinaryProtocolAcceleratedFactory())
     self.eofTestHelperStress(
         TBinaryProtocol.TBinaryProtocolAcceleratedFactory())
def findNtpAmplifiers(table, today=datetime.date.today(), verbose=False):
    """
  Find NTP amplifiers in the given traffic (table) and store the results in the 'ntpamplifiers' Hive table.
  """

    date = "%d%02d%02d" % (today.year, today.month, today.day)
    table = scrub(table)

    ## set some variables regarding the input data
    if table.startswith("netflow"):
        dataType = "netflow"
        req0 = "select sa, sum(ibyt), sum(ipkt) from %s where sp=123 and dt='%s' and pr='UDP' and ibyt/ipkt=468 group by sa" % (
            table, date)
    elif table.startswith("sflow"):
        dataType = "sflow"
        req0 = "select srcip, sum(ipsize), count(*) from %s where udpsrcport=123 and ipprotocol=17 and ipsize=468 and dt='%s' group by srcip" % (
            table, date)
    else:
        sys.stderr.write("Data type unknown!")
        sys.exit(-1)

    cursor = presto.connect('localhost').cursor()
    if verbose:
        sys.stdout.write("Looking for %s NTP amplifiers... (%s)\n" %
                         (date, table))

    # get today's data
    cursor.execute(req0)
    res = cursor.fetchall()

    if len(res) == 0:
        return

    data = pd.DataFrame(res, columns=["srcip", "nbbyt", "nbpkt"])

    # add the confidence score:
    data["confidence"] = "LOW"
    data.loc[data.nbpkt >= 100, "confidence"] = "MED"
    data.loc[data.nbpkt >= 1000, "confidence"] = "HIGH"

    outputFile = open(
        "%s/ntpamplifiers_%s_%s.txt" % (outputDirectory, table, date), "w")
    data.to_csv(outputFile,
                sep="\t",
                header=False,
                cols=["srcip", "nbbyt", "nbpkt", "confidence"],
                index=False)
    outputFile.close()

    # Store results in Hive
    try:
        transport = TSocket.TSocket('localhost', 10000)
        transport = TTransport.TBufferedTransport(transport)
        protocol = TBinaryProtocol.TBinaryProtocol(transport)

        client = ThriftHive.Client(protocol)
        transport.open()

        client.execute(
            "create table if not exists ntpamplifiers (srcip string, byte bigint,  pkt bigint, confidence string) partitioned by(dt string, dataSrc string) row format delimited fields terminated by '\t'"
        )
        client.execute(
            "load data local inpath '{dir}/ntpamplifiers_{table}_{date}.txt' overwrite into table ntpamplifiers partition (dt='{date}', dataSrc='{table}')"
            .format(table=table, date=date, dir=outputDirectory))
        transport.close()

    except Thrift.TException, tx:
        sys.stderr.write('%s\n' % (tx.message))
 def __init__(self):
     self.transport = TSocket.TSocket('192.168.0.242', 9090)
     transport = TTransport.TBufferedTransport(self.transport)
     protocol = TBinaryProtocol.TBinaryProtocol(transport)
     self.client = Hbase.Client(protocol)
     transport.open()
Exemple #18
0
from thrift import Thrift
from thrift.protocol import TBinaryProtocol
from thrift.transport import THttpClient
from thrift.transport import TTransport
'''
@author: anant bhardwaj
@date: Oct 11, 2013

Sample Python client for DataHub Account Creation
'''

try:
    datahub_transport = THttpClient.THttpClient(
        'http://datahub.csail.mit.edu/service')
    datahub_transport = TTransport.TBufferedTransport(datahub_transport)
    datahub_protocol = TBinaryProtocol.TBinaryProtocol(datahub_transport)
    datahub_client = DataHub.Client(datahub_protocol)

    account_transport = THttpClient.THttpClient(
        'http://datahub.csail.mit.edu/service/account')
    account_transport = TTransport.TBufferedTransport(account_transport)
    account_protocol = TBinaryProtocol.TBinaryProtocol(account_transport)
    account_client = AccountService.Client(account_protocol)

    print "Version: %s" % (datahub_client.get_version())

    try:
        print account_client.remove_account(
            username="******",
            app_id="confer",
            app_token="d089b3ed-1d82-4eae-934a-859d7070d364")
Exemple #19
0
 def testBinaryProtocolAcceleratedEof(self):
     """Test that TBinaryProtocolAccelerated throws a TTransportException
     when it reaches the end of the stream"""
     self.eofTestHelper(TBinaryProtocol.TBinaryProtocolAcceleratedFactory())
     self.eofTestHelperStress(
         TBinaryProtocol.TBinaryProtocolAcceleratedFactory())
Exemple #20
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

from thrift.Thrift import TException
from thrift.transport import TSocket, TTransport
from thrift.protocol import TBinaryProtocol
from genpy.calc.ICalc import Client

if __name__ == '__main__':
    try:
        TRANSPORT = TSocket.TSocket('localhost', 9090)
        TRANSPORT = TTransport.TBufferedTransport(TRANSPORT)
        PROTOCOL = TBinaryProtocol.TBinaryProtocol(TRANSPORT)
        CLIENT = Client(PROTOCOL)

        TRANSPORT.open()
        num1, num2 = sys.argv[1], sys.argv[2]

        print CLIENT.add(int(num1), int(num2))

        TRANSPORT.close()
    except TException as e:
        print e.message



Exemple #21
0
def execute_hurdle(make_plot=False,
                   result_file="results.json",
                   host='127.0.0.1',
                   port=9090,
                   seed=None,
                   initial_state=None,
                   num_trials=10,
                   num_rounds=30000,
                   scoring_rounds=1000,
                   team_name="team"):
    num_states = 10

    avg_score_threshold = 2.0
    trial_pass_threshold = 6

    expected = expected_random_score(num_states)
    print("expected score of random guesser is {}".format(expected *
                                                          num_rounds))
    print("score required to pass a trial is {}".format(avg_score_threshold *
                                                        num_rounds))
    print("Number of trials passed to pass Hurdle 3 is  {} out of {}".format(
        trial_pass_threshold, num_trials))

    # Make socket
    transport = TSocket.TSocket(host, port)

    # Buffering is critical. Raw sockets are very slow
    transport = TTransport.TBufferedTransport(transport)

    # Wrap in a protocol
    protocol = TBinaryProtocol.TBinaryProtocol(transport)

    # Create a client to use the protocol encoder
    client = Hurdle3Execution.Client(protocol)

    # Connect!
    transport.open()

    results = {"trials": {}, "team_name": team_name}

    for t in range(num_trials):

        if initial_state is None:
            initial_state = random.randrange(num_states)

        if seed is None:
            seed = random.randint(0, 0xffffffff)

        # create a new probabilistic state machine with potentaiily
        # a new initial state and seed
        # at the start of each trial
        psm = PSM(num_states, initial_state, seed)

        print("starting trial {} of {}".format(t, num_trials))

        # run the trial and store the trial results
        trial_results = run_trial(t, num_rounds, scoring_rounds,
                                  avg_score_threshold, client, psm)

        # add seed and initial state to trial_results
        trial_results["seed"] = seed
        trial_results["initial_state"] = initial_state

        results["trials"][t] = trial_results

    # count the number of trials that passed
    trials_passed = sum(
        [results["trials"][i]["trial_pass"] for i in range(num_trials)])

    print(
        "Number of trials passed: {} Number of trials passed required to pass Hurdle 3: {}"
        .format(trials_passed, trial_pass_threshold))
    hurdle_pass = trials_passed >= trial_pass_threshold

    print("Hurdle 3 Passed? {}".format(hurdle_pass))

    results["num_trials"] = num_trials
    results["num_states"] = num_states
    results["trials_passed"] = trials_passed
    results["trial_pass_threshold"] = trial_pass_threshold
    results["hurdle_pass"] = hurdle_pass

    with open(result_file, 'w') as f:

        f.write(json.dumps(results))

    print("Writing results to file: {}".format(result_file))
    #print("Results file: {}".format(results))

    client.stop()
Exemple #22
0
 def __init__(self):
     transport = TSocket.TSocket(kw_config.IP, kw_config.PORT)
     self.transport = TTransport.TBufferedTransport(transport)
     protocol = TBinaryProtocol.TBinaryProtocol(self.transport)
     self.client = kwServer.Client(protocol)
     self.transport.open()
class AcceleratedBinaryTest(AbstractTest):
  protocol_factory = TBinaryProtocol.TBinaryProtocolAcceleratedFactory()
def serialize(thrift_obj, filename):
    with open(filename, 'wb') as f:
        transport = TTransport.TFileObjectTransport(f)
        protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport)
        thrift_obj.write(protocol)
        transport.flush()
Exemple #25
0
    def kill(self):
        os._exit(0)

    def say(self, word):
        print word


if __name__ == '__main__':
    try:
        parser = argparse.ArgumentParser(
            description='Durable File Service Participant.')
        parser.add_argument(dest='port', help='Port')
        args = parser.parse_args()

        handler = TestFileStoreHandler()
        processor = TestFileStore.Processor(handler)
        tsocket = TSocket.TServerSocket('0.0.0.0', args.port)
        transport = TTransport.TBufferedTransportFactory()
        protocol = TBinaryProtocol.TBinaryProtocolFactory()
        server = TServer.TThreadedServer(processor, tsocket, transport,
                                         protocol)

        host = socket.gethostname()
        host += '.cs.binghamton.edu' if host.startswith('remote') else ''
        print('TestFileStore server running on ' + host + ':' + args.port)
        server.serve()

    except Thrift.TException as tx:
        print('%s' % (tx.message))
Exemple #26
0
def handler(event, context):
    # dataset
    data_bucket = event['data_bucket']
    file = event['file']
    dataset_type = event["dataset_type"]
    assert dataset_type == "dense_libsvm"
    n_features = event['n_features']

    # ps setting
    host = event['host']
    port = event['port']

    # hyper-parameter
    n_clusters = event['n_clusters']
    n_epochs = event["n_epochs"]
    threshold = event["threshold"]
    sync_mode = event["sync_mode"]
    n_workers = event["n_workers"]
    worker_index = event['worker_index']
    assert sync_mode.lower() == Synchronization.Reduce

    print('data bucket = {}'.format(data_bucket))
    print("file = {}".format(file))
    print('number of workers = {}'.format(n_workers))
    print('worker index = {}'.format(worker_index))
    print('num clusters = {}'.format(n_clusters))
    print('host = {}'.format(host))
    print('port = {}'.format(port))

    # Set thrift connection
    # Make socket
    transport = TSocket.TSocket(host, port)
    # Buffering is critical. Raw sockets are very slow
    transport = TTransport.TBufferedTransport(transport)
    # Wrap in a protocol
    protocol = TBinaryProtocol.TBinaryProtocol(transport)
    # Create a client to use the protocol encoder
    t_client = ParameterServer.Client(protocol)
    # Connect!
    transport.open()
    # test thrift connection
    ps_client.ping(t_client)
    print("create and ping thrift server >>> HOST = {}, PORT = {}".format(
        host, port))

    # Reading data from S3
    read_start = time.time()
    storage = S3Storage()
    lines = storage.load(file, data_bucket).read().decode('utf-8').split("\n")
    print("read data cost {} s".format(time.time() - read_start))

    parse_start = time.time()
    dataset = libsvm_dataset.from_lines(lines, n_features, dataset_type).ins_np
    data_type = dataset.dtype
    centroid_shape = (n_clusters, dataset.shape[1])
    print("parse data cost {} s".format(time.time() - parse_start))
    print("dataset type: {}, dtype: {}, Centroids shape: {}, num_features: {}".
          format(dataset_type, data_type, centroid_shape, n_features))

    # register model
    model_name = Prefix.KMeans_Cent
    model_length = centroid_shape[0] * centroid_shape[1] + 1
    ps_client.register_model(t_client, worker_index, model_name, model_length,
                             n_workers)
    ps_client.exist_model(t_client, model_name)
    print("register and check model >>> name = {}, length = {}".format(
        model_name, model_length))

    init_centroids_start = time.time()
    ps_client.can_pull(t_client, model_name, 0, worker_index)
    ps_model = ps_client.pull_model(t_client, model_name, 0, worker_index)
    if worker_index == 0:
        centroids = dataset[0:n_clusters].flatten()
        ps_client.can_push(t_client, model_name, 0, worker_index)
        ps_client.push_grad(
            t_client, model_name,
            np.append(centroids.flatten(), 1000.).astype(np.double) -
            np.asarray(ps_model).astype(np.double), 1.0, 0, worker_index)

    else:
        centroids = np.zeros(centroid_shape)
        ps_client.can_push(t_client, model_name, 0, worker_index)
        ps_client.push_grad(
            t_client, model_name,
            np.append(centroids.flatten(), 0).astype(np.double), 0, 0,
            worker_index)
    ps_client.can_pull(t_client, model_name, 1, worker_index)
    ps_model = ps_client.pull_model(t_client, model_name, 1, worker_index)
    cur_centroids = np.array(ps_model[0:-1]).astype(
        np.float32).reshape(centroid_shape)
    cur_error = float(ps_model[-1])
    #print("init centroids = {}, error = {}".format(cur_centroids, cur_error))
    print("initial centroids cost {} s".format(time.time() -
                                               init_centroids_start))

    model = cluster_models.get_model(dataset, cur_centroids, dataset_type,
                                     n_features, n_clusters)

    train_start = time.time()
    cal_time = 0
    comm_time = 0
    for epoch in range(1, n_epochs + 1):
        epoch_start = time.time()

        # local computation
        model.find_nearest_cluster()
        local_cent = model.get_centroids("numpy").reshape(-1)
        local_cent_error = np.concatenate(
            (local_cent.astype(np.double).flatten(),
             np.array([model.error], dtype=np.double)))
        epoch_cal_time = time.time() - epoch_start
        print("error after local update = {}".format(model.error))

        # push updates
        epoch_comm_start = time.time()
        last_cent_error = np.concatenate(
            (cur_centroids.astype(np.double).flatten(),
             np.array([cur_error], dtype=np.double)))
        ps_model_inc = local_cent_error - last_cent_error
        ps_client.can_push(t_client, model_name, epoch, worker_index)
        ps_client.push_grad(t_client, model_name, ps_model_inc,
                            1.0 / n_workers, epoch, worker_index)

        # pull new model
        epoch_pull_start = time.time()
        ps_client.can_pull(t_client, model_name, epoch + 1,
                           worker_index)  # sync all workers
        ps_model = ps_client.pull_model(t_client, model_name, epoch + 1,
                                        worker_index)
        model.centroids = np.array(ps_model[0:-1]).astype(
            np.float32).reshape(centroid_shape)
        model.error = float(ps_model[-1])
        cur_centroids = model.get_centroids("numpy").reshape(-1)
        cur_error = model.error

        epoch_comm_time = time.time() - epoch_comm_start

        print(
            "Epoch[{}] Worker[{}], error = {}, cost {} s, cal cost {} s, sync cost {} s"
            .format(epoch, worker_index, model.error,
                    time.time() - epoch_start, epoch_cal_time,
                    epoch_comm_time))

        if model.error < threshold:
            break

    print("Worker[{}] finishes training: Error = {}, cost {} s".format(
        worker_index, model.error,
        time.time() - train_start))
    return
Exemple #27
0
#!/usr/bin/env python

import sys
sys.path.append('./gen-py')

from scribe import *
from scribe.ttypes import *

from thrift.transport import TTransport, TSocket
from thrift.protocol import TBinaryProtocol

category = 'ncs_index_err'
message = 'test_message'

host = 'localhost'
port = 9999

log_entry = LogEntry(category=category, message=message)

socket = TSocket.TSocket(host=host, port=port)
transport = TTransport.TFramedTransport(socket)
protocol = TBinaryProtocol.TBinaryProtocol(trans=transport, strictRead=False, strictWrite=False)
client = scribe.Client(iprot=protocol, oprot=protocol)


for i in range(10000):
    transport.open()
    result = client.Log(messages=[log_entry])
    transport.close()
def create_sharing_client(transport):

    protocol = TBinaryProtocol.TBinaryProtocol(transport)

    return SharingRegistryService.Client(protocol)
Exemple #29
0
if __name__ == '__main__':
    if os.path.exists('../../service_log'):
        shutil.rmtree('../../service_log')
    os.makedirs('../../service_log/info_log')
    os.makedirs('../../service_log/error_log')
    info_logger = get_logger(name=__name__ + '_info',
                             filename='../../service_log/info_log/info.log',
                             level='info')
    error_logger = get_logger(name=__name__ + '_error',
                              filename='../../service_log/error_log/error.log',
                              level='error')

    #
    conf_path_1 = '/Users/lix/Desktop/fasic_cv_sdk/pretrained_models/2stems'
    conf_path_2 = '/Users/lix/Desktop/fasic_cv_sdk/inaSpeechSegmenter'

    handler = VisionServicesHandler(conf_path_1,
                                    conf_path_2,
                                    info_logger=info_logger,
                                    error_logger=error_logger)
    processor = VisionServices.Processor(handler)

    port, worker = get_args()
    transport = TSocket.TServerSocket(port=port)
    tfactory = TTransport.TBufferedTransportFactory()
    pfactory = TBinaryProtocol.TBinaryProtocolFactory(strictRead=True,
                                                      strictWrite=False)
    server = TServer.TThreadedServer(processor, transport, tfactory, pfactory)
    print('server starting...')
    server.serve()
Exemple #30
0
            uid_list = req.uidList
            if not uid_list:
                raise Exception('参数错误', ErrCodeEnum.PARAM_ERROR)

            user_list_all = self.get_user_by_uid_list(uid_list)
            if not user_list_all:
                raise Exception('服务器错误', ErrCodeEnum.SERVER_ERROR)

            user_list_resp = UserListResp(user_list_all)
            return user_list_resp
        except Exception as e:
            print e
            raise ApiErrorException(e.getCode(), e.getMessage())


if __name__ == '__main__':
    handler = UserInfoHandler()
    processor = UserService.Processor(handler)
    transport = TSocket.TServerSocket(host='127.0.0.1', port=9090)
    tfactory = TTransport.TBufferedTransportFactory()
    pfactory = TBinaryProtocol.TBinaryProtocolFactory()

    # 简单服务器模式
    server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
    # 线程模式
    # server = TServer.TThreadedServer(
    #     processor, transport, tfactory, pfactory)

    print "Starting thrift server in python..."
    server.serve()
    print "done!"
Exemple #31
0
def start_extension(name="<unknown>",
                    version="0.0.0",
                    sdk_version="3.0.7",
                    min_sdk_version="1.8.0"):
    """Start your extension by communicating with osquery core and starting
    a thrift server.

    Keyword arguments:
    name -- the name of your extension
    version -- the version of your extension
    sdk_version -- the version of the osquery SDK used to build this extension
    min_sdk_version -- the minimum version of the osquery SDK that you can use
    """
    args = parse_cli_params()

    # Disable logging for the thrift module (can be loud).
    logging.getLogger('thrift').addHandler(logging.NullHandler())

    client = ExtensionClient(path=args.socket)

    if not client.open(args.timeout):
        if args.verbose:
            message = "Could not open socket %s" % args.socket
            raise ExtensionException(
                code=1,
                message=message,
            )
        return
    ext_manager = ExtensionManager()

    # try connecting to the desired osquery core extension manager socket
    try:
        status = client.extension_manager_client().registerExtension(
            info=InternalExtensionInfo(
                name=name,
                version=version,
                sdk_version=sdk_version,
                min_sdk_version=min_sdk_version,
            ),
            registry=ext_manager.registry(),
        )
    except socket.error:
        message = "Could not connect to %s" % args.socket
        raise ExtensionException(
            code=1,
            message=message,
        )

    if status.code != 0:
        raise ExtensionException(
            code=1,
            message=status.message,
        )

    # Start a watchdog thread to monitor the osquery process.
    rt = threading.Thread(target=start_watcher, args=(client, args.interval))
    rt.daemon = True
    rt.start()

    # start a thrift server listening at the path dictated by the uuid returned
    # by the osquery core extension manager
    ext_manager.uuid = status.uuid
    processor = Processor(ext_manager)

    transport = None
    if sys.platform == 'win32':
        transport = TPipeServer(pipe_name="{}.{}".format(args.socket, status.uuid))
    else:
        transport = TSocket.TServerSocket(
            unix_socket=args.socket + "." + str(status.uuid))

    tfactory = TTransport.TBufferedTransportFactory()
    pfactory = TBinaryProtocol.TBinaryProtocolFactory()
    server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
    server.serve()
Exemple #32
0
class NormalBinaryTest(AbstractTest):
    protocol_factory = TBinaryProtocol.TBinaryProtocolFactory()
    def start(self):

        # Set up thrift client and contact server
        thrift_server = 'localhost'
        self.transport = TSocket.TSocket(thrift_server, 9090)

        self.transport = TTransport.TBufferedTransport(self.transport)
        bprotocol = TBinaryProtocol.TBinaryProtocol(self.transport)
        # And the pltfm server as well
        self.transport_pltfm = None
        if self.pltfm_pm_client_module or self.pltfm_mgr_client_module:
            thrift_server = 'localhost'
            self.transport_pltfm = TSocket.TSocket(thrift_server, 9095)
            self.transport_pltfm = TTransport.TBufferedTransport(self.transport_pltfm)
            bprotocol_pltfm = TBinaryProtocol.TBinaryProtocol(self.transport_pltfm)

        # And the diag server as well
        self.transport_diag = None
        if self.diag_client_module:
            thrift_server = 'localhost'
            self.transport_diag = TSocket.TSocket(thrift_server, 9096)
            self.transport_diag = TTransport.TBufferedTransport(self.transport_diag)
            #bprotocol_diag = TBinaryProtocol.TBinaryProtocol(self.transport_diag)

        self.mc_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, "mc")
        if self.mirror_client_module:
            self.mirror_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, "mirror")
        if self.sd_client_module:
            self.sd_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, "sd")
        if self.plcmt_client_module:
            self.plcmt_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, "plcmt")
        if self.devport_mgr_client_module:
            self.devport_mgr_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, "devport_mgr")
        else:
            self.devport_mgr_protocol = None
        if self.port_mgr_client_module:
            self.port_mgr_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, "port_mgr")
        else:
            self.port_mgr_protocol = None
        self.conn_mgr_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, "conn_mgr")
        if self.pkt_client_module:
            self.pkt_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, "pkt")
        else:
            self.pkt_protocol = None

        if self.pltfm_pm_client_module and self.transport_pltfm:
            self.pltfm_pm_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol_pltfm, "pltfm_pm_rpc")
        else:
            self.pltfm_pm_protocol = None
        if self.pltfm_mgr_client_module and self.transport_pltfm:
            self.pltfm_mgr_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol_pltfm, "pltfm_mgr_rpc")
        else:
            self.pltfm_mgr_protocol = None
        if self.diag_client_module and self.transport_diag:
            self.diag_protocol = TBinaryProtocol.TBinaryProtocol(self.transport_diag)
        else:
            self.diag_protocol = None
        self.p4_protocols = {}
        self.clients = {}
        self.client = None
        for p4_name, p4_prefix in zip(self.p4_names, self.p4_prefixes):
            p4_protocol = TMultiplexedProtocol.TMultiplexedProtocol(bprotocol, p4_prefix)
            self.p4_protocols[p4_name] = p4_protocol
            self.clients[p4_name] = self.p4_client_modules[p4_name].Client(p4_protocol)

        if len(self.clients) == 1:
            self.client = self.clients.values()[0]

        self.mc = self.mc_client_module.Client(self.mc_protocol)
        if self.mirror_client_module:
            self.mirror = self.mirror_client_module.Client(self.mirror_protocol)
        else:
            self.mirror = None
        if self.sd_client_module:
            self.sd = self.sd_client_module.Client(self.sd_protocol)
        else:
            self.sd = None
        if self.plcmt_client_module:
            self.plcmt = self.plcmt_client_module.Client(self.plcmt_protocol)
        else:
            self.plcmt = None
        if self.devport_mgr_client_module:
            self.devport_mgr = self.devport_mgr_client_module.Client(self.devport_mgr_protocol)
        else:
            self.devport_mgr = None
        if self.port_mgr_client_module:
            self.port_mgr = self.port_mgr_client_module.Client(self.port_mgr_protocol)
        else:
            self.port_mgr = None
        self.conn_mgr = self.conn_mgr_client_module.Client(self.conn_mgr_protocol)
        if self.pkt_client_module:
            self.pkt = self.pkt_client_module.Client(self.pkt_protocol)
        else:
            self.pkt = None

        if self.pltfm_pm_client_module and self.transport_pltfm:
            self.pltfm_pm = self.pltfm_pm_client_module.Client(self.pltfm_pm_protocol)
        else:
            self.pltfm_pm = None
        if self.pltfm_mgr_client_module and self.transport_pltfm:
            self.pltfm_mgr = self.pltfm_mgr_client_module.Client(self.pltfm_mgr_protocol)
        else:
            self.pltfm_mgr = None
        if self.diag_client_module and self.transport_diag:
            self.diag = self.diag_client_module.Client(self.diag_protocol)
        else:
            self.diag = None
        self.transport.open()
        if self.transport_pltfm:
            try:
                self.transport_pltfm.open()
            except:
                print "Did not connect to pltfm thrift server"
                self.transport_pltfm = None
                self.pltfm_mgr = None
                self.pltfm_pm = None
        if self.transport_diag:
                try:
                    self.transport_diag.open()
                except:
                    print "Did not connect to diag thrift server"
                    self.transport_diag = None
                    self.diag = None


        self.sess_hdl = self.conn_mgr.client_init()
        self.dev_tgt = DevTarget_t(0, hex_to_i16(0xFFFF))
        self.mc_sess_hdl = self.mc.mc_create_session()

        self.platform_type = "mavericks"
        board_type = self.pltfm_pm.pltfm_pm_board_type_get()
        if re.search("0x0234|0x1234|0x4234", hex(board_type)):
            self.platform_type = "mavericks"
        elif re.search("0x2234|0x3234", hex(board_type)):
            self.platform_type = "montara"
        print ("platform type: %s"%self.platform_type)

        return self.client