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