def test_connect(self):
self.mox.StubOutWithMock(socket, 'create_connection')
socket.create_connection(('testhost', 8025), 7).AndReturn(9)
self.mox.ReplayAll()
conn = HTTPConnection('testhost', 8025, True, 7)
conn.connect()
assert_equal(9, conn.sock)
def client_connector(backend, local_port, tunnel_data,
ready=gevent.event.Event()):
while True:
init = tunnel_data.pop('init', None)
header = copy.copy(tunnel_data)
if init:
header['new'] = True
ready.clear()
elif not ready.isSet():
ready.wait()
backend_client = create_connection(backend)
backend_client.sendall("{0}\n".format(json.dumps(header)))
header = recv_json(backend_client)
if header and 'banner' in header:
print " {0}".format(header['banner'])
print " Port {0} is now accessible from http://{1} ...\n".format(
local_port, header['host'])
ready.set()
elif header and 'error' in header:
print " ERROR: {0}".format(header['error'])
gevent.hub.get_hub().parent.throw(SystemExit(1))
else:
try:
local_client = create_connection(('0.0.0.0', local_port))
join_sockets(backend_client, local_client)
except IOError:
backend_client.close()
def test(self):
try:
socket.create_connection(('localhost', get_port()), timeout=30, source_address=('', get_port()))
except socket.error:
ex = sys.exc_info()[1]
if 'refused' not in str(ex).lower():
raise
else:
raise AssertionError('create_connection did not raise socket.error as expected')
def connect(self):
if hasattr(self, 'source_address') and self.source_address:
self.sock = socket.create_connection((self.host, self.port),
self.timeout,
self.source_address)
else:
self.sock = socket.create_connection((self.host, self.port),
self.timeout)
if self._tunnel_host:
self._tunnel()
def test_connect(self):
self.mox.StubOutWithMock(socket, "create_connection")
socket.create_connection(("testhost", 8025), 7).AndReturn(9)
self.mox.ReplayAll()
# strict HTTPConnection became deprecated
if six.PY2:
conn = HTTPConnection("testhost", 8025, True, 7)
else:
conn = HTTPConnection("testhost", 8025, 7)
conn.connect()
self.assertEqual(9, conn.sock)
def test_connect(self):
self.mox.StubOutWithMock(socket, 'create_connection')
self.mox.StubOutWithMock(ssl, 'SSLSocket')
sslsock = self.mox.CreateMockAnything()
socket.create_connection(('testhost', 8025), 7).AndReturn(9)
ssl.SSLSocket(9, var='val').AndReturn(sslsock)
sslsock.do_handshake()
self.mox.ReplayAll()
conn = HTTPSConnection('testhost', 8025, {'var': 'val'}, True, 7)
conn.connect()
assert_equal(sslsock, conn.sock)
def netcat(host, port, proxy_host, proxy_port):
request = [('CONNECT %s:%d HTTP/1.1' % (host, port)).encode('ascii')]
request.append(('Host: %s:%d' % (host, port)).encode('ascii'))
request.append(('Proxy-Connection: Keep-Alive').encode('ascii'))
request.append(('\r\n').encode('ascii'))
dst = create_connection((proxy_host, proxy_port))
dst.sendall(b'\r\n'.join(request))
data = b''
while True:
data += dst.recv(1024)
if b'\r\n\r\n' in data:
break
if b'200 Connection established' not in data and b'407' in data:
service = gssapi.Name('HTTP@%s' % proxy_host, gssapi.NameType.hostbased_service)
ctx = gssapi.SecurityContext(name=service, usage='initiate')
token = ctx.step()
b64token = base64.b64encode(token).encode('ascii')
request[-1] = ('Proxy-Authorization: Negotiate %s' % b64token).encode('ascii')
request.append(('\r\n').encode('ascii'))
try:
dst.sendall(b'\r\n'.join(request))
except:
# if proxy does not support Keep-Alive
dst.close()
dst = create_connection((proxy_host, proxy_port))
dst.sendall(b'\r\n'.join(request))
data = b''
while True:
data += dst.recv(1024)
if b'\r\n\r\n' in data:
break
if b'200 Connection established' in data:
sys.stderr.write('Proxy connection established\n')
data = data.split(b'\r\n\r\n', 1)[1]
if data:
dst.sendall(data)
forwarders = (gevent.spawn(forward_stdin, dst),
gevent.spawn(forward_stdout, dst))
gevent.joinall(forwarders)
elif b'407' in data:
sys.stderr.write('Proxy authentication failed\n')
else:
version, status_code, status_message = data.split(b'\r\n', 1)[0].split(b' ', 2)
sys.stderr.write('Proxy returned %s %s\n' % (status_code, status_message))
def test_connect(self):
self.mox.StubOutWithMock(socket, "create_connection")
self.mox.StubOutWithMock(ssl, "SSLSocket")
sslsock = self.mox.CreateMockAnything()
socket.create_connection(("testhost", 8025), 7).AndReturn(9)
ssl.SSLSocket(9, var="val").AndReturn(sslsock)
sslsock.do_handshake()
self.mox.ReplayAll()
# strict HTTPConnection became deprecated
if six.PY2:
conn = HTTPSConnection("testhost", 8025, {"var": "val"}, True, 7)
else:
conn = HTTPSConnection("testhost", 8025, {"var": "val"}, 7)
conn.connect()
self.assertEqual(sslsock, conn.sock)
def stream_data(request):
from gevent import socket
s = socket.create_connection(("127.0.0.1", 1234))
sf = s.makefile()
return StreamingHttpResponse(FileWrapper(sf), content_type='text/plain')
def send_message_to_slave(message, address):
try:
payload = generate_msgpack_message_payload(message)
except TypeError:
logger.exception('Failed encoding message %s as msgpack', message)
stats['rpc_message_pass_fail_cnt'] += 1
return False
pretty_address = '%s:%s' % address
message_id = message.get('message_id', '?')
try:
s = socket.create_connection(address)
s.send(payload)
sender_resp = msgpack_unpack_msg_from_socket(s)
s.close()
except socket.error:
logging.exception('Failed connecting to %s to send message (ID %s)',
pretty_address, message_id)
stats['rpc_message_pass_fail_cnt'] += 1
return False
if sender_resp == 'OK':
logger.info('Successfully passed message (ID %s) to %s for sending',
message_id, pretty_address)
stats['rpc_message_pass_success_cnt'] += 1
return True
else:
logger.error('Failed sending message (ID %s) through %s: %s',
message_id, pretty_address, sender_resp)
stats['rpc_message_pass_fail_cnt'] += 1
return False
def did_it_work(server):
client = socket.create_connection((params.DEFAULT_CONNECT, server.getsockname()[1]))
fd = client.makefile(mode='rb')
client.close()
self.assertEqual(fd.readline(), b'hello\n')
self.assertFalse(fd.read())
fd.close()
def test_del_closes_socket(self):
timer = gevent.Timeout.start_new(0.5)
def accept_once(listener):
# delete/overwrite the original conn
# object, only keeping the file object around
# closing the file object should close everything
# XXX: This is not exactly true on Python 3.
# This produces a ResourceWarning.
try:
conn, _ = listener.accept()
conn = conn.makefile(mode='wb')
conn.write(b'hello\n')
conn.close()
_write_to_closed(conn, b'a')
finally:
listener.close()
server = tcp_listener(('0.0.0.0', 0))
gevent.spawn(accept_once, server)
client = socket.create_connection(
('127.0.0.1', server.getsockname()[1]))
fd = client.makefile()
client.close()
assert fd.read() == 'hello\n'
assert fd.read() == ''
timer.cancel()
def connect(self, timeout=None):
if not self._connected:
try:
sock = socket.create_connection(self._server, timeout)
if not self._ssl_enable:
self._socket = sock
else:
self._socket = ssl.wrap_socket(
sock,
keyfile=self._keyfile,
certfile=self._certfile,
ca_certs=self._ca_cert,
cert_reqs=ssl.CERT_REQUIRED,
ssl_version=ssl.PROTOCOL_TLSv1)
except socket.error as err_msg:
self._socket = None
self._handle_event(self.SESSION_ERROR)
return -1
else:
self._connected = True
self._socket.settimeout(None)
self._set_socket_options()
self._handle_event(self.SESSION_ESTABLISHED)
return 0
return 0
def connect(self, hostport):
if self.connected:
self.disconnect()
self.sock = socket.create_connection(hostport)
self.conn = ssl.wrap_socket(self.sock)
self.connected = True
def create_connection_hosts(addrs, port, timeout):
for addr in addrs:
try:
return socket.create_connection((addr, port), timeout=timeout)
except:
pass
raise socket.error("all addrs are failed.") # @UndefinedVariable
def connect(self, address, remote_pubkey):
log.debug('connecting', address=address)
log.info('connecting', address=address)
"""
gevent.socket.create_connection(address, timeout=Timeout, source_address=None)
Connect to address (a 2-tuple (host, port)) and return the socket object.
Passing the optional timeout parameter will set the timeout
getdefaulttimeout() is default
"""
try:
connection = create_connection(address,
timeout=self.connect_timeout)
except socket.timeout:
log.debug('connection timeout',
address=address,
timeout=self.connect_timeout)
self.errors.add(address, 'connection timeout')
return False
except socket.error as e:
log.debug('connection error', errno=e.errno, reason=e.strerror)
self.errors.add(address, 'connection error')
return False
log.debug('connecting to', connection=connection)
p = self._start_peer(connection, address, remote_pubkey)
p.join()
return True
def handle(self, src, addr):
data = b''
while True:
data += src.recv(1024)
if b'\r\n\r\n' in data:
break
service = gssapi.Name('HTTP@%s' % self.upstream[0],
gssapi.NameType.hostbased_service)
ctx = gssapi.SecurityContext(name=service, usage='initiate')
token = ctx.step()
b64token = base64.b64encode(token).encode('ascii')
headers, data = data.split(b'\r\n\r\n', 1)
headers = headers.split('\r\n')
replaced = False
for i, header in enumerate(headers):
if header.startswith('Proxy-Authorization:'):
headers[i] = b'Proxy-Authorization: Negotiate %s' % b64token
replaced = True
break
if not replaced:
headers.append(b'Proxy-Authorization: Negotiate %s' % b64token)
dst = create_connection(self.upstream)
dst.sendall(b'\r\n'.join(headers) + b'\r\n\r\n' + data)
forwarders = (gevent.spawn(forward, src,
dst), gevent.spawn(forward, dst, src))
gevent.joinall(forwarders)
def test_tracer_attach_timeout(self, mode):
"""
Tests the case where a tracer attaches but no client does.
"""
with QdbServer(tracer_host='localhost',
tracer_port=0,
client_server=QdbNopServer(),
attach_timeout=0.01,
timeout_disable_mode=mode) as server:
tracer = socket.create_connection(
('localhost', server.tracer_server.server_port))
send_tracer_event(tracer, 'start', {
'uuid': 'test',
'auth': '',
'local': (0, 0),
})
disable_event = None
with Timeout(0.1, False):
error_event = recv_tracer_event(tracer)
disable_event = recv_tracer_event(tracer)
error_dict = fmt_err_msg('client', 'No client')
self.assertEqual(error_dict, error_event)
self.assertEqual(fmt_msg('disable', mode), disable_event)
self.assertNotIn('test', server.session_store)
def test_inactivity_timeout(self, mode):
"""
Tests that timeout sends a disable message with the proper mode..
"""
with QdbServer(
tracer_host='localhost',
tracer_port=0,
client_host='localhost',
client_port=0,
inactivity_timeout=0.01, # minutes
sweep_time=0.01, # seconds
timeout_disable_mode=mode) as server:
tracer = socket.create_connection(
('localhost', server.tracer_server.server_port))
send_tracer_event(tracer, 'start', {
'uuid': 'test',
'auth': '',
'local': (0, 0),
})
client = create_connection('ws://localhost:%d%s' %
(server.client_server.server_port,
DEFAULT_ROUTE_FMT.format(uuid='test')))
send_client_event(client, 'start', '')
self.assertEqual({
'e': 'start',
'p': ''
}, recv_tracer_event(tracer))
self.assertEqual({
'e': 'disable',
'p': mode
}, recv_tracer_event(tracer))
self.assertEqual('disable', recv_client_event(client)['e'])
self.assertFalse('test' in server.session_store)
def test_del_closes_socket(self):
timer = gevent.Timeout.start_new(0.5)
def accept_once(listener):
# delete/overwrite the original conn
# object, only keeping the file object around
# closing the file object should close everything
try:
conn_, addr = listener.accept()
conn = conn_.makefile()
conn.write(b('hello\n'))
conn.close()
conn_.close()
if PY3:
self.assertRaises(AttributeError, conn.write, b('a'))
else:
r = conn.write(b('a'))
assert r is None, r
finally:
listener.close()
server = tcp_listener(('0.0.0.0', 0))
gevent.spawn(accept_once, server)
client = socket.create_connection(
('127.0.0.1', server.getsockname()[1]))
fd = client.makefile()
client.close()
assert fd.read() == b('hello\n')
assert fd.read() == b('')
timer.cancel()
def connect_with(self, protocol_class: Type[BaseProtocol],
host_port: tuple, protocol_args: list,
protocol_kwargs: dict) -> (BaseProtocol, socket.socket):
""" Helper which creates a new connection and feeds the data stream into
a protocol handler class.
:rtype: tuple(protocol_class, gevent.socket)
:param protocol_class: A handler class which has handler functions like
on_connected, consume, and on_connection_lost
:param protocol_kwargs: Keyword args to pass to the handler constructor
:param protocol_args: Args to pass to the handler constructor
:param host_port: (host,port) tuple where to connect
"""
LOG.info("Will connect to %s", host_port)
sock = socket.create_connection(address=host_port)
handler = protocol_class(*protocol_args, **protocol_kwargs)
handler.on_connected(host_port)
LOG.info("Connection to %s established", host_port)
try:
g = gevent.spawn(_read_loop, proto=handler, sock=sock)
g.start()
except Exception as e:
LOG.error("Exception: %s", traceback.format_exc())
return handler, sock
def test_del_closes_socket(self):
if PYPY:
return
timer = gevent.Timeout.start_new(0.5)
def accept_once(listener):
# delete/overwrite the original conn
# object, only keeping the file object around
# closing the file object should close everything
try:
conn, addr = listener.accept()
conn = conn.makefile(mode='wb')
conn.write(b'hello\n')
conn.close()
_write_to_closed(conn, b'a')
finally:
listener.close()
server = tcp_listener(('0.0.0.0', 0))
gevent.spawn(accept_once, server)
client = socket.create_connection(('127.0.0.1', server.getsockname()[1]))
fd = client.makefile()
client.close()
assert fd.read() == 'hello\n'
assert fd.read() == ''
timer.cancel()
def connect(self, hostport):
if self.connected:
self.disconnect()
self.sock = socket.create_connection(hostport)
self.conn = ssl.wrap_socket(self.sock)
self.connected = True
def query(self, q, local=False):
"""
This is a base function for communication with remote database.
@param q: str, query to be executed remotely
@param local: bool, this argument defines whether given query will be duplicated on local database
@return: None when database returned correct NONE response
False when there was an error during database communication or error during query execution
Those cases are being explicitly notified using self.notify
list of string lists when database reponded with some data
"""
if local:
with self.local.connection() as c:
c.execute(q)
try:
s = socket.create_connection(self.addr, timeout=20)
s.send(q)
answer = s.recv(1024)
except socket.error as e:
print e.__class__.__name__, e
if self.notify:
self.notify(_("Database Error"), q.decode('utf8', errors='replace'))
return False
if answer == 'FAIL':
self.notify(_("Query Error"), q.decode('utf8', errors='replace'))
return False
if answer == 'NONE':
return None
return [line.split('|') for line in answer.split('\n')]
def did_it_work(server):
client = socket.create_connection(('127.0.0.1', server.getsockname()[1]))
fd = client.makefile(mode='rb')
client.close()
assert fd.readline() == b'hello\n'
assert fd.read() == b''
fd.close()
def process_main():
for i in range(10000):
conn = socket.create_connection(('localhost', 9977))
conn.send("ABCDE")
conn.recv(5);
conn.close()
def connect(self):
conn = socket.create_connection(('127.0.0.1', self.port))
self.connected.append(weakref.ref(conn))
result = conn
if PY3:
conn_makefile = conn.makefile
def makefile(*args, **kwargs):
if 'bufsize' in kwargs:
kwargs['buffering'] = kwargs.pop('bufsize')
if 'mode' in kwargs:
return conn_makefile(*args, **kwargs)
# Under Python3, you can't read and write to the same
# makefile() opened in (default) r, and r+ is not allowed
kwargs['mode'] = 'rwb'
rconn = conn_makefile(*args, **kwargs)
_rconn_write = rconn.write
def write(data):
if isinstance(data, str):
data = data.encode('ascii')
return _rconn_write(data)
rconn.write = write
self.connected.append(weakref.ref(rconn))
return rconn
class proxy(object):
def __getattribute__(self, name):
if name == 'makefile':
return makefile
return getattr(conn, name)
result = proxy()
return result
def setUp(self):
self.tempdir, self.inst = util.create_test_instance()
self.bundle = self.inst.fi.bundles.values()[0]
self.local_server = local.start_server(self.inst)
gevent.sleep(0)
self.sock = socket.create_connection(('127.0.0.1', 54321))
def send_req(self, hostname, port, msg):
try:
sock = socket.create_connection((hostname, port))
except socket.error:
print('ERRO: conexao recusada para {}:{}'.format(hostname, port))
return False
sock.send(msg)
def handle(self, client, address):
try:
line = ''
while 1:
_data = client.recv(1)
line += _data
if not _data or _data == '\n':
break
if line:
log(line)
target_address = parse_address(line.split()[1])
target = create_connection(target_address)
target.sendall(line)
gevent.spawn(forward, client, target)
gevent.spawn(forward, target, client, 500000)
else:
client.close()
return
except IOError, ex:
log('failed : {}', ex)
import traceback
traceback.print_exc()
return
def initialize(self):
self.socksconn = socket.create_connection((self.socksip, self.socksport), self.timeout)
self.allsocks = [self.socksconn]
self.socksconn.sendall(InitRequest().pack())
read_init_reply(self.socksconn)
self.status = SESSION_WAIT_REQUEST
self.initialized = True
def test(self):
tempsock1 = socket.socket()
tempsock1.bind(('', 0))
source_port = tempsock1.getsockname()[1]
tempsock2 = socket.socket()
tempsock2.bind(('', 0))
tempsock2.getsockname()[1]
tempsock1.close()
del tempsock1
tempsock2.close()
del tempsock2
try:
socket.create_connection(('localhost', 4), timeout=30, source_address=('', source_port))
except socket.error, ex:
if 'connection refused' not in str(ex).lower():
raise
def handle(self, src, addr):
data = b''
while True:
data += src.recv(1024)
if b'\r\n\r\n' in data:
break
service = gssapi.Name('HTTP@%s' % self.upstream[0], gssapi.NameType.hostbased_service)
ctx = gssapi.SecurityContext(name=service, usage='initiate')
token = ctx.step()
b64token = base64.b64encode(token).encode('ascii')
headers, data = data.split(b'\r\n\r\n', 1)
headers = headers.split('\r\n')
replaced = False
for i, header in enumerate(headers):
if header.startswith('Proxy-Authorization:'):
headers[i] = b'Proxy-Authorization: Negotiate %s' % b64token
replaced = True
break
if not replaced:
headers.append(b'Proxy-Authorization: Negotiate %s' % b64token)
dst = create_connection(self.upstream)
dst.sendall(b'\r\n'.join(headers) + b'\r\n\r\n' + data)
forwarders = (gevent.spawn(forward, src, dst),
gevent.spawn(forward, dst, src))
gevent.joinall(forwarders)
def get_file(peer, f):
f.local_path = os.path.join(settings.DOWNLOAD_PATH,
os.path.split(f.name)[1])
print "Downloading to " + f.local_path
if os.path.exists(f.local_path):
print("File {filename} already exists.".format(filename=f.name))
return
sock = socket.create_connection((peer.address, peer.tcp_port))
sock.sendall(parser.build(GetFileMessage(f.sha_hash, 0, f.length)))
message_data = ""
while True:
new_data = sock.recv(1)
message_data += new_data
if new_data == parser.message_separator:
message = parser.parse(message_data)
if message.status != FileTransferResponseMessage.OK_STATUS:
print("File Request denied by peer.")
sock.close()
return
else:
break
fd = file(f.local_path, "wb")
while True:
new_data = sock.recv(1024)
if new_data:
fd.write(new_data)
else:
break
fd.close()
sock.close()
def stream_data(request):
from gevent import socket
s = socket.create_connection(("127.0.0.1", 1234))
sf = s.makefile()
return StreamingHttpResponse(FileWrapper(sf), content_type='text/plain')
def test_inactivity_timeout(self, mode):
"""
Tests that timeout sends a disable message with the proper mode..
"""
with QdbServer(tracer_host='localhost',
tracer_port=0,
client_host='localhost',
client_port=0,
inactivity_timeout=0.01, # minutes
sweep_time=0.01, # seconds
timeout_disable_mode=mode) as server:
tracer = socket.create_connection(
('localhost', server.tracer_server.server_port)
)
send_tracer_event(tracer, 'start', {
'uuid': 'test',
'auth': '',
'local': (0, 0),
})
client = create_connection(
'ws://localhost:%d%s' % (server.client_server.server_port,
DEFAULT_ROUTE_FMT.format(uuid='test'))
)
send_client_event(client, 'start', '')
self.assertEqual({'e': 'start', 'p': ''},
recv_tracer_event(tracer))
self.assertEqual({'e': 'disable', 'p': mode},
recv_tracer_event(tracer))
self.assertEqual('disable', recv_client_event(client)['e'])
self.assertFalse('test' in server.session_store)
def proc_tcp_request(self, req):
dst = (req.dstaddr, req.dstport)
log.info("TCP request address: (%s:%d)" % dst)
self.remoteconn = socket.create_connection(dst, self.timeout)
self.track_sock(self.remoteconn)
addrtype, bndaddr, bndport = sock_addr_info(self.remoteconn)
request_success(self.socksconn, addrtype, bndaddr, bndport)
def test_tracer_attach_timeout(self, mode):
"""
Tests the case where a tracer attaches but no client does.
"""
with QdbServer(tracer_host='localhost',
tracer_port=0,
client_server=QdbNopServer(),
attach_timeout=0.01,
timeout_disable_mode=mode) as server:
tracer = socket.create_connection(
('localhost', server.tracer_server.server_port)
)
send_tracer_event(tracer, 'start', {
'uuid': 'test',
'auth': '',
'local': (0, 0),
})
disable_event = None
with Timeout(0.1, False):
error_event = recv_tracer_event(tracer)
disable_event = recv_tracer_event(tracer)
error_dict = fmt_err_msg('client', 'No client')
self.assertEqual(error_dict, error_event)
self.assertEqual(fmt_msg('disable', mode), disable_event)
self.assertNotIn('test', server.session_store)
def create_connection_hosts(addrs, port, timeout):
for addr in addrs:
try:
return socket.create_connection((addr, port), timeout=timeout)
except:
pass
raise socket.error("all addrs are failed.") # @UndefinedVariable
def send_events(message):
if CARBON_ENDPOINT:
sock = socket.create_connection((CARBON_ENDPOINT.split(":")))
sock.sendall(message)
sock.close()
else:
print(message)
def handle(self, source, address):
log('%s:%s accepted', *address[:2])
try:
dest = create_connection(self.dest)
except IOError, ex:
log('%s:%s failed to connect to %s:%s: %s', address[0], address[1], self.dest[0], self.dest[1], ex)
return
def __init__ (self, client, endpoints):
"""
Set up a connection between the client_socket and multiple endpoints.
endpoints should be an array of (host, port) pairs.
"""
# We'll need these later
self.client = client
self.outgoing_queue = Queue()
self.connected = Event()
self.connected.set()
# Setup the endpoint connections and store them
self.endpoints = {}
for host, port in endpoints:
key = "%s:%s" % (host, port)
# Connect to the endpoint
endpoint = create_connection((host, port))
# Stream client <- self <- endpoint
self.stream(key, self.incoming, (host, port))
# Store the endpoint
self.endpoints[key] = endpoint
# Pick which endpoint to use first
self.current_endpoint = self.endpoints.keys()[0]
self.endpoints["client"] = self.client
# Stream client -> self -> endpoint
self.stream("client", self.outgoing)
def client(cid):
s = socket.create_connection(('127.0.0.1', 7890))
w = s.makefile('w')
r = s.makefile('r')
def send():
times = 0
while times < 100:
times += 1
gevent.sleep(1)
data = str(random.randint(10, 10000))
w.write('%s, from client %d\n' % (data, cid))
w.flush()
print 'client', cid, 'send:', data
def recv():
while True:
line = r.readline()
print 'client', cid, 'recive:', line,
if not line:
break
send_job = gevent.spawn_later(1, send)
recv_job = gevent.spawn(recv)
def clear(*args):
gevent.killall([send_job, recv_job])
s.close()
send_job.link(clear)
recv_job.link(clear)
gevent.joinall([send_job, recv_job])
print 'client', cid, 'finish'
def test():
conn = socket.create_connection(("192.168.2.34", 23), timeout=15)
conn.send("Hello from a telnet!")
data = conn.recv(20)
print(data)
conn.close()
def tcp_policy_client(address,
postfix_protocol,
force_sleep=None,
timeout=None):
u""" Simule l'action client de Postfix
Client TCP pour envoyer au serveur RS-Policy le protocol et recevoir le résultat
dans un tableau qui seront les actions renvoyés à Postfix
:param address: (host, port)
:param postfix_protocol: str
"""
if not postfix_protocol.endswith('\n\n'):
"""
POUR ne pas bloquer la transaction, il faut que protocol se termine par un \n ou 2 ?
"""
postfix_protocol = "%s\n\n" % postfix_protocol
if timeout:
conn = socket.create_connection(address, timeout=timeout)
else:
conn = socket.create_connection(address)
fileobj = conn.makefile()
fileobj.write(postfix_protocol)
fileobj.flush()
result = []
while True:
if force_sleep:
gevent.sleep(force_sleep)
line = fileobj.readline()
if not line: break
elif '=' in line:
line = iter(line.strip().split('='))
key = line.next()
result.append(line.next())
else:
fileobj.flush()
break
return result
def client_connect(address):
sockfile = create_connection(address).makefile()
while True:
line = sockfile.readline() # returns None on EOF
if line is not None:
print "<<<", line,
else:
break
def __init__(self, address, transport, chanid):
gevent.Greenlet.__init__(self)
gevent.sleep(.2)
logger.info("Tunneller creating connection -> %s", address)
self.socket = socket.create_connection(address)
self.transport = transport
self.chanid = chanid
gevent.sleep(0)
def _get_socket(self, host, port, timeout):
if self.debuglevel > 0:
print >> stderr, 'connect:', (host, port)
new_socket = socket.create_connection((host, port), timeout)
new_socket = ssl.wrap_socket(new_socket, self.keyfile,
self.certfile)
self.file = SSLFakeFile(new_socket)
return new_socket
def startedConnecting(self, connector):
"""
"""
address = connector.getHost()
client = create_connection(address)
t = Transport(client, address)
self.buildProtocol(t)
self._protocol = self.protocol(t, self)
def test_connect_disconnect(self):
my_server = server.Server(host="0.0.0.0")
my_server.run()
a = client.SimpleClient(
create_connection(("localhost", my_server.port)))
a.close()
my_server.stop()
def pg_proxy(self, client_socket, address):
pg_socket = socket.create_connection(("localhost", 5439))
pg_socket.settimeout(300.0)
client_socket.settimeout(300.0)
joinall((Greenlet.spawn(self.query_pipe, client_socket, pg_socket),
Greenlet.spawn(self.response_pipe, pg_socket, client_socket)))
pg_socket.close()
client_socket.close()
def handle(self, source, address):
log('%s:%s accepted', *address[:2])
try:
dest = create_connection(self.dest)
except IOError, ex:
log('%s:%s failed to connect to %s:%s: %s', address[0], address[1],
self.dest[0], self.dest[1], ex)
return
def did_it_work(server):
client = socket.create_connection(
('127.0.0.1', server.getsockname()[1]))
fd = client.makefile()
client.close()
assert fd.readline() == 'hello\n'
assert fd.read() == ''
fd.close()
def forward_processer():
last_packet = None
while True:
global forward_socket
try:
data = forward_socket.recv(65535)
except socket.timeout as e:
gevent.sleep(0)
continue
except:
print(sys.exc_info())
forward_socket.close()
try:
forward_socket = create_connection(forwarder_address)
except:
log_print("re connect forward failed")
gevent.sleep(0)
continue
if len(data) == 0:
gevent.sleep(0)
continue
start = 0
if last_packet != None:
log_print("reload packet data %d last packet %d" %
(len(data), len(last_packet)))
data = last_packet + data
last_packet = None
log_print("recv forward start len %d" % len(data))
while start < len(data):
if (start + 6 > len(data)):
last_packet = data[start:]
break
fileno, content_len = struct.unpack("!IH", data[start:start + 6])
if int(content_len) == 65535:
client_socket = proxy_clients.get(fileno)
if client_socket != None:
log_print("close %d" % fileno)
client_socket.close()
start = start + 6
continue
if (content_len > len(data[start + 6:])):
last_packet = data[start:]
log_print("save packet %d content len %d" %
(len(data[start:]), content_len))
log_print(data[start:])
break
log_print("recv forward start %d content %d" %
(start, content_len))
client_socket = proxy_clients.get(fileno)
if client_socket == None:
start = start + 6 + content_len
log_print("no client socket")
continue
try:
client_socket.sendall(data[start + 6:start + 6 + content_len])
except:
log_print("client_socket has closed")
start = start + 6 + content_len
def __init__(self, parent):
self.host = parent._parent.host
self.port = parent._parent.port
self._read_buffer = None
self._socket = None
self.ssl = parent._parent.ssl
try:
self._socket = socket.create_connection((self.host, self.port))
self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
if len(self.ssl) > 0:
ssl_context = self._get_ssl_context(self.ssl["ca_certs"])
try:
self._socket = ssl_context.wrap_socket(self._socket,
server_hostname=self.host)
except IOError as exc:
self._socket.close()
raise ReqlDriverError("SSL handshake failed: %s" % (str(exc),))
try:
match_hostname(self._socket.getpeercert(), hostname=self.host)
except CertificateError:
self._socket.close()
raise
self.sendall(parent._parent.handshake)
# The response from the server is a null-terminated string
response = b''
while True:
char = self.recvall(1)
if char == b'\0':
break
response += char
except ReqlAuthError:
raise
except ReqlTimeoutError:
raise
except ReqlDriverError as ex:
self.close()
error = str(ex)\
.replace('receiving from', 'during handshake with')\
.replace('sending to', 'during handshake with')
raise ReqlDriverError(error)
except Exception as ex:
self.close()
raise ReqlDriverError("Could not connect to %s:%s. Error: %s" %
(self.host, self.port, ex))
if response != b"SUCCESS":
self.close()
message = decodeUTF(response).strip()
if message == "ERROR: Incorrect authorization key.":
raise ReqlAuthError(self.host, self.port)
else:
raise ReqlDriverError("Server dropped connection with message: \"%s\"" %
(message, ))
def test_client(message):
conn = create_connection(('127.0.0.1', 6000)).makefile(bufsize=1)
welcome = conn.readline()
assert 'Welcome' in welcome, repr(welcome)
conn.write(message)
received = conn.read(len(message))
self.assertEqual(received, message)
conn._sock.settimeout(0.1)
self.assertRaises(timeout, conn.read, 1)
def __init__(self, uid=1, address=("127.0.0.1", 8080)):
self.secret_key = ""
self.uid = uid
self.rid = 1
self.cli_sock = create_connection(address)
if self.cli_sock:
self.accept_event = core.read_event(self.cli_sock.fileno(),
self.do_read,
persist=True)
def startedConnecting(self,connector):
"""开始建立连接\n
@param connector: BaseConnector (详见gtwisted.core.base 中对BaseConnector的定义)\n
"""
address = connector.getHost()
client = create_connection(address)
t = Transport(client,address)
self.buildProtocol(t)
self._protocol = self.protocol(t,self)
def test_search(start, end, direction):
print "test_search: s: %d, e: %d, dir: %d" % (start, end, direction)
con = create_connection(('127.0.0.1', 8090))
con.settimeout(5.0)
con.send("SEARCH %d %d %d FP_3031/Suma/Suma_produkcji_ciepla_DN300\r\n" %
(start, end, direction))
print con.recv(64)
def handle(self, source, address):
if address[:2][0] != 'xxx': # 如果不是公司的外网ip 就不要理了
return
log('%s:%s accepted', *address[:2])
try:
dest = create_connection(self.dest)
except IOError, ex:
log('%s:%s failed to connect to %s:%s: %s', address[0], address[1], self.dest[0], self.dest[1], ex)
return
