def connect(self):
with (yield self._lock.acquire()):
if self._connected:
return
for host, port in (yield resolve_logging(self.endpoints, self._name,
self.io_loop)):
try:
self.pipe = yield TCPClient(io_loop=self.io_loop).connect(host, port)
self.pipe.set_nodelay(True)
yield self.update_verbosity()
return
except IOError:
pass
def test_send_after_stream_start():
with echo_server() as e:
client = TCPClient()
stream = yield client.connect('127.0.0.1', e.port)
b = BatchedSend(interval=10)
b.start(stream)
b.send('hello')
b.send('world')
result = yield read(stream)
if len(result) < 2:
result += yield read(stream)
assert result == ['hello', 'world']
def connect(self):
try:
self.stream = yield TCPClient().connect(self.ip, self.port)
self.is_connected = True
self.stream.read_until(b"\n", callback=self.parse_response)
logger.debug('client connected')
self.ioloop.add_periodic(self.send_all)
self.ioloop.add_periodic(self.callback)
self.ioloop.add_periodic(self.subscribe)
except StreamClosedError as ex:
self.is_connected = False
except Exception as ex:
print ex
self.is_connected = False
def run_client():
stream = yield TCPClient().connect('127.0.0.1', SOURCE_PORT)
try:
while True:
input('<Press Enter To Send Message>').encode(ENCODING)
initial_message = Message(MESSAGE)
source_message = initial_message.prepare_source_message()
yield stream.write(source_message)
server_message = yield stream.read_bytes(4)
msg = Message(server_message)
unpacked_message = msg.parse_server_msg()
logging.info('Response from server: %s', unpacked_message)
except KeyboardInterrupt:
stream.close()
def __init__(self, host, port, user_connection_id, docker_id, io_loop):
self.__host = host
self.__port = port
self.__user_connection_id = user_connection_id
self.__docker_id = docker_id
self._io_loop = io_loop
self.client = TCPClient(io_loop=self._io_loop)
self._stream = None
self._requests = dict()
self._requests_signals = {
packet.InPacket.METHOD_SELECT_RESULT: Signal('data'),
packet.InPacket.METHOD_GET_STATUS: Signal('data'),
packet.InPacket.METHOD_CANCEL: Signal('data'),
}
def initialize(self,
io_loop,
max_clients=10,
hostname_mapping=None,
max_buffer_size=104857600,
resolver=None,
defaults=None,
max_header_size=None,
max_body_size=None):
"""Creates a AsyncHTTPClient.
Only a single AsyncHTTPClient instance exists per IOLoop
in order to provide limitations on the number of pending connections.
force_instance=True may be used to suppress this behavior.
max_clients is the number of concurrent requests that can be
in progress. Note that this arguments are only used when the
client is first created, and will be ignored when an existing
client is reused.
hostname_mapping is a dictionary mapping hostnames to IP addresses.
It can be used to make local DNS changes when modifying system-wide
settings like /etc/hosts is not possible or desirable (e.g. in
unittests).
max_buffer_size is the number of bytes that can be read by IOStream. It
defaults to 100mb.
"""
super(SimpleAsyncHTTPClient, self).initialize(io_loop,
defaults=defaults)
self.max_clients = max_clients
self.queue = collections.deque()
self.active = {}
self.waiting = {}
self.max_buffer_size = max_buffer_size
self.max_header_size = max_header_size
self.max_body_size = max_body_size
# TCPClient could create a Resolver for us, but we have to do it
# ourselves to support hostname_mapping.
if resolver:
self.resolver = resolver
self.own_resolver = False
else:
self.resolver = Resolver(io_loop=io_loop)
self.own_resolver = True
if hostname_mapping is not None:
self.resolver = OverrideResolver(resolver=self.resolver,
mapping=hostname_mapping)
self.tcp_client = TCPClient(resolver=self.resolver, io_loop=io_loop)
def __init__(self,
host,
port,
secure=True,
verify_certificate=True,
client_key=None,
client_cert=None,
auto_reconnect=True,
auto_reconnect_interval=DEFAULT_RECONNECT_INTERVAL,
_connection_cls=HTTP2ClientConnection,
_stream_cls=HTTP2ClientStream,
**kwargs):
if getattr(self, 'initialized', False):
return
else:
self.initialized = True
self.host = host
self.port = port
self.secure = secure
self.verify_certificate = verify_certificate
self.ssl_key = client_key
self.ssl_cert = client_cert
self.closed = False
self.connection_timeout = kwargs.get('connection_timeout',
DEFAULT_CONNECTION_TIMEOUT)
self.auto_reconnect = auto_reconnect
self.auto_reconnect_interval = auto_reconnect_interval
# Default 100 per http2 advice, but this can get changed by the remote
self.max_active_requests = 100
self.pending_requests = collections.deque()
self.queue_timeouts = dict()
self.active_requests = dict()
self.connection_cls = _connection_cls
self.stream_cls = _stream_cls
self.tcp_client = TCPClient()
self.no_more_stream_ids = False
self.connection = None
self.connect()
def connect(ip, port, timeout=1):
client = TCPClient()
start = time()
while True:
try:
stream = yield client.connect(ip,
port,
max_buffer_size=MAX_BUFFER_SIZE)
raise Return(stream)
except StreamClosedError:
if time() - start < timeout:
yield gen.sleep(0.01)
logger.debug("sleeping on connect")
else:
raise
def __init__(self,
io_loop=None,
max_clients=10,
max_buffer_size=None,
max_response_size=None):
self._io_loop = io_loop or IOLoop.instance()
self.max_clients = max_clients
self.max_buffer_size = max_buffer_size or 104857600 # 100M
self.max_response_size = max_response_size or 10 * 1024 * 1024 # 10M
self.queue = collections.deque()
self.active = {}
self.waiting = {}
self._client_closed = False
self.tcp_client = TCPClient(io_loop=self._io_loop)
def __init__(self, io_loop=None, hostname_mapping=None,
max_buffer_size=104857600, max_header_size=None,
max_body_size=None):
super(HTTPAdapter, self).__init__()
self.max_buffer_size = max_buffer_size
self.max_header_size = max_header_size
self.max_body_size = max_body_size
self.io_loop = io_loop or IOLoop.current()
self.resolver = Resolver()
if hostname_mapping is not None:
self.resolver = OverrideResolver(resolver=self.resolver,
mapping=hostname_mapping)
self.tcp_client = TCPClient(resolver=self.resolver)
def connect(ip, port, timeout=3):
client = TCPClient()
start = time()
while True:
future = client.connect(ip, port, max_buffer_size=MAX_BUFFER_SIZE)
try:
stream = yield gen.with_timeout(timedelta(seconds=timeout), future)
raise Return(stream)
except StreamClosedError:
if time() - start < timeout:
yield gen.sleep(0.01)
logger.debug("sleeping on connect")
else:
raise
except gen.TimeoutError:
raise IOError("Timed out while connecting to %s:%d" % (ip, port))
def test_BatchedStream_raises():
port = 3435
server = MyServer()
server.listen(port)
client = TCPClient()
stream = yield client.connect('127.0.0.1', port)
b = BatchedStream(stream, interval=20)
stream.close()
with pytest.raises(StreamClosedError):
yield b.recv()
with pytest.raises(StreamClosedError):
yield b.send('123')
def start(self):
wait_sec = 10
while True:
try:
self.stream = yield TCPClient().connect(self.host, self.port)
break
except iostream.StreamClosedError:
logger.error("connect error and again")
yield gen.sleep(wait_sec)
wait_sec = (wait_sec if (wait_sec >= 60) else (wait_sec * 2))
self.send_heart_beat()
self.heartbeat_callback = PeriodicCallback(self.send_heart_beat, 1000 * HEARTBEAT_TIMEOUT)
self.heartbeat_callback.start() # start scheduler
self.login()
self.stream.read_bytes(16, self.__recv_header)
def start(self):
self.stream = yield TCPClient().connect(self.host, self.port)
try:
while True:
self.sendno = self.sendno + 1
message = {"sendno": self.sendno, "message": "register node"}
encode_json = json.dumps(message)
print("send " + str(self.sendno))
self.stream.write(encode_json.encode() + b"\n")
rec = yield self.stream.read_until(b'\n')
print('recive from the server', rec)
time.sleep(2)
except iostream.StreamClosedError:
pass
def __init__(self, request):
self.connect_future = asyncio.Future()
self.read_future = None
self.read_queue = collections.deque()
self.events = []
self.tcp_client = TCPClient()
super().__init__(
None,
request,
lambda: None,
self._on_http_response,
104857600,
self.tcp_client,
65536,
104857600,
)
def __init__(self,
host,
port,
secure=True,
verify_certificate=True,
ssl_key=None,
ssl_cert=None,
max_active_requests=10,
io_loop=None,
auto_reconnect=False,
auto_reconnect_interval=DEFAULT_RECONNECT_INTERVAL,
_connection_cls=HTTP2ClientConnection,
_stream_cls=HTTP2ClientStream):
if getattr(self, 'initialized', False):
return
else:
self.initialized = True
self.io_loop = io_loop or IOLoop.instance()
self.host = host
self.port = port
self.secure = secure
self.verify_certificate = verify_certificate
self.ssl_key = ssl_key
self.ssl_cert = ssl_cert
self.closed = False
self.auto_reconnect = auto_reconnect
self.auto_reconnect_interval = auto_reconnect_interval
self.max_active_requests = max_active_requests
self.pending_requests = collections.deque()
self.queue_timeouts = dict()
self.active_requests = dict()
self.connection_cls = _connection_cls
self.stream_cls = _stream_cls
self.tcp_client = TCPClient()
self.connection = None
self.connect()
def run_remote():
print "Enter destination IP: "
dest_IP = raw_input()
print "Enter destination port: "
dest_port = raw_input()
dest_port = int(dest_port)
print "Enter remote name: "
remote_name = raw_input()
print "Enter preferred NIC: "
nic = raw_input()
stream = yield TCPClient().connect(str(dest_IP), dest_port)
try:
specs = {
"machine":
platform.platform(),
"node":
platform.node(),
"architecture":
[platform.architecture()[0],
platform.architecture()[1]],
"system":
platform.system(),
"release":
platform.release(),
"version":
platform.version(),
"name":
remote_name,
"memory":
psutil.virtual_memory().total
}
specs = json.dumps(specs)
text = str(specs) + '\n'
yield stream.write(text.encode('utf-8'))
time.sleep(1)
while True:
stats = get_stats(remote_name, nic)
stats = json.dumps(stats)
text = str(stats) + '\n'
yield stream.write(text.encode('utf-8'))
print text
time.sleep(1)
except KeyboardInterrupt:
print "Keyboard interrupt"
return
def post(self):
if self.request.remote_ip == allow_ip:
connection.info("{0}-{0}".format("POST连接成功IP", allow_ip))
data_p = json.loads(self.get_argument('data'))
data = {}
data['path'] = data_p['path_config']
data['fun'] = 'service_config'
data['app'] = 'read_path'
# conn = Connect_agen(host=data_p['ip'], port=9888,data=data)
# aa=yield self.send_message_new(host=data_p['ip'], port=9888,data=data)
# print aa
try:
ret = {}
stream = yield TCPClient().connect(data_p['ip'], 9888)
yield stream.write((json.dumps(data) + b"\n").encode())
reply = yield stream.read_until(b"\n")
print reply, '1111'
self.reutn_data = reply
# self.reutn_data=reply
ret['status'] = 'None'
ret['data_d'] = reply
self.reutn_data = ret
stream.close()
except StreamClosedError:
print 'error'
s = traceback.format_exc()
print s
ret = {}
ret['status'] = 'stop'
ret['data_d'] = '连接客户端失败'
self.reutn_data = ret
except Exception as e:
print e
s = traceback.format_exc()
print s
ret = {}
ret['status'] = 'stop'
ret['data_d'] = '连接客户端失败'
self.reutn_data = ret
else:
connection.error("{0}-{0}".format("POST连接失败IP", allow_ip))
ret = {}
ret['status'] = 'stop'
ret['data_d'] = "error"
ret = response_t(ret)
self.write(ret)
def start_send(self):
self.send_stream = yield TCPClient().connect(self.host,
self.send_port,
af=socket.AF_INET)
while True:
if len(self.send_queue):
msg = self.send_queue.pop()
print("发送消息：" + str(msg))
if msg.get("get_return"):
self.send_stream.write(msg.get("msg").encode("gbk"))
res = yield self.send_stream.read_until(self.delimiter)
res = res.decode("gbk").rstrip("|EOF|")
res = {"res": res, "id": msg.get("id")}
self.accept_queue.append(res)
else:
self.send_stream.write(msg.get("msg").encode("gbk"))
yield gen.sleep(0.5)
def connect(self):
while self.stream == None:
try:
self.log("Trying to connect...")
self.stream = yield TCPClient().connect(self.addr, self.port)
self.stream.set_close_callback(self.on_disconnect)
except Exception as e:
self.log(
"Connection failed, trying to reconnect in %d seconds" %
self.retry_time)
yield gen.sleep(self.retry_time)
self.log("Connection succeeded")
while True:
data = yield self.queue.get()
yield self.on_data(data)
def get(self):
"create TCP connection"
stream = yield TCPClient().connect('127.0.0.1', options.port)
try:
"init connection to back end"
stream.write(b"Poker\n");
"Read reply from Back-end"
data = yield stream.read_until('\n'.encode(options.encoding))
"Send reply to browser"
self.write(data);
"print the data sent"
print('Echoing data: ' + repr(data))
except KeyboardInterrupt:
stream.close()
def __init__(self, connection_options=ConnectionOptions()):
"""Constructs a new PropertyEstimatorClient object.
Parameters
----------
connection_options: ConnectionOptions
The options used when connecting to the calculation server.
"""
self._connection_options = connection_options
if connection_options.server_address is None:
raise ValueError('The address of the server which will run'
'these calculations must be given.')
self._tcp_client = TCPClient()
async def action(loop):
ip = hn_config.IP
port = hn_config.PORT
timeout = hn_config.TIMEOUT_1
read_timeout = hn_config.TIMEOUT_1
tcp_client = TCPClient()
stream = await tcp_client.connect(ip, port, timeout=timeout)
address = hn_config.HN_ADDRESS
hello_string = poshelpers.hello_string(port=101, address=address)
await com_helpers.async_send_string(commands_pb2.Command.hello,
hello_string, stream, ip)
msg = await com_helpers.async_receive(stream, ip, timeout=read_timeout)
await com_helpers.async_send_void(commands_pb2.Command.getheights, stream,
ip)
msg = await com_helpers.async_receive(stream, ip, timeout=read_timeout)
if msg.command == commands_pb2.Command.getheights:
S['heights'] = json.loads(msg.string_value)
await com_helpers.async_send_void(commands_pb2.Command.status, stream, ip)
msg = await com_helpers.async_receive(stream, ip, timeout=read_timeout)
if msg.command == commands_pb2.Command.status:
S['status'] = json.loads(msg.string_value)
await com_helpers.async_send_void(commands_pb2.Command.gethypernodes,
stream, ip)
msg = await com_helpers.async_receive(stream, ip, timeout=read_timeout)
if msg.command == commands_pb2.Command.gethypernodes:
status = json.loads(msg.string_value)
S['data'] = status
L = len(status)
task = []
for i in range(0, L):
data = status[i]
pingstatus.append(0)
pingversion.append("?")
task.append(loop.create_task(ping(i, data[1], data[2], timeout)))
for i in range(0, L):
await task[i]
return status
def __init__(self, io_loop, request):
self.connect_future = TracebackFuture()
self.read_future = None
self.read_queue = collections.deque()
self.events = []
if old_tornado:
self.resolver = Resolver(io_loop=io_loop)
super(EventSourceClient,
self).__init__(io_loop, None, request, lambda: None,
self._on_http_response, 104857600,
self.resolver)
else:
self.tcp_client = TCPClient(io_loop=io_loop)
super(EventSourceClient,
self).__init__(io_loop, None, request, lambda: None,
self._on_http_response, 104857600,
self.tcp_client, 65536)
def connect(self, address, deserialize=True, **connection_args):
self._check_encryption(address, connection_args)
ip, port = parse_host_port(address)
kwargs = self._get_connect_args(**connection_args)
client = TCPClient()
try:
stream = yield client.connect(ip,
port,
max_buffer_size=MAX_BUFFER_SIZE,
**kwargs)
except StreamClosedError as e:
# The socket connect() call failed
convert_stream_closed_error(e)
# XXX
raise gen.Return(
self.comm_class(stream, self.prefix + address, deserialize))
def StartClient(client, host='127.0.0.1', port=502, callback=None):
''' Connect to tcp host and, join to client.transport, wait for reply data
Reconnect on close
'''
while True:
try:
stream = yield TCPClient().connect(host, port)
client.setTransport(stream)
future = stream.read_until_close(streaming_callback = client.dataReceived)
if callback:
yield callback()
yield future
except StreamClosedError:
pass
except Exception, E:
print str(E)
stream.close()
finally:
def __init__(self,
host,
port,
max_clients=5,
max_buffer_size=None,
max_response_size=None,
connect_timeout=0.2):
self._io_loop = IOLoop.current()
self.client_config = _RPCClientConfig(
host=host,
port=port,
max_clients=max_clients,
max_buffer_size=max_buffer_size,
max_response_size=max_response_size,
connect_timeout=connect_timeout)
self.tcp_client = TCPClient(io_loop=self._io_loop)
def a():
stream = yield TCPClient().connect('0.0.0.0', 7777)
print 'client ok'
f = open('a.txt', 'rb')
s = f.read()
f.close()
print len(s)
yield stream.write(s)
while True:
d1 = yield stream.read_bytes(1)
if len(d1) != 0:
break
data = stream._read_buffer
l = len(data)
d2 = yield stream.read_bytes(l - 1)
s = d1 + d2
print s
def handle_stream(self, stream, address):
ip, fileno = address
print("Incoming connection from " + ip)
EchoServer.clients.add(address)
ip = '192.168.199.126'
ip = '45.77.214.165'
streamCli = yield TCPClient().connect(ip, 8888)
print 'client ok'
IOLoop.instance().add_callback(
functools.partial(run_client, stream, streamCli))
while True:
try:
yield self.echo(stream, streamCli)
except StreamClosedError:
print("Client " + str(address) + " left.")
EchoServer.clients.remove(address)
break
def send_message_new(self):
try:
stream = yield TCPClient().connect(self.host, self.port)
self.stream = stream
print self.data
print self.host, self.port
yield stream.write((json.dumps(self.data) + b"\n").encode())
i1 = 0
while self.status:
i1 += 1
print '1111'
reply = yield stream.read_until(b"\n")
#reply=stream.read_until(b"\n")
print type(json.loads(reply))
print json.loads(reply)
if type(json.loads(reply)) == dict:
reply = json.loads(reply)
reply['count'] = i1
reply = json.dumps(reply)
if json.loads(reply)['status'] == 'stop':
break
# self.object_w.write_message(reply)
# if json.loads(reply)['pf'] == 'write':
# self.object_w.close()
# break
print dict_w[self.hash_hash]
for i in dict_w[self.hash_hash]['stream']:
i.write_message(reply)
print 'test'
stream.close()
except StreamClosedError:
ret = {}
ret['status'] = 'stop'
ret['data'] = '连接客户端失败'
for i in dict_w[self.hash_hash]['stream']:
i.write_message(ret)
i.close()
except Exception as e:
ret = {}
ret['status'] = 'stop'
ret['data'] = '连接客户端失败'
for i in dict_w[self.hash_hash]['stream']:
i.write_message(ret)
i.close()
