def check_tor(self):
"""
Called only when we must start tor by director.start
"""
from ooni.utils.net import ConnectAndCloseProtocol, connectProtocol
incoherent = []
if not self.advanced.start_tor:
if self.tor.socks_port is None:
incoherent.append('tor:socks_port')
else:
socks_port_ep = TCP4ClientEndpoint(reactor,
"localhost",
self.tor.socks_port)
try:
yield connectProtocol(socks_port_ep, ConnectAndCloseProtocol())
except Exception:
incoherent.append('tor:socks_port')
if self.tor.control_port is not None:
if isinstance(self.tor.control_port, int):
control_port_ep = TCP4ClientEndpoint(reactor,
"localhost",
self.tor.control_port)
try:
yield connectProtocol(control_port_ep, ConnectAndCloseProtocol())
except Exception:
incoherent.append('tor:control_port')
else:
conf_unix_socket_path = self.tor.control_port.lstrip()
if conf_unix_socket_path.startswith("unix:"):
if os.path.exists(conf_unix_socket_path.lstrip("unix:")):
unix_socket_path = conf_unix_socket_path.lstrip("unix:")
else:
incoherent.append('tor:control_port')
else:
incoherent.append('tor:control_port')
self.log_incoherences(incoherent)
python类TCP4ClientEndpoint()的实例源码
def sendPayload(self, payload):
d1 = defer.Deferred()
def closeConnection(proto):
self.report['sent'].append(proto.sent_data)
self.report['received'].append(proto.received_data)
proto.transport.loseConnection()
log.debug("Closing connection")
d1.callback(proto.received_data)
def timedOut(proto):
self.report['failure'] = 'tcp_timed_out_error'
proto.transport.loseConnection()
def errback(failure):
self.report['failure'] = failureToString(failure)
d1.errback(failure)
def connected(proto):
log.debug("Connected to %s:%s" % (self.address, self.port))
proto.report = self.report
proto.deferred = d1
proto.sendPayload(payload)
if self.timeout:
# XXX-Twisted this logic should probably go inside of the protocol
reactor.callLater(self.timeout, closeConnection, proto)
point = TCP4ClientEndpoint(reactor, self.address, self.port)
log.debug("Connecting to %s:%s" % (self.address, self.port))
d2 = point.connect(TCPSenderFactory())
d2.addCallback(connected)
d2.addErrback(errback)
return d1
def _test_proxy_alive(self, host, port, protocol, proxy_type,
url=b'http://www.baidu.com', timeout=10):
endpoint = TCP4ClientEndpoint(reactor, host, int(port))
agent = ProxyAgent(endpoint)
d = agent.request(b'GET', url)
self.currents += 1
proxy = '{}:{}'.format(host, port)
key = 'proxy_info:' + proxy
if proxy_type == 'rookies_checking':
def _callback(ignored):
pipe = self.conn.pipeline(False)
pipe.zrem('rookies_checking', proxy)
pipe.hset(key, 'failed_times', 0)
# Move proxy from rookies to availables
pipe.smove('rookie_proxies', 'available_proxies',
'{}://{}'.format(protocol, proxy))
pipe.zadd('availables_checking', proxy, time.time() + 30)
pipe.execute()
def _errback(err):
if self.conn.hincrby(key, 'failed_times', 1) < 3:
# If not reach the maximum of failed_times
# Since it is not important so re-check it after 10 seconds
self.conn.zadd('rookies_checking', proxy, time.time() + 10)
else:
pipe = self.conn.pipeline(False)
pipe.zrem('rookies_checking', proxy)
pipe.smove('rookie_proxies', 'dead_proxies',
'{}://{}'.format(protocol, proxy))
pipe.execute()
else:
def _callback(ignored):
pipe = self.conn.pipeline(False)
pipe.hset(key, 'failed_times', 0)
pipe.zadd('availables_checking', proxy, time.time() + 30)
pipe.smove('lost_proxies', 'available_proxies',
'{}://{}'.format(protocol, proxy))
pipe.execute()
def _errback(err):
pipe = self.conn.pipeline(False)
if self.conn.hincrby(key, 'failed_times', 1) < 3:
pipe.zadd('availables_checking', proxy, time.time() + 10)
pipe.smove('available_proxies', 'lost_proxies',
'{}://{}'.format(protocol, proxy))
else:
pipe.zrem('availables_checking', proxy)
pipe.smove('lost_proxies', 'dead_proxies',
'{}://{}'.format(protocol, proxy))
pipe.delete(key)
pipe.execute()
d.addCallbacks(_callback, _errback)
reactor.callLater(timeout, d.cancel)
def _clean(ignored):
self.currents -= 1
d.addBoth(_clean)
def run(config, bcast, discovery_addr):
f = MyFactory(config)
try:
port = reactor.listenTCP(config.port, f)
config.port = port.getHost().port
except error.CannotListenError:
logging.error("cannot listen on {}".format(config.port))
sys.exit(1)
# connect to discovery server
point = TCP4ClientEndpoint(reactor, discovery_addr, 8123, timeout=90)
d = connectProtocol(point, Discovery({}, f))
d.addCallback(got_discovery, b64encode(f.vk), config.port).addErrback(my_err_back)
# connect to myself
point = TCP4ClientEndpoint(reactor, "localhost", config.port, timeout=90)
d = connectProtocol(point, MyProto(f))
d.addCallback(got_protocol).addErrback(my_err_back)
if bcast:
call_later(5, f.overwrite_promoters)
# optionally run tests, args.test == None implies reactive node
# we use call later to wait until the nodes are registered
if config.test == 'dummy':
call_later(5, f.bcast, pb.Dummy(m='z'))
elif config.test == 'bracha':
call_later(6, f.bracha.bcast_init)
elif config.test == 'mo14':
call_later(6, f.mo14.start, config.value)
elif config.test == 'acs':
# use port number (unique on local network) as test message
call_later(6, f.acs.start, str(config.port), 1)
elif config.test == 'tc':
call_later(5, f.tc_runner.make_tx, 1.0 / config.tx_rate, True)
# optionally use validate
if config.validate:
call_later(10, f.tc_runner.make_validation)
elif config.test == 'bootstrap':
call_later(5, f.tc_runner.bootstrap_promoters)
logging.info("NODE: reactor starting on port {}".format(config.port))
reactor.run()
def test_stopStartReading(self):
"""
This test verifies transport socket read state after multiple
pause/resumeProducing calls.
"""
sf = ServerFactory()
reactor = sf.reactor = self.buildReactor()
skippedReactors = ["Glib2Reactor", "Gtk2Reactor"]
reactorClassName = reactor.__class__.__name__
if reactorClassName in skippedReactors and platform.isWindows():
raise SkipTest(
"This test is broken on gtk/glib under Windows.")
sf.protocol = StopStartReadingProtocol
sf.ready = Deferred()
sf.stop = Deferred()
p = reactor.listenTCP(0, sf)
port = p.getHost().port
def proceed(protos, port):
"""
Send several IOCPReactor's buffers' worth of data.
"""
self.assertTrue(protos[0])
self.assertTrue(protos[1])
protos = protos[0][1], protos[1][1]
protos[0].transport.write(b'x' * (2 * 4096) + b'y' * (2 * 4096))
return (sf.stop.addCallback(cleanup, protos, port)
.addCallback(lambda ign: reactor.stop()))
def cleanup(data, protos, port):
"""
Make sure IOCPReactor didn't start several WSARecv operations
that clobbered each other's results.
"""
self.assertEqual(data, b'x'*(2*4096) + b'y'*(2*4096),
'did not get the right data')
return DeferredList([
maybeDeferred(protos[0].transport.loseConnection),
maybeDeferred(protos[1].transport.loseConnection),
maybeDeferred(port.stopListening)])
cc = TCP4ClientEndpoint(reactor, '127.0.0.1', port)
cf = ClientFactory()
cf.protocol = Protocol
d = DeferredList([cc.connect(cf), sf.ready]).addCallback(proceed, p)
d.addErrback(log.err)
self.runReactor(reactor)
def _request(self, method, urn, genReceiver, bodyProducer=None, retries=3):
if self.backend_type == 'onion':
agent = TrueHeadersSOCKS5Agent(reactor,
proxyEndpoint=TCP4ClientEndpoint(reactor,
'127.0.0.1',
config.tor.socks_port))
else:
agent = Agent(reactor)
attempts = 0
finished = defer.Deferred()
def perform_request(attempts):
uri = urljoin(self.base_address, urn)
d = agent.request(method, uri, bodyProducer=bodyProducer,
headers=Headers(self.base_headers))
@d.addCallback
def callback(response):
try:
content_length = int(response.headers.getRawHeaders('content-length')[0])
except:
content_length = None
response.deliverBody(genReceiver(finished, content_length))
def errback(err, attempts):
# We we will recursively keep trying to perform a request until
# we have reached the retry count.
if attempts < retries:
log.err("Lookup {} failed. Retrying.".format(uri))
attempts += 1
perform_request(attempts)
else:
log.err("Failed. Giving up.")
finished.errback(err)
d.addErrback(errback, attempts)
perform_request(attempts)
return finished
