def __init__(self):
# init ROS node
rospy.init_node("holo_tf_receiver", anonymous=True)
self.server_ = TcpServer(host="192.168.1.152", port=12345)
self.pub_ = rospy.Publisher('holo_transform',
HoloTransform,
queue_size=10)
# call self.server_.stop before node destroied
rospy.on_shutdown(self.server_.stop)
def test_server(self):
af_inet = AF_INET
sock_stream = SOCK_STREAM
sol_socket = SOL_SOCKET
so_reuseaddr = SO_REUSEADDR
with mock.patch("tcp_server.socket") as mock_socket, \
mock.patch("tcp_server.ClientThread", spec=True) as mock_ClientThread:
host = 'localhost'
port = 5555
tcp_server = TcpServer(host=host, port=port)
self.assertEqual(tcp_server.host, host)
self.assertEqual(tcp_server.port, port)
self.assertIsNone(tcp_server._socket)
self.assertFalse(tcp_server._runnning)
def accept_stub():
ca = [("conn1", "addr1"), ("conn2", "addr2"), ("conn3", "addr3")]
for i in range(len(ca)):
if i == 2:
tcp_server.stop()
yield ca[i]
s_socket = mock.Mock(name="s_sock")
s_socket.accept.side_effect = accept_stub()
mock_socket.socket.return_value = s_socket
mock_socket.AF_INET = af_inet
mock_socket.SOCK_STREAM = sock_stream
mock_socket.SOL_SOCKET = sol_socket
mock_socket.SO_REUSEADDR = so_reuseaddr
tcp_server.run()
mock_socket.socket.assert_called_once_with(af_inet, sock_stream)
tcp_server._socket.setsockopt.assert_called_once_with(sol_socket, so_reuseaddr, 1)
tcp_server._socket.bind.assert_called_once_with((host, port))
tcp_server._socket.listen.assert_called_once_with(5)
self.assertFalse(tcp_server._runnning)
self.assertEqual(tcp_server._socket.accept.call_count, 3)
self.assertEqual(mock_ClientThread.call_count, 3)
inst_client_thread = mock_ClientThread("stub", "stub")
self.assertEqual(inst_client_thread.start.call_count, 3)
tcp_server._socket.close.assert_called_once()
def __init__(self):
# init ROS node
rospy.init_node("holo_sensor_receiver", anonymous=True)
self.server_ = TcpServer(
# get from private domain ~
host=rospy.get_param("~host", default="192.168.1.152"),
port=rospy.get_param("~port", default=8800))
self.pub_ = rospy.Publisher("image_topic", Image, queue_size=5)
self.bridge_ = CvBridge()
# self.pub_ = rospy.Publisher('holo_transform', HoloTransform, queue_size=10)
# call self.server_.stop before node destroied
rospy.on_shutdown(self.server_.stop)
def send_serial_client(arduino_conn, arduino_queue, running):
while running:
if not arduino_queue.empty():
arduino_conn.send(arduino_queue.get())
if __name__ == "__main__":
running = True
pc_queue = Queue.Queue()
android_queue = Queue.Queue()
arduino_queue = Queue.Queue()
pc_conn = TcpServer("192.168.7.1", 77)
android_conn = BtServer(4)
arduino_conn = SerialClient("/dev/ttyACM0", 9600)
# arduino_conn = SerialClient("/dev/ttyAMA0", 9600)
t1 = threading.Thread(target=run_tcp_server,
args=(pc_conn, android_queue, arduino_queue, running))
t2 = threading.Thread(target=run_bt_server,
args=(android_conn, pc_queue, arduino_queue, running))
t3 = threading.Thread(target=run_serial_client,
args=(arduino_conn, pc_queue, running))
t4 = threading.Thread(target=send_tcp_server,
args=(pc_conn, pc_queue, running))
t5 = threading.Thread(target=send_bt_server,
args=(android_conn, android_queue, running))
}
################################################################################
# Main #
################################################################################
script_name = os.path.basename(sys.argv[0])
if len(sys.argv) != 2:
print_usage(script_name)
sys.exit(-1)
service_name = sys.argv[1]
if service_name not in service_table:
print_usage(script_name)
sys.exit(-1)
try:
init_logger(log_file_name, log_max_bytes, log_backup_count)
logger = logging.getLogger()
logger.info(f'SW version: {sw_version}')
tcp_server = TcpServer("svc-server")
tcp_server.run(port, ClientHandlerFactory(service_table[service_name]))
except Exception as ex:
logger.error(traceback.format_exc())
finally:
logger.info('Server stopped.')
logging.shutdown()
sys.exit('File torrent not exists')
torrent_file_data = parse_torrent_file(args.torrent_file_path)
info_hash = hashlib.sha1(
json.dumps(torrent_file_data['info']).encode('utf-8')).hexdigest()
my_id = ''.join(
random.choice(string.ascii_letters + string.digits)
for i in range(PEER_ID_SIZE))
main_controller = MainController.start(my_id, info_hash, torrent_file_data,
args.seeder)
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((socket.gethostname(), 0))
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.listen(5)
tracker_client = TrackerClient(my_id, info_hash,
server_socket.getsockname()[0],
server_socket.getsockname()[1],
torrent_file_data['tracker_ip'],
torrent_file_data['tracker_port'],
main_controller)
tracker_client.daemon = True
tracker_client.start()
tcp_server = TcpServer(info_hash, server_socket, main_controller)
tcp_server.daemon = True
tcp_server.start()
def __init__(self, selfNodeAddr, otherNodesAddrs, conf=None):
if conf is None:
self.__conf = SyncObjConf()
else:
self.__conf = conf
self.__conf.validate()
if self.__conf.password is not None:
if not HAS_CRYPTO:
raise ImportError("Please install 'cryptography' module")
self.__encryptor = getEncryptor(self.__conf.password)
else:
self.__encryptor = None
self.__selfNodeAddr = selfNodeAddr
self.__otherNodesAddrs = otherNodesAddrs
self.__unknownConnections = {} # descr => _Connection
self.__raftState = _RAFT_STATE.FOLLOWER
self.__raftCurrentTerm = 0
self.__votedFor = None
self.__votesCount = 0
self.__raftLeader = None
self.__raftElectionDeadline = time.time() + self.__generateRaftTimeout(
)
self.__raftLog = createJournal(self.__conf.journalFile)
if len(self.__raftLog) == 0:
self.__raftLog.add(_bchr(_COMMAND_TYPE.NO_OP), 1,
self.__raftCurrentTerm)
self.__raftCommitIndex = 1
self.__raftLastApplied = 1
self.__raftNextIndex = {}
self.__raftMatchIndex = {}
self.__lastSerializedTime = time.time()
self.__lastSerializedEntry = None
self.__forceLogCompaction = False
self.__leaderCommitIndex = None
self.__onReadyCalled = False
self.__changeClusterIDx = None
self.__noopIDx = None
self.__destroying = False
self.__startTime = time.time()
globalDnsResolver().setTimeouts(self.__conf.dnsCacheTime,
self.__conf.dnsFailCacheTime)
self.__serializer = Serializer(self.__conf.fullDumpFile,
self.__conf.logCompactionBatchSize,
self.__conf.useFork,
self.__conf.serializer,
self.__conf.deserializer,
self.__conf.serializeChecker)
self.__isInitialized = False
self.__lastInitTryTime = 0
self._poller = createPoller(self.__conf.pollerType)
host, port = selfNodeAddr.split(':')
self.__server = TcpServer(
self._poller,
host,
port,
onNewConnection=self.__onNewConnection,
sendBufferSize=self.__conf.sendBufferSize,
recvBufferSize=self.__conf.recvBufferSize,
connectionTimeout=self.__conf.connectionTimeout)
self._methodToID = {}
self._idToMethod = {}
methods = sorted([m for m in dir(self) if callable(getattr(self, m))])
for i, method in enumerate(methods):
self._methodToID[method] = i
self._idToMethod[i] = getattr(self, method)
self.__thread = None
self.__mainThread = None
self.__initialised = None
self.__commandsQueue = Queue.Queue(self.__conf.commandsQueueSize)
self.__nodes = []
self.__newAppendEntriesTime = 0
self.__commandsWaitingCommit = collections.defaultdict(
list) # logID => [(termID, callback), ...]
self.__commandsLocalCounter = 0
self.__commandsWaitingReply = {} # commandLocalCounter => callback
self.__properies = set()
for key in self.__dict__:
self.__properies.add(key)
if self.__conf.autoTick:
self.__mainThread = threading.current_thread()
self.__initialised = threading.Event()
self.__thread = threading.Thread(target=SyncObj._autoTickThread,
args=(weakref.proxy(self), ))
self.__thread.start()
while not self.__initialised.is_set():
pass
else:
self.__initInTickThread()
def __init__(self, ip, port, reactor_num=5):
self.__compute_thread_pool = compute_thread_pool
self.__server = TcpServer(ip, port, reactor_num)
"""
PyPepperChecker module
"""
from tcp_server import TcpServer
from network import Network
OUTPUT_SIZE = 3
INPUT_SIZE = 172 * 229 * 3
print("Building neural network...")
network = Network(INPUT_SIZE, OUTPUT_SIZE)
print "Processing images samples..."
network.process_images()
print "Training network..."
network.train()
print("Running TCP server...")
tcp_server = TcpServer(network)
tcp_server.run()
