def __init__(self, **kwargs): """ :param host: :param port: :param timeout: :param connect: :return: """ port = get_kwarg('port', kwargs, 7147) timeout = get_kwarg('timeout', kwargs, 10) Transport.__init__(self, **kwargs) # Create instance of self.logger try: self.logger = kwargs['logger'] except KeyError: self.logger = logging.getLogger(__name__) new_connection_msg = '*** NEW CONNECTION MADE TO {} ***'.format(self.host) self.logger.info(new_connection_msg) katcp.CallbackClient.__init__( self, self.host, port, tb_limit=20, timeout=timeout, logger=self.logger, auto_reconnect=True) self.system_info = {} self.unhandled_inform_handler = None self._timeout = timeout self.connect() self.logger.info('%s: port(%s) created and connected.' % (self.host, port))
def __init__(self, gb): self.gb = gb # -- flow -- # self.discr_flow = Flow(gb) shape = self.discr_flow.shape() self.flux_pressure = np.zeros(shape) # -- temperature -- # self.discr_temperature = Heat(gb) # -- solute and precipitate -- # self.discr_solute_advection_diffusion = Transport(gb) self.discr_solute_precipitate_reaction = Reaction(gb) # -- porosity -- # self.discr_porosity = Porosity(gb) # -- fracture aperture -- # self.discr_fracture_aperture = FractureAperture( gb, "fracture_aperture") # -- layer porosity and aperture -- # self.discr_layer_porosity = Porosity(gb, "layer_porosity") self.discr_layer_aperture = LayerAperture(gb, "layer_aperture") # the actual time of the simulation self.time = 0
def __init__(self, **kwargs): """ Initialized Tapcp FPGA object :param host: IP Address of the targeted Board """ try: import tftpy global TFTPY TFTPY = tftpy TFTPY.setLogLevel(logging.CRITICAL) except ImportError: raise ImportError( 'You need to install tftpy to use TapcpTransport') Transport.__init__(self, **kwargs) set_log_level(logging.ERROR) self.t = tftpy.TftpClient(kwargs['host'], 69) try: self.parent = kwargs['parent_fpga'] self.logger = self.parent.logger except KeyError: errmsg = 'parent_fpga argument not supplied when creating tapcp device' raise RuntimeError(errmsg) new_connection_msg = '*** NEW CONNECTION MADE TO {} ***'.format( self.host) self.logger.info(new_connection_msg) self.timeout = kwargs.get('timeout', 3) self.server_timeout = 0.1 # Microblaze timeout period. So that if a command fails we can wait for the microblaze to terminate the connection before retrying self.retries = kwargs.get( 'retries', 8 ) # These are retries of a complete transaction (each of which has it's ofw TFTP retries).
class TestTransport(unittest.TestCase): @classmethod def setUpClass(cls): print('setUpClass') def setUp(self): #print('setUp') self.transport = Transport(speed=120) def tearDown(self): #print('tearDown') del self.transport def test_drive(self): # assert True, True self.transport.drive(10) self.assertEqual(self.transport.pos, 1200) def test_drive2(self): self.transport.drive(10) self.assertEqual(self.transport.pos, 1200) @unittest.expectedFailure def test_fail(self): self.assertEqual(1, 0, "broken")
def __init__(self, **kwargs): """ :param host: :param port: :param timeout: :param connect: :return: """ try: port = kwargs['port'] except KeyError: port = 7147 try: timeout = kwargs['timeout'] except KeyError: timeout = 10 katcp.CallbackClient.__init__(self, kwargs['host'], port, tb_limit=20, timeout=timeout, logger=LOGGER, auto_reconnect=True) Transport.__init__(self, **kwargs) self.system_info = {} self.unhandled_inform_handler = None self._timeout = timeout self.connect() LOGGER.info('%s: port(%s) created and connected.' % (self.host, port))
def __init__(self): Transport.__init__(self) self.sock = None self.srv_addr = None self.api_name = None self.token = None self.ids_sensor = {}
def __init__(self, jobname, compute_nodes, replicas): #changed on 12/1/14 # jobname: identifies current asyncRE job # compute_nodes: list of names of nodes in the pool # nreplicas: number of replicas, 0 ... nreplicas-1 Transport.__init__(self) #WFF - 2/18/15 self.logger = logging.getLogger( "async_re.ssh_transport") #WFF - 3/2/15 # names of compute nodes (slots) self.compute_nodes = compute_nodes #changed on 12/1/14 self.nprocs = len(self.compute_nodes) # node status = None if idle # Otherwise a structure containing: # replica number being executed # process id # process name # ... self.node_status = [None for k in range(self.nprocs)] # contains the nodeid of the node running a replica # None = no information about where the replica is running self.replica_to_job = [None for k in replicas] # implements a queue of jobs from which to draw the next job # to launch self.jobqueue = Queue.Queue()
def __init__(self, jobname, compute_nodes, replicas): #changed on 12/1/14 # jobname: identifies current asyncRE job # compute_nodes: list of names of nodes in the pool # nreplicas: number of replicas, 0 ... nreplicas-1 Transport.__init__(self) #WFF - 2/18/15 self.logger = logging.getLogger("async_re.ssh_transport") #WFF - 3/2/15 # names of compute nodes (slots) self.compute_nodes = compute_nodes #changed on 12/1/14 self.nprocs = len(self.compute_nodes) #self.openmm_platform = None # node status = None if idle # Otherwise a structure containing: # replica number being executed # process id # process name # ... self.node_status = [ None for k in range(self.nprocs)] #self.openmm_platform = None # contains the nodeid of the node running a replica # None = no information about where the replica is running self.replica_to_job = [ None for k in replicas ] # implements a queue of jobs from which to draw the next job # to launch self.jobqueue = Queue.Queue()
def main(): random.seed(0) d = Driver() t = Transport(d, isServer=False) services = Services(t) s = services.getService(TEST_ADDRESS) for i in itertools.count(1): #totalFrags = random.randrange(1, 2**16 - 1) totalFrags = random.randrange(1, 500) #totalFrags = 1000 requestBuffer = Buffer(['a' * t.dataPerFragment() for j in range(totalFrags)]) responseBuffer = Buffer() start = gettime() r = t.clientSend(s, requestBuffer, responseBuffer) r.getReply() elapsedNs = gettime() - start resp = responseBuffer.getRange(0, responseBuffer.getTotalLength()) req = requestBuffer.getRange(0, requestBuffer.getTotalLength()) assert len(req) == len(resp), (len(req), len(resp), req[:10], resp[:10], req[-10:], resp[-10:]) assert req == resp, (req, resp) print print "Message %d with %d frags OK in %dms" % (i, totalFrags, elapsedNs / 1000000) d.stat()
class Mailgun(object): def __init__(self, domain, api_key): self._client = Transport(domain, api_key) def get(self, action, *args, **kwargs): """ HTTP GET method """ return self._client.process(action, "get", *args, **kwargs) def post(self, action, *args, **kwargs): """ HTTP POST method """ return self._client.process(action, "post", *args, **kwargs) def delete(self, action, *args, **kwargs): """ HTTP DELETE method """ return self._client.process(action, "delete", *args, **kwargs) def put(self, action, *args, **kwargs): """ HTTP PUT method """ return self._client.process(action, "put", *args, **kwargs)
def main(): random.seed(0) d = Driver() t = Transport(d, isServer=False) services = Services(t) s = services.getService(TEST_ADDRESS) for i in itertools.count(1): #totalFrags = random.randrange(1, 2**16 - 1) totalFrags = random.randrange(1, 500) #totalFrags = 1000 requestBuffer = Buffer( ['a' * t.dataPerFragment() for j in range(totalFrags)]) responseBuffer = Buffer() start = gettime() r = t.clientSend(s, requestBuffer, responseBuffer) r.getReply() elapsedNs = gettime() - start resp = responseBuffer.getRange(0, responseBuffer.getTotalLength()) req = requestBuffer.getRange(0, requestBuffer.getTotalLength()) assert len(req) == len(resp), (len(req), len(resp), req[:10], resp[:10], req[-10:], resp[-10:]) assert req == resp, (req, resp) print print "Message %d with %d frags OK in %dms" % (i, totalFrags, elapsedNs / 1000000) d.stat()
def main(): d = Driver(TEST_ADDRESS) t = Transport(d, isServer=True) while True: r = t.serverRecv() r.replyPayload.extend(r.recvPayload) r.sendReply() d.stat()
def __init__(self, target_descriptor, signed=True, flush_trigger=1): ''' target_descriptor must be an ESDescriptor''' self.transport = Transport(signed) self.target_descriptor = target_descriptor self.flush_trigger = flush_trigger self.buffer = ESLineBuffer(target_descriptor.es_index, target_descriptor.es_type)
class TestTransport2(unittest.TestCase): def setUp(self): self.transport = Transport(speed=120) def test_drive(self): self.transport.drive(10) self.assertEqual(self.transport.pos, 1200)
def run(self): # parameters Sim.scheduler.reset() Sim.set_debug('AppHandler') Sim.set_debug('TCP') # setup network net = Network('../networks/setup.txt') net.loss(self.loss) # setup routes n1 = net.get_node('n1') n2 = net.get_node('n2') n1.add_forwarding_entry(address=n2.get_address('n1'), link=n1.links[0]) n2.add_forwarding_entry(address=n1.get_address('n2'), link=n2.links[0]) # setup transport t1 = Transport(n1) t2 = Transport(n2) # setup application a = AppHandler(self.filename, self.out_directory) # setup connection c1 = TCP(t1, n1.get_address('n2'), 1, n2.get_address('n1'), 1, a, window=self.window) c2 = TCP(t2, n2.get_address('n1'), 1, n1.get_address('n2'), 1, a, window=self.window) # send a file with open(self.in_directory + '/' + self.filename, 'r') as f: while True: data = f.read(10000) if not data: break Sim.scheduler.add(delay=0, event=data, handler=c1.send) # run the simulation Sim.scheduler.run() # print str(self.window) + " & " + \ # str(Sim.scheduler.current_time()) + " & " + \ # str(4116160.0 / float(Sim.scheduler.current_time())) + " & " + \ # str(c2.totalQueueingDelay / float(c1.totalPacketsSent)) + " \\\\" # print str(self.window) + "," + str(4116160.0 / float(Sim.scheduler.current_time())) print str(self.window) + "," + str( c2.totalQueueingDelay / float(c1.totalPacketsSent))
def __init__(self, debug=False, verbose=False): self.client.login() if verbose: self.log.basicConfig(level=self.log.INFO) if debug: self.log.basicConfig(level=self.log.DEBUG) Transport.__init__(self, self.client, self.log) NetworkServices.__init__(self, self.client, self.log) ControlServices.__init__(self, self.client, self.log)
def setScheduler(self, sched): """ Intercept setting of scheduler so we know when to start our periodic timer """ Transport.setScheduler(self, sched) # Alefiya: added sendStatus every 10 second in again # the first status message is jittered across all the nodes # Not sure if the jitter is a good idea for aggregation purposes #jitter = random.randint(0,20) #self.sched.sched_relative(30+jitter,self.sendStatus) self.sendStatus()
def __init__(self, jobname, nreplicas): Transport.__init(self) self.logger = logging.getLogger("asyncre.condor_transport") self.jobname = jobname self.user_name = os.environ['USER'] self.replica_to_jobid = [None for k in range(nreplicas)] self.replica_status = dict()
def __init__(self, **kwargs): """ Make a Dummy Transport :param host: IP Address should be 127.0.0.1 for a Dummy """ Transport.__init__(self, **kwargs) self._devices = NamedFifo(100) self._devices_wishbone = NamedFifo(100) LOGGER.info('%s: port(%s) created and connected.' % (self.host, sd.ETHERNET_CONTROL_PORT_ADDRESS))
def __enter__(self): # Start transport layer self.socket = Transport() self.socket.connect((self.server_name, self.port)) # Start SSH connection self.version_exchange() self.key_exchange() self.init_authentication() return self
def __init__(self, udpc, logger: Logger, name="Ana", parent=None): super().__init__(logger=logger, parent=parent) self.udpc = udpc self.addr = QHostAddress(udpc.addr) self.port = udpc.port self.transport = Transport() self.socket = QUdpSocket(self) self.socket.bind(QHostAddress(udpc.local_addr), udpc.local_port) self.rid = udpc.rid self.add_rid(udpc.rid) self.name = name
def __init__(self, sock = None, codec=DefaultCodec): """ Create a new TCP Transport. If sock is provided, it is used, otherwise starts with an unconnected socket. """ Transport.__init__(self, sock=sock, codec=codec) self.closed = False if not sock: self.connected = False self.txMessage = TXTracker(codec=self.codec) self.rxMessage = RXTracker(codec=self.codec)
def __init__(self, **kwargs): """ Initialized Tapcp FPGA object :param host: IP Address of the targeted Board :return: none """ Transport.__init__(self, **kwargs) self.t = tftpy.TftpClient(kwargs['host'], 69) self._logger = LOGGER self.timeout = kwargs.get('timeout', 3)
def initialize(self): if not self.__configured: raise RuntimeError('robot has not been configured.') try: self.__transport = Transport(self.__port, self.__baudrate) except: print("serial initialization failed") raise RuntimeError("Robot init failed. Check configuration.") self.__proc = threading.Thread(name='robot process', target=self.__run) self.__proc.setDaemon(True) self.robot_status = RobotStatus(self.__num_joints) self.__initialized = True
def __init__(self): self.command_map = { 'login': self.login, 'create': self.create, 'join': self.join, 'leave': self.leave, 'raise': self.raise_bet, 'fold': self.fold, 'call': self.call, } self.card_suit_map = { 1: SPADES, 2: HEARTS, 3: DIAMONDS, 4: CLUBS, } self.card_value_map = { 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9', 10: '10', 11: 'J', 12: 'Q', 13: 'K', 14: 'A', } self.round_status_map = { 0: 'Unknown', 1: 'Begining', 2: 'Preflop', 3: 'Flop', 4: 'Turn', 5: 'River', 6: 'End', } self.table_status_map = { 0: 'Unknown', 1: 'Waiting for players', 2: 'Game in progress', 3: 'Game ended', } self.transport = Transport(HOST, PORT) self.working_flag = False
class RadioUDP(QObject, AbstractRadio): """ Radio protobuf over UDP """ def __init__(self, udpc, logger: Logger, name="Ana", parent=None): super().__init__(logger=logger, parent=parent) self.udpc = udpc self.addr = QHostAddress(udpc.addr) self.port = udpc.port self.transport = Transport() self.socket = QUdpSocket(self) self.socket.bind(QHostAddress(udpc.local_addr), udpc.local_port) self.rid = udpc.rid self.add_rid(udpc.rid) self.name = name def start(self): self.emit_msg(self.rid, m.Message()) self.socket.readyRead.connect(self.read_datagrams) def stop(self): self.socket.close() def read_datagrams(self): while self.socket.hasPendingDatagrams(): datagram = self.socket.receiveDatagram() data = datagram.data().data() msg = self.transport.put(data) if msg is not None: # print(msg, data) self.handle_umsg(msg) d = self.msg_to_dict(self.rid, msg) self.log_dict(self.name, d) def handle_umsg(self, msg): self.emit_msg(self.rid, msg) @staticmethod def msg_to_dict(src, msg): msg_name = msg.WhichOneof('inner') inner = getattr(msg, msg_name) d_msg = {msg_name: {}} for f in inner.DESCRIPTOR.fields: field_name = f.name d_msg[msg_name][field_name] = getattr(inner, field_name) d = {src: d_msg} return d def send_msg(self, rid, msg: m.Message): if msg.WhichOneof("inner") in self.udpc.allowed: data = self.transport.serialize(msg) self.socket.writeDatagram(data, self.addr, self.port)
def __init__(self, jobname, nreplicas): Transport.__init__(self) self.logger = logging.getLogger("async_re.condor_transport") self.jobname = jobname self.user_name = os.environ['USER'] self.replica_to_jobid = [None for k in range(nreplicas)] self.replica_status = dict() """ Template for Condor submit description file """ self.condor_submit_file = """+ProjectName = "TG-MCB150001"
def __init__(self, **kwargs): """ Initialized Tapcp FPGA object :param host: IP Address of the targeted Board :return: none """ Transport.__init__(self, **kwargs) self.t = tftpy.TftpClient(kwargs['host'], 69) self._logger = LOGGER self.timeout = kwargs.get( 'timeout', 1.2) # long enough to account for Flash erases self.server_timeout = 4 # Microblaze timeout period self.retries = kwargs.get('retries', 8)
def main(): transport = Transport() print(""" [*] Choose your option : 1) Change state 2) List vehicles in current state 3) Select next vehicle in current state 4) Quit (or Ctrl+C) """) while (True): try: i = int(input(">>> ")) if i == 1: transport.toggle_wheels() elif i == 2: transport.listVehicles() elif i == 3: transport.selectNextVehicle() elif i == 4: print("[-] Exiting ...") break else: print("[-] Invalid option") except KeyboardInterrupt: print("\n[-] Exiting ...") break
def initialize(self): if not self.__configured: print('[Error] Robot has not been configured.') return False try: self.__transport = Transport(self.__port, self.__baudrate) except: print("[Error] Serial initialization failed. \n ***** Check serial settings.") return False self.__proc = threading.Thread(name='robot process', target=self.__run) self.__proc.setDaemon(True) self.robot_status = RobotStatus(self.__num_joints) self.__initialized = True return True
def transfer(self, count, request, data=[0], dap_index=0): cmd = [] cmd.append(COMMAND_ID['DAP_TRANSFER']) cmd.append(dap_index) cmd.append(count) count_write = count for i in range(count): cmd.append(request[i]) if not (request[i] & ((1 << 1) | (1 << 4))): cmd.append(data[i] & 0xff) cmd.append((data[i] >> 8) & 0xff) cmd.append((data[i] >> 16) & 0xff) cmd.append((data[i] >> 24) & 0xff) count_write -= 1 self.interface.write(cmd) resp = self.interface.read() if resp[0] != COMMAND_ID['DAP_TRANSFER']: raise ValueError('DAP_TRANSFER response error') if resp[2] != DAP_TRANSFER_OK: if resp[2] == DAP_TRANSFER_FAULT: raise Transport.TransferError() raise ValueError('SWD Fault') # Check for count mismatch after checking for DAP_TRANSFER_FAULT # This allows TransferError to get thrown instead of ValueError if resp[1] != count: raise ValueError('Transfer not completed') return resp[3:3 + count_write * 4]
def __init__(self, tracks=None, devices=None, transport=None, view_scale=None, units=None, patch_bay=None): Model.__init__(self) # the file path to save to self.path = None # transport if (transport is None): transport = Transport() self.transport = transport # time scale if (view_scale is None): view_scale = ViewScale() self.view_scale = view_scale # devices if (devices is None): devices = DeviceAdapterList() self.devices = devices # a list of units on the workspace if (units is None): units = UnitList() self.units = units self.units.add_observer(self.on_change) self.units.add_observer(self.update_transport_duration) self.update_transport_duration() # a list of connections between units if (patch_bay is None): patch_bay = PatchBay() self.patch_bay = patch_bay self.patch_bay.add_observer(self.on_change)
def __init__(self, **kwargs): """ Initialized Tapcp FPGA object :param host: IP Address of the targeted Board :return: none """ Transport.__init__(self, **kwargs) self.t = tftpy.TftpClient(kwargs['host'], 69) self._logger = LOGGER self.timeout = kwargs.get('timeout', 0.025) # 1/4 the timeout of the MB self.server_timeout = 0.1 # Microblaze timeout period. So that if a command fails we can wait for the microblaze to terminate the connection before retrying self.retries = kwargs.get( 'retries', 8 ) # These are retries of a complete transaction (each of which has it's ofw TFTP retries).
class Client: def __init__(self): self.transport = None self.torrents = {} self.torrent_keys = ['queue', 'name', 'total_size', 'state', 'progress', 'num_seeds', 'files', 'download_payload_rate', 'upload_payload_rate'] self.session_keys = ['download_rate', 'payload_download_rate', 'upload_rate', 'payload_upload_rate'] def connect(self, host="127.0.0.1", port=58846, username="", password=""): self.transport = Transport(host, port) try: r = self.transport.login(username, password) except Exception, e: print "login failed", e self.transport = None return False print "login infor is r", r print "Protocol version", self.transport.daemon_info() for event, handler in [ ('TorrentStateChangedEvent', self._on_torrent_state_changed), ('TorrentRemovedEvent', self._on_torrent_removed), ('TorrentAddedEvent', self._on_torrent_added)]: if not self.transport.register_event_handler(event, handler): print "Failed to register handler", event, handler self.torrents = self.transport.torrent_status(None, self.torrent_keys) return True
class Client: def __init__(self, user): self.user = user self.ip = str(54) + '.' + str(random.randrange(0, 255)) + '.' + str(random.randrange(0, 255)) + '.' + str(random.randrange(0, 255)) self.connections = [] self.routerBuffer = [] self.inbox = {} self.transportLayer = Transport(self) self.applicationLayer = Application(self) # Adds a link between this client and another def addConnection(self, client): if client == self: return if client.ip in self.connections: return self.connections.append(client.ip) # Sends a message (tells the application layer to make a packet) def sendMessage(self, source, destination, message , time): applicationPacket = self.applicationLayer.generatePacket(time, source, destination, message) tcpPackets = self.transportLayer.process(applicationPacket, time) def __repr__(self): return self.ip def __str__(self): return self.ip + ' - ' + str(self.connections) + " => Router Buffer: " + str(self.routerBuffer) + " Inbox: " + str(self.inbox)
def __init__(self, url, user=None, password=None, token=None): """ Use 'user/password' for access to auth.token and auth.token2, otherwise use 'token'. Args: url: Url user: User password: Password token: Token """ self.transport = Transport(url, user, password, token) self.allowed_ports = AllowedPortsClient(self) self.auth = AuthClient(self) self.domains = DomainsClient(self) self.images = ImagesClient(self) self.ippool = IPPoolClient(self) self.nodes = NodesClient(self) self.pstorage = PStorageClient(self) self.pods = PodsClient(self) self.predefined_apps = PredefinedAppsClient(self) self.pricing = PricingClient(self) self.restricted_ports = RestrictedPortsClient(self) self.system_settings = SystemSettingsClient(self) self.users = UsersClient(self)
def __init__(self, user): self.user = user self.ip = str(54) + '.' + str(random.randrange(0, 255)) + '.' + str(random.randrange(0, 255)) + '.' + str(random.randrange(0, 255)) self.connections = [] self.routerBuffer = [] self.inbox = {} self.transportLayer = Transport(self) self.applicationLayer = Application(self)
def buildTransports(self): self.transports = [ Transport(str(i), self, self.env, DELAY_BETWEEN_TR * i, self.transport_info['capacity'], self.transport_info['stop_time']) for i in range(1, self.transport_info['count'] + 1) ] del self.transport_info
def connect(self, host="127.0.0.1", port=58846, username="", password=""): self.transport = Transport(host, port) try: r = self.transport.login(username, password) except Exception, e: print "login failed", e self.transport = None return False
def __init__(self, intf): self._intf = intf self._transport = Transport() self._id = None self._version = None self._polling = False self._connected = False self._ndefMessagePresent = False self._ndefRecords = None self._ndefRead = False
class Main(object): def __init__(self): self.monitor = None try: # instanciates the config self.config = Config() # exists baboon when receiving a sigint signal signal.signal(signal.SIGINT, self.sigint_handler) # Initialize the scm class to use scm_classes = Diffman.__subclasses__() for cls in scm_classes: tmp_inst = cls() if tmp_inst.scm_name == self.config.scm: self.diffman = tmp_inst # TODO verify self.diffman self.mediator = Mediator(self.diffman) self.transport = Transport(self.mediator) self.transport.open() self.monitor = Monitor(self.transport, self.diffman) self.monitor.watch() # TODO this won't work on windows... signal.pause() except BaboonException, err: sys.stderr.write("%s\n" % err) # Try to close the transport properly. If the transport is # not correctly started, the close() method has no effect. self.transport.close() # Same thing for the monitor if self.monitor: self.monitor.close() # Exits with a fail return code sys.exit(1)
def __init__(self, jobname, keywords, nreplicas, files_to_stage): # jobname: identifies current asyncRE job # files_to_stage: permanent files to stage into BOINC download directory (main struct file, datafiles, etc.) Transport.__init__(self) self.logger = logging.getLogger("async_re.boinc_transport") self.jobname = jobname # variables required for boinc-based transport if keywords.get('BOINC_PROJECTDIR') is None: self._exit("BOINC transport requires a BOINC_PROJECTDIR") self.project_dir = keywords.get('BOINC_PROJECTDIR') if not os.path.isdir(self.project_dir): self.logger.critical("Unable to located BOINC project directory: %s", self.project_dir) sys.exit(1) #sets up a mapping between replicas running and work unit ids self.replica_to_wuid = [ None for k in range(nreplicas)] #sets up lookup table for replica done status self.replica_status = dict() #set connection with mysql boinc server database if keywords.get('BOINC_DATABASE') is None: self.logger.critical("BOINC transport requires a BOINC_DATABASE") sys.exit(1) if keywords.get('BOINC_DATABASE_USER') is None: self.logger.critical("BOINC transport requires a BOINC_DATABASE_USER") sys.exit(1) if keywords.get('BOINC_DATABASE_PASSWORD') is None: self.logger.critical("BOINC transport requires a BOINC_DATABASE_PASSWORD") sys.exit(1) self.db_name = keywords.get('BOINC_DATABASE') self.db_user = keywords.get('BOINC_DATABASE_USER') self.db_pwd = keywords.get('BOINC_DATABASE_PASSWORD') # stage files if files_to_stage is not None: for file in files_to_stage: filepath = os.getcwd() + "/" + file self._stage_file(filepath,file)
class Player(object): auth_timeout = 5 def __init__(self, socket, address): self.transport = Transport(socket, address) self.host = address[0] self.port = address[1] self.health = 100 def close(self): self.transport.send(Message.exit().pack()) self.transport.close() def auth(self): recv = None with Timeout(Player.auth_timeout, PlayerError("Authentication timed out")): try: msg = self.transport.receive() except PlayerError as e: print("error on receive") print(e) return False try: msg = Message.parse(msg) except MessageError: print("bad message") return False if msg.type == "nick": self.name = msg.payload self.transport.send(Message.auth_success().pack()) return True return False def listen(self): return self.transport.receive() def send(self, msg): self.transport.send(msg)
def __init__(self, **params): self.params = params self.transport = Transport() self.reader = DelimitedReader("\r\n") self.reader.add_callback(self.new_line) self._services = [] for t in type(self).COMMON_SERVICES: self.add_service(t()) for i in self.services(): self.add_service(i) self.lock_many = threading.Lock() self.lock_single = threading.Lock() self.common_state = {"irc": self}
def __init__(self, **kwargs): """ Initialized Tapcp FPGA object :param host: IP Address of the targeted Board :return: none """ try: import tftpy global TFTPY TFTPY = tftpy except ImportError: raise ImportError('You need to install tftpy to use TapcpTransport') Transport.__init__(self, **kwargs) set_log_level(logging.ERROR) self.t = tftpy.TftpClient(kwargs['host'], 69) try: self.logger = kwargs['logger'] except KeyError: self.logger = logging.getLogger(__name__) new_connection_msg = '*** NEW CONNECTION MADE TO {} ***'.format(self.host) self.logger.info(new_connection_msg) self.timeout = kwargs.get('timeout', 3)
def __init__(self, intf): self._intf = intf self._transport = Transport() self._id = None self._version = None self._polling = False self._connected = False self._type2 = False self._type4 = False self._p2p = False self._initiator = False self._ndefPresent = False self._ndefRecords = None self._ndefRead = False self._ndefReadable = False self._ndefWriteable = False self._ndefBusy = False self._ndefSuccess = False
def connect(self): self.t = Transport(self.host, self.port, timeout=None, verbose=False) if not self.upgrade_connection(): raise ServerError('Unable to upgrade connection') self.log("Connected to {0}:{1}.".format(self.host, self.port)) response = self.send_init_request() if response.responseCode != 200: error_text = 'Wrong response from server, status_code={0}'.format( response.responseCode) if response.HasField("message"): error_text += ', message is "{0}"'.format(response.message) raise ServerError(error_text) self.session_id = response.sessionId self.log("session_id={0}".format(self.session_id)) return self.session_id
class IRCClient(object): COMMON_SERVICES = [IRCRules] def __init__(self, **params): self.params = params self.transport = Transport() self.reader = DelimitedReader("\r\n") self.reader.add_callback(self.new_line) self._services = [] for t in type(self).COMMON_SERVICES: self.add_service(t()) for i in self.services(): self.add_service(i) self.lock_many = threading.Lock() self.lock_single = threading.Lock() self.common_state = {"irc": self} # This is not persistent and transmitted as the sender for # events like IRC commands def update_common_state(self, newstate): self.common_state.update(newstate) def get_common_state(self): return self.common_state def services(self): """ Should return an Iterable of services initialized for the current instance. You should override this when subclassing IRCClient. """ return [] def loop(self): # Automates connect()/update() in a separate thread. self.looping = True self.state = load_state() threading.Thread(target = self._loop).start() def _loop(self): self.connect() while self.looping: time.sleep(0.01) self.update() def stop(self): dump_state(self.state) self.looping = False def connect(self): host, post = self.cfgget("host"), self.cfgget("port") self.transport.connect((host, post,)) for i in self._services: i.handle(self, messages.JustConnected()) def update(self): try: self.reader.update(self.transport) except TransportError: self.stop() def new_line(self, line): try: parsed = primitive.parse(line) print "Received line: %s" % line.strip() except primitive.UnknownMessageError: print "Received (but could not understand) line: %s" % line return for i in self._services: i.handle(self, parsed) def add_service(self, s): self._services.append(s) s.patch(self) def cfgget(self, name, default = NOPARAM): """ Gets the given configuration parameter. The following order of precedence is used to return the parameter in order to deal with cases where it is unspecified: 1. self.params[name] 2. default 3. default_params[name] 4. None """ try: return self.params[name] except KeyError: pass if default != NOPARAM: return default try: return default_params[name] except KeyError: pass return None def cfgset(self, name, value): self.params[name] = value def send(self, message): """ Sends a single message. This method is thread-safe: however, it's probably best to use sendmany if you're attempting to send a series of messages at once, so that unrelated send-multiple-messages requests don't intersect accidentally. """ with self.lock_single: out = message.write() print "Sending line: %s" % out self.transport.write(out + "\r\n") def sendmany(self, messages): """ Sends several messages at once. Because the bot is heavily threaded and threads are evil, it's probably best to call sendmany() instead of calling send multiple times when sending series of messages, so unrelated series don't occur at the same time. There's no danger of two messages sending inside of each other midstream, mind, as Transport.write() and self.send() are both highly thread-safe. """ with self.lock_many: for i in messages: self.send(i) def quit(self, message = None): q = messages.QuitMessage.create() q["text"] = message self.send(q) self.stop() """ Most IRC messages are not wrapped in order to encourage users to use threadsafe ones like sendmany. """ def status(self, text): """ You should override this in an IRC subclass as a default 'send some message' routine. """ pass def error(self, text): """ A special version of status() to be used with errors. By default this just prepends ERROR: to the message and calls status(). You can override this. """ self.status("ERROR: %s" % text)
def __init__(self, mode, applications, own_ip): Transport.__init__(self, mode, applications, own_ip) self.connection = Connection self.name = 'UDP' self.socktype = SOCK_DGRAM self.server = Udpserver
def connect(self): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((self.host, self.port)) print dir(sock) self.transport = Transport(sock, (self.host, self.port))
class Client(Greenlet): def __init__(self, host, port, nick): Greenlet.__init__(self) self.host = host self.port = port self.name = nick def _run(self): self.connect() if not self.auth(): self.exit("Could not connect to server") print("Auth successful") self.opponent = self.opponent_wait() self.start_wait() self.play() def wait(self, msg_type): """ Waits for a specific message type, then returns the received message """ while True: rec = self.transport.receive() try: msg = Message.parse(rec) except MessageError: continue if msg.type == msg_type: return msg def opponent_wait(self): msg = self.wait('opponent') return msg.payload def start_wait(self): while True: msg = self.wait('game') if msg.payload == 'start': break def play(self): sensor = gevent.spawn(self.handle_punch) sensor.join() def handle_punch(self): while True: gevent.sleep(7) #print "sending punch" self.transport.send(Message.punch().pack()) def exit(self, msg): print(msg) raise GreenletExit def connect(self): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((self.host, self.port)) print dir(sock) self.transport = Transport(sock, (self.host, self.port)) def auth(self): self.transport.send(Message.nick(self.name).pack()) data = self.transport.receive() try: msg = Message.parse(data) except MessageError: return False if msg.type == 'auth' and msg.payload == 'success': return True else: return False
class ServerConnection(object): def __init__(self, host, port, key, app, service, topic, lang, format, logger=None, punctuation=True): self.host = host self.port = port self.key = key self.app = app self.topic = topic self.service = service self.lang = lang self.format = format self.uuid = randomUuid().hex self.logger = logger self.punctuation = punctuation self.log("uuid={0}".format(self.uuid)) self.session_id = "" self.connect() def log(self, message): if self.logger is not None: self.logger.info(message) def connect(self): self.t = Transport(self.host, self.port, timeout=None, verbose=False) if not self.upgrade_connection(): raise ServerError('Unable to upgrade connection') self.log("Connected to {0}:{1}.".format(self.host, self.port)) response = self.send_init_request() if response.responseCode != 200: error_text = 'Wrong response from server, status_code={0}'.format( response.responseCode) if response.HasField("message"): error_text += ', message is "{0}"'.format(response.message) raise ServerError(error_text) self.session_id = response.sessionId self.log("session_id={0}".format(self.session_id)) return self.session_id def send_init_request(self): request = ConnectionRequest( speechkitVersion='Not Speechkit', serviceName=self.service, uuid=self.uuid, apiKey=self.key, applicationName=self.app, device='desktop', coords='0, 0', topic=self.topic, lang=self.lang, format=self.format, punctuation=self.punctuation) self.t.sendProtobuf(request) return self.t.recvProtobuf(ConnectionResponse) def upgrade_connection(self): logger = logging.getLogger('arslib') request = ('GET /asr_partial_checked HTTP/1.1\r\n' 'User-Agent: {user_agent}\r\n' 'Host: {host}:{port}\r\n' 'Upgrade: {service}\r\n\r\n').format( user_agent=self.app, host=self.host, port=self.port, service=self.service) self.t.send(request) check = 'HTTP/1.1 101 Switching Protocols' buffer = '' # possible infinite loop here? while True: buffer += self.t.recv(1) if buffer.startswith(check) and buffer.endswith('\r\n\r\n'): return True if len(buffer) > 300: logger.warning(buffer) return False def close(self): self.session_id = "" self.t.close() def reconnect(self, delay=None): self.log('Reconnecting!') self.close() if delay is not None: self.log('Going to sleep for {0} seconds'.format(delay)) time.sleep(delay) self.connect() def add_data(self, chunk): if chunk is None: self.t.sendProtobuf(AddData(lastChunk=True)) else: self.t.sendProtobuf(AddData(lastChunk=False, audioData=chunk)) def get_utterance_if_ready(self): response = self.t.recvProtobufIfAny(AddDataResponse) if response is not None: if response.responseCode != 200: error_text = 'Wrong response from server, status_code={0}'.format( response.responseCode) if response.HasField("message"): error_text += ', message is "{0}"'.format(response.message) raise ServerError(error_text) self.log("got response: endOfUtt={0}; len(recognition)={1}".format(response.endOfUtt, len(response.recognition))) if len(response.recognition) == 0: return "", response.messagesCount text = response.recognition[0].normalized.encode('utf-8') merged = response.messagesCount self.log("partial result: {0}; merged={1}".format(text, merged)) if response.endOfUtt: return text, merged else: return "", response.messagesCount return None, 0
class MicroNFCBoard(object): @staticmethod def getBoard(number = 0): a = INTERFACE[usb_backend].getAllConnectedInterface(VID, PID) if((a != None) and (len(a) > number)): return MicroNFCBoard(a[number]) return None @staticmethod def getAllBoards(): return [MicroNFCBoard(i) for i in INTERFACE[usb_backend].getAllConnectedInterface(VID, PID)] def __init__(self, intf): self._intf = intf self._transport = Transport() self._id = None self._version = None self._polling = False self._connected = False self._ndefMessagePresent = False self._ndefRecords = None self._ndefRead = False def open(self): self._transport.open(self._intf) version, revision, self._id = self._transport.info() self._version = (version, revision) def close(self): self._transport.close() @property def id(self): return self._id @property def connected(self): self._updateStatus() return self._connected @property def polling(self): self._updateStatus() return self._polling @property def ndefMessagePresent(self): self._updateStatus() return self._ndefMessagePresent @property def ndefRecords(self): self._updateStatus() if self._ndefMessagePresent and not self._ndefRead: self._ndefRecords = self._getNdefMessageRecords() self._ndefRecordsRead = True return self._ndefRecords @property def version(self): return self._version def getNfcInfo(self): return self._transport.nfcGetInfo() def reset(self): self._transport.reset(False) def startPolling(self): self._transport.nfcPoll(True) def stopPolling(self): self._transport.nfcPoll(True) def setLeds(self, led1, led2): self._transport.leds(led1, led2) def _updateStatus(self): status = self._transport.status() self._polling = (status & STATUS_POLLING) != 0 self._connected = (status & STATUS_CONNECTED) != 0 self._ndefMessagePresent = (status & STATUS_NDEF_PRESENT) != 0 if not self._ndefMessagePresent: self._ndefRecordsRead = False def _getNdefRecords(self, start, count): records = [] for recordNumber in range(start, start+count): #Get records info recordType, recordInfo = self._transport.nfcGetRecordInfo(recordNumber) funcs = { 0 : self._parseUnknownRecord, 1 : self._parseURIRecord, 2 : self._parseTextRecord, 3 : self._parseSmartPosterRecord, 4 : self._parseMIMERecord, } record = funcs[recordType](recordNumber, recordInfo) if record != None: records += [record] return records def _getNdefMessageRecords(self): #Get message count recordsCount = self._transport.nfcGetMessageInfo() return self._getNdefRecords(0, recordsCount) def _parseUnknownRecord(self, recordNumber, recordInfo): return None def _parseURIRecord(self, recordNumber, recordInfo): uriLength = recordInfo[0] uri = unicode(self._getRecordData(recordNumber, 0, uriLength).tostring(), "utf-8") return URIRecord(uri) def _parseTextRecord(self, recordNumber, recordInfo): encoding = TEXT_ENCODING[recordInfo[0]] languageCodeLength = recordInfo[1] textLength = recordInfo[2] languageCode = unicode(self._getRecordData(recordNumber, 0, languageCodeLength).tostring(), "utf-8") text = unicode(self._getRecordData(recordNumber, 1, textLength).tostring(), encoding) return TextRecord(text, languageCode) def _parseSmartPosterRecord(self, recordNumber, recordInfo): recordsStart = recordInfo[0] recordsCount = recordInfo[1] records = self._getNdefRecords(recordsStart, recordsCount) return SmartPosterRecord(records) def _parseMIMERecord(self, recordNumber, recordInfo): mimeTypeLength = recordInfo[0] dataLength = recordInfo[1] mimeType = unicode(self._getRecordData(recordNumber, 0, mimeTypeLength).tostring(), "utf-8") data = self._getRecordData(recordNumber, 1, dataLength) return MIMERecord(mimeType, data) def _getRecordData(self, recordNumber, item, itemLength): buf = array("B") while len(buf) < itemLength: chunkLength = min(CHUNK_SIZE, itemLength - len(buf)) buf += self._transport.nfcGetRecordData(recordNumber, item, len(buf), chunkLength) return buf
def transportJob( self, callback, *arg ): QHelper.log( '::ASYNC:CONNECT:TRANSPORT:' + callback, *arg ) assert callback != 'execute' Transport.execute( callback, *arg )
class ServerConnection(object): def __init__(self, host, port, key, app, service, topic, lang, format, uuid, inter_utt_silence, cmn_latency, logger=None, punctuation=True, ipv4=False, capitalize=False, expected_num_count=0): self.host = host self.port = port self.key = key self.app = app self.topic = topic self.service = service self.lang = lang self.format = format self.uuid = uuid self.logger = logger self.punctuation = punctuation self.inter_utt_silence = inter_utt_silence self.cmn_latency = cmn_latency self.ipv4 = ipv4 self.capitalize = capitalize self.expected_num_count = expected_num_count self.log("uuid={0}".format(self.uuid)) self.session_id = "not-set" self.connect() def log(self, message): if self.logger is not None: self.logger.info(message) def connect(self): self.t = Transport(self.host, self.port, timeout=None, verbose=False, enable_ssl=(self.port==443), ipv4=self.ipv4) if not self.upgrade_connection(): raise ServerError('Unable to upgrade connection') self.log("Connected to {0}:{1}.".format(self.host, self.port)) response = self.send_init_request() if response.responseCode != 200: error_text = 'Wrong response from server, status_code={0}'.format( response.responseCode) if response.HasField("message"): error_text += ', message is "{0}"'.format(response.message) raise ServerError(error_text) self.session_id = response.sessionId self.log("session_id={0}".format(self.session_id)) return self.session_id def send_init_request(self): request = ConnectionRequest( speechkitVersion='', serviceName=self.service, uuid=self.uuid, apiKey=self.key, applicationName=self.app, device='desktop', coords='0, 0', topic=self.topic, lang=self.lang, format=self.format, punctuation=self.punctuation, advancedASROptions=AdvancedASROptions( utterance_silence=int(self.inter_utt_silence), cmn_latency=self.cmn_latency, capitalize=self.capitalize, expected_num_count=self.expected_num_count, biometry="children", ) ) self.t.sendProtobuf(request) return self.t.recvProtobuf(ConnectionResponse) def upgrade_connection(self): logger = logging.getLogger('arslib') request = ('GET /asr_partial_checked HTTP/1.1\r\n' 'User-Agent: {user_agent}\r\n' 'Host: {host}:{port}\r\n' 'Upgrade: {service}\r\n\r\n').format( user_agent=self.app, host=self.host, port=self.port, service=self.service) self.t.send(request) check = 'HTTP/1.1 101 Switching Protocols' buffer = '' # possible infinite loop here? while True: buffer += self.t.recv(1) if buffer.startswith(check) and buffer.endswith('\r\n\r\n'): return True if len(buffer) > 300: logger.warning(buffer) return False def close(self): self.session_id = "" self.t.close() def reconnect(self, delay=None): self.log('Reconnecting!') self.close() if delay is not None: self.log('Going to sleep for {0} seconds'.format(delay)) time.sleep(delay) self.connect() def add_data(self, chunk): if chunk is None: self.t.sendProtobuf(AddData(lastChunk=True)) else: self.t.sendProtobuf(AddData(lastChunk=False, audioData=chunk)) def get_response_if_ready(self): response = self.t.recvProtobufIfAny(AddDataResponse) if response is not None: if response.responseCode != 200: error_text = 'Wrong response from server, status_code={0}'.format( response.responseCode) if response.HasField("message"): error_text += ', message is "{0}"'.format(response.message) raise ServerError(error_text) return response
def __init__(self, domain, api_key): self._client = Transport(domain, api_key)
def __init__(self, auto_gen=False): Transport.__init__(self) self.comm = MCUComm() self.wrote = "" self.ans_buff = "" self.auto_gen = auto_gen