def doMath():
destination = TCP4ClientEndpoint(reactor, "127.0.0.1", 1234)
sumDeferred = connectProtocol(destination, AMP())
def connected(ampProto):
return ampProto.callRemote(Sum, a=13, b=81)
sumDeferred.addCallback(connected)
def summed(result):
return result["total"]
sumDeferred.addCallback(summed)
divideDeferred = connectProtocol(destination, AMP())
def connected(ampProto):
return ampProto.callRemote(Divide, numerator=1234, denominator=0)
divideDeferred.addCallback(connected)
def trapZero(result):
result.trap(ZeroDivisionError)
print "Divided by zero: returning INF"
return 1e1000
divideDeferred.addErrback(trapZero)
def done(result):
print "Done with math:", result
reactor.stop()
defer.DeferredList([sumDeferred, divideDeferred]).addCallback(done)
def range_check(self, firstbyte, lastbyte, setset=False):
test_deferred = Deferred()
self._logger.debug("range_test: %s %s %s setset %s", firstbyte, lastbyte, self.sourcesize, setset)
if firstbyte is not None and lastbyte is None:
exp_byte_range = (firstbyte, self.sourcesize - 1)
elif firstbyte is None and lastbyte is not None:
exp_byte_range = (self.sourcesize - lastbyte, self.sourcesize - 1)
else:
exp_byte_range = (firstbyte, lastbyte)
# the amount of bytes actually requested. (Content-length)
self.expsize = exp_byte_range[1] - exp_byte_range[0] + 1
f = open(self.sourcefn, "rb")
f.seek(exp_byte_range[0])
expdata = f.read(self.expsize)
f.close()
def on_connected(p):
p.sendMessage(self.get_header(firstbyte, lastbyte, setset))
endpoint = TCP4ClientEndpoint(reactor, "localhost", self.port)
connectProtocol(endpoint, VideoServerProtocol(test_deferred, self.sourcesize, expdata, setset, exp_byte_range))\
.addCallback(on_connected)
return test_deferred
def process(self):
parsed = urllib_parse.urlparse(self.uri)
protocol = parsed[0]
host = parsed[1].decode('ascii')
if protocol in self.ports:
port = self.ports[protocol]
else:
# handle
pass
if ':' in host:
host, port = host.split(':')
port = int(port)
rest = urllib_parse.urlunparse((b'', b'') + parsed[2:])
if not rest:
rest = rest + b'/'
if protocol in self.protocols:
factory = self.protocols[protocol]
headers = self.getAllHeaders().copy()
if b'host' not in headers:
headers[b'host'] = host.encode('ascii')
headers.pop(b'user-agent', None)
headers[b'user-agent'] = b'I2P'
self.content.seek(0, 0)
s = self.content.read()
client = factory(self.method, rest, self.clientproto, headers, s, self)
ep = self.endpointFactory(host, port)
connectProtocol(ep, client.buildProtocol(ep))
def test_basic(self):
ep = clientFromString(reactor, self.transit)
a1 = yield connectProtocol(ep, Accumulator())
a2 = yield connectProtocol(ep, Accumulator())
token1 = b"\x00"*32
a1.transport.write(b"please relay " + hexlify(token1) + b"\n")
a2.transport.write(b"please relay " + hexlify(token1) + b"\n")
# a correct handshake yields an ack, after which we can send
exp = b"ok\n"
yield a1.waitForBytes(len(exp))
self.assertEqual(a1.data, exp)
s1 = b"data1"
a1.transport.write(s1)
exp = b"ok\n"
yield a2.waitForBytes(len(exp))
self.assertEqual(a2.data, exp)
# all data they sent after the handshake should be given to us
exp = b"ok\n"+s1
yield a2.waitForBytes(len(exp))
self.assertEqual(a2.data, exp)
a1.transport.loseConnection()
a2.transport.loseConnection()
def on_deploy_start(self):
now = int(time.time())
events = ("events.deploy.%s %d %d\r\n" % (component, 1, now)
for component in self.components)
message = "".join(events)
protocol = OneShotMessageWriter(message)
endpoint = endpoints.clientFromString(reactor, self.endpoint_config)
endpoints.connectProtocol(endpoint, protocol)
def start_client(proto):
client_endpoint = TCP4ClientEndpoint(reactor, 'localhost', 1234)
nickname = 'PyClient' + str(random.getrandbits(23))
factory = PyClientProtocolFactory(nickname)
proto = factory.buildProtocol(('localhost', 0))
connectProtocol(client_endpoint, proto)
d = Deferred()
reactor.callLater(4, d.callback, proto)
d.addCallback(test_state)
return d
def connectionMade(self):
script_dir = os.getcwd()
rel_path = "hostkeys"
abs_file_path = os.path.join(script_dir, rel_path)
knownHosts = KnownHostsFile.fromPath(abs_file_path)
self.point = SSHCommandClientEndpoint.newConnection(reactor, 'cmd', 'user', '127.0.0.1', port=5122,
password='******', knownHosts=PermissiveKnownHosts())
self.sshSide = FzSSHClient()
self.sshSide.tcpSide = self
connectProtocol(self.point, self.sshSide)
def perform_run(dispatcher, intent):
context.bind(
message_type="flocker.provision.ssh:run",
command=intent.log_command_filter(intent.command),
).write()
endpoint = SSHCommandClientEndpoint.existingConnection(
connection, intent.command)
d = Deferred()
connectProtocol(endpoint, CommandProtocol(
deferred=d, context=context))
return d
def onEvent(self, ev):
if ev.getName() == YowNetworkLayer.EVENT_STATE_CONNECT:
# self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
# self.out_buffer = bytearray()
endpoint = self.getProp(YowNetworkLayer.PROP_ENDPOINT)
point = TCP4ClientEndpoint(reactor, endpoint[0], endpoint[1])
connectProtocol(point, self)
# self.connect(endpoint)
return True
elif ev.getName() == YowNetworkLayer.EVENT_STATE_DISCONNECT:
self.handle_close(ev.getArg("reason") or "Requested")
return True
def run(messagehandler):
options = optionsForClientTLS(
hostname=AUTHORITY,
acceptableProtocols=[b'h2', b'http/1.1'],
)
connectProtocol(
SSL4ClientEndpoint(reactor, AUTHORITY, 443, options),
H2Protocol(messagehandler)
)
reactor.run(installSignalHandlers=0)
def _connectServer(self, hostname, port, server_queue, client_queue):
"""A helper function for connecting to (hostname, port)
with the given server and client queues.
:param str hostname:
:param int port:
:param DeferredQueue server_queue:
:param DeferredQueue client_queue:
"""
endpoint = TCP4ClientEndpoint(reactor, hostname, port)
protocol = ServerProtocol(
server_queue, client_queue)
connectProtocol(endpoint, protocol)
def connectServer(self, hostname, port):
"""Tell the proxy what the end server is and start the connection.
The messages in `self.client_queue` will automatically be consumed.
This method should only be called once.
:param str hostname:
:param int port:
"""
endpoint = TCP4ClientEndpoint(reactor, hostname, port)
protocol = ServerProtocol(
self.server_queue, self.client_queue)
connectProtocol(endpoint, protocol)
def main(reactor=reactor):
arguments = vars(parser.parse_args())
endpoint = clientFromString(
reactor=reactor,
description=arguments["endpoint"],
)
lines = iter(replay_file(arguments["queries"]))
client = BenchmarkClient()
client.lineiterator = lines
connectProtocol(endpoint, client).addCallback(
lambda protocol : protocol.sendLine(lines.next()),
)
reactor.run()
def zkconnected(z, reactor):
val, meta = yield z.get('/brokers/topics/test/partitions/0/state')
broker = json.loads(val)['isr'][0]
val, meta = yield z.get('/brokers/ids/%d' % (broker, ))
val = json.loads(val)
host, port = val['host'], val['port']
ep = TCP4ClientEndpoint(reactor, host, port)
proto = KafkaClientProtocol()
yield connectProtocol(ep, proto)
brokers, topics = yield proto.sender.metadataRequest(topicNames=['test'])
log.debug('Brokers: {brokers!r}', brokers=brokers)
test_zero_md = topics['test'][0]
leader, replicas, isr = test_zero_md
r = yield proto.sender.fetchRequest(replicaId=-1,
maxWaitTime=10,
minBytes=0,
topics=[
('test', [(0, 0, 65535)])
])
r = yield proto.sender.produceRequest(1, 1000, [
('test', [
(0, [
(3, Message(value='message 4'))
])
])
])
def send(m):
point = TCP4ClientEndpoint(reactor, "localhost", 1234)
g = Greeter()
g.message = m
d = connectProtocol(point,g)
d.addCallback(gotProtocol)
reactor.run()
def makeConnection(ip, port, connectCallback):
connection = Connection()
connection.callback = connectCallback
point = TCP4ClientEndpoint(reactor, ip, port)
d = connectProtocol(point, connection)
thread.start_new_thread(startConnection, ())
return connection
def main(reactor, args):
vhost = args.vhost
user = args.user
passwd_file = args.passwd_file
if passwd_file is None:
passwd = 'guest'
else:
passwd = passwd_file.read().rstrip("\n\r")
passwd_file.close()
spec_path = os.path.join(
os.path.dirname(__file__),
'spec/amqp0-9-1.stripped.xml')
spec = txamqp.spec.load(spec_path)
params = {
'creds': (user, passwd),
'exchange': args.exchange,
'content': args.msg_file.read(),
'route_key': args.route_key,
}
endpoint_s = args.endpoint
e = clientFromString(reactor, endpoint_s)
delegate = TwistedDelegate()
amqp_protocol = AMQClient(
delegate=delegate,
vhost=vhost,
spec=spec)
d = connectProtocol(e, amqp_protocol)
d.addCallback(on_amqp_connect, params)
return d
def greylistCommand(command, port='unix:/var/run/greylistd/socket', reactor=None):
if not reactor:
from twisted.internet import reactor
deferred = Deferred()
d = connectProtocol(clientFromString(reactor, port), _GreylistProtocol(deferred, command))
d.addErrback(deferred.errback)
return deferred
def run(reactor, command, **kwargs):
"""
Run a process and kill it if the reactor stops.
:param reactor: Reactor to use.
:param list command: The command to run.
:return Deferred: Deferred that fires when the process is ended.
"""
if 'env' not in kwargs:
kwargs['env'] = os.environ
endpoint = ProcessEndpoint(reactor, command[0], command, **kwargs)
protocol_done = Deferred()
protocol = CommandProtocol(deferred=protocol_done, output=sys.stdout)
connected = connectProtocol(endpoint, protocol)
def unregister_killer(result, trigger_id):
try:
reactor.removeSystemEventTrigger(trigger_id)
except:
# If we can't remove the trigger, presumably it has already been
# removed (or run). In any case, there is nothing sensible to do
# if this fails.
pass
return result
def register_killer(_):
trigger_id = reactor.addSystemEventTrigger(
'before', 'shutdown', protocol.transport.signalProcess, 'TERM')
protocol_done.addBoth(unregister_killer, trigger_id)
connected.addCallback(register_killer)
connected.addCallback(lambda _: protocol_done)
return connected
def main(reactor, args):
endpoint_str = args.endpoint
e = clientFromString(reactor, endpoint_str)
d = connectProtocol(e, LDAPClient())
d.addCallback(onConnect, args)
d.addErrback(onError)
return d
def connect(self):
"""Connect client."""
if self.number < self.req_num:
# pre-add the available connection count
# will be decremented if failure occurs
self.number += 1
connector = ClientConnector(self)
# connect through Tor if required, direct connection otherwise
if self.socksproxy:
proxy = random.choice(self.socksproxy)
# Further settings and check
socks_point = TCP4ClientEndpoint(reactor, proxy[0], proxy[1])
point = SOCKS5Point(self.host, self.port, socks_point)
elif self.obfs_level == 3:
meek_point = TCP4ClientEndpoint(
reactor, "127.0.0.1", self.ptproxy_local_port)
point = SOCKS4Point(self.host, self.port, meek_point)
else:
point = TCP4ClientEndpoint(reactor, self.host, self.port)
deferred = connectProtocol(point, connector)
# trigger success or failure action depending on the result
deferred.addCallback(self.success)
deferred.addErrback(lambda ignored: self.retry())
def _handshake(self, credential):
"""
Run a TLS handshake between a client and server, one of which is
using the validation logic and the other the given credential.
:param credential: The high-level credential to use.
:return ``Deferred``: Fires when handshake succeeded or
failed.
"""
peer_context_factory = PeerContextFactory(credential.credential)
port = find_free_port()[1]
validating_context_factory = context_factory_fixture(
port, self.good_ca)
if validator_is_client:
client_context_factory = validating_context_factory
server_context_factory = peer_context_factory
else:
server_context_factory = validating_context_factory
client_context_factory = peer_context_factory
result = start_tls_server(self, port, server_context_factory)
validating_endpoint = SSL4ClientEndpoint(
reactor, "127.0.0.1", port, client_context_factory)
client_protocol = ReceivingProtocol()
result.addCallback(lambda _: connectProtocol(validating_endpoint,
client_protocol))
result.addCallback(lambda _: client_protocol.result)
return result
def connect(self, endpoint):
if self.client:
raise RuntimeError("Already connected to %s" % (self.client,))
if self._connecting:
raise RuntimeError("Connection already in progress.")
self._connecting = connectProtocol(endpoint, self._protocolClass())
self._connecting.addCallbacks(self._setClient, self._connectFailed)
def __init__(self,backend_port):
self.send_queue = defer.DeferredQueue()
self.backend_point = TCP4ClientEndpoint(reactor, "localhost", backend_port)
self.backend = MetricLineProtocol()
self.backend_defer = connectProtocol(self.backend_point,self.backend)
self.backend_defer.addCallback(self.backendConnectionMade)
def connectionMade(self):
print 'got connection from %s' % (self.addr, )
print 'connecting to %s:%d' % (self.host, self.port)
point = TCP4ClientEndpoint(reactor, self.host, self.port)
self.client = XMPPClient(self, self.domain, self.cert_file, self.pkey_file)
d = connectProtocol(point, self.client)
d.addCallback(self._connected)
def main(reactor):
endpoint_str = "tcp:host=127.0.0.1:port=8080"
e = clientFromString(reactor, endpoint_str)
d = connectProtocol(e, LDAPClient())
d.addCallback(onConnect)
d.addErrback(onError)
return d
def main(reactor):
log.startLogging(sys.stdout)
endpoint_str = "tcp:host=localhost:port=8080"
e = clientFromString(reactor, endpoint_str)
d = connectProtocol(e, LDAPClient())
d.addCallback(onConnect)
d.addErrback(onError, reactor)
return d
def run_amp_command(description, command, args, reactor=None):
if reactor is None:
from twisted.internet import reactor
endpoint = endpoints.clientFromString(reactor, description)
amp = AMP()
d = endpoints.connectProtocol(endpoint, amp)
d.addCallback(lambda ign: amp.callRemote(command, **args))
return d
def main():
log.startLogging(stdout)
log.msg("Connecting to the AMP server...")
d = endpoints.connectProtocol(ampEndpoint, AMP())
d.addCallback(_connected)
reactor.run()
def reconnector(self, onion):
protocol = Protocol()
protocol.onion = onion
protocol.connectionLost = lambda failure: self.handleLostConnection(failure, onion)
tor_endpoint = clientFromString(self.reactor, "tor:%s.onion:8060" % onion)
self.onion_pending_map[onion] = connectProtocol(tor_endpoint, protocol)
self.onion_pending_map[onion].addCallback(lambda protocol: self.connection_ready(onion, protocol))
self.onion_pending_map[onion].addErrback(lambda failure: self.connectFail(failure, onion))
def _get_protocol(self):
# TODO: something smart to kickout bad servers and use ones with lower
# pings
if not self._endpoints:
raise GRPCError('No servers configured')
yield self._lock.acquire()
if not self._protocol:
self._protocol = yield endpoints.connectProtocol(
self._endpoints[0],
self.PROTOCOL_FACTORY(
clock=self._reactor,
authority='localhost:1234',
stats=self._stats,
),
)
self._lock.release()
defer.returnValue(self._protocol)
def zfs_command(reactor, arguments):
"""Run the ``zfs`` command-line tool with the given arguments.
:param reactor: A ``IReactorProcess`` provider.
:param arguments: A ``list`` of ``bytes``, command-line arguments to
``zfs``.
:return: A :class:`Deferred` firing with the bytes of the result (on
exit code 0), or errbacking with :class:`CommandFailed` or
:class:`BadArguments` depending on the exit code (1 or 2).
"""
endpoint = ProcessEndpoint(reactor, b"zfs", [b"zfs"] + arguments,
os.environ)
d = connectProtocol(endpoint, _AccumulatingProtocol())
d.addCallback(lambda protocol: protocol._result)
return d
def connectionMade(self):
hackedCommandHandler = CLIShell.CommandHandler(
"hack", "Notify the C&C they've been hacked", self.__hack)
self.registerCommand(hackedCommandHandler)
networkSettings = PlaygroundNetworkSettings()
networkSettings.configureNetworkStackFromPath("./ProtocolStack")
networkSettings.requestSpecificAddress(self.hostaddr)
playgroundEndpoint = GateClientEndpoint(reactor, self.peeraddr, 10001,
networkSettings)
self.__protocol = SimpleCommandAndControlProtocol()
self.__protocol.factory = self
self.__d = connectProtocol(playgroundEndpoint, self.__protocol)
self.__d.addCallback(self.candcConnectionMade)
self.deferToResponse = Deferred()
def connect(self,
address,
port,
SessionType,
establishedCallback=None,
failureCallback=None,
*args):
print "Connecting to host {} : {}".format(address, port)
from twisted.internet import reactor
endpoint = TCP4ClientEndpoint(reactor, address, port)
connection = SessionType.ConnectionStateType()
d = connectProtocol(endpoint, connection)
d.addCallback(Network.__connectionEstablished, SessionType,
establishedCallback, *args)
d.addErrback(Network.__connectionFailure, failureCallback, *args)
def start_client(self):
self.log.info('start client')
self.transport.pauseProducing()
conf = ConfigManager().default
proxy_host_port = conf.get('local', 'proxy_host_port')
point = clientFromString(self.factory.reactor,
f"tcp:{proxy_host_port}")
d = connectProtocol(point, ProxyClient(self))
def error(failure):
raise errors.HostUnreachable()
d.addErrback(error)
return d
def secureConnection(self):
"""
Create and return a new SSH connection which has been secured and on
which authentication has already happened.
@return: A L{Deferred} which fires with the ready-to-use connection or
with a failure if something prevents the connection from being
setup, secured, or authenticated.
"""
protocol = _CommandTransport(self)
ready = protocol.connectionReady
sshClient = TCP4ClientEndpoint(self.reactor, self.hostname, self.port)
d = connectProtocol(sshClient, protocol)
d.addCallback(lambda ignored: ready)
return d
def connect_mqtt_tls(
client_id,
host,
rootpath,
port,
client_creds=None,
protocols=None,
):
"""Connect an MQTT Client over TLS without client auth.
:param host: The hostname to connect
:type host: str
:param rootpath: Path to the root certificate
:type rootpath: str
:param port (optional): The port to use, default 8883
:type port: int
:param client_creds: Client cert/key pair
:type client_creds: ssl.PrivateCertificate
:param protocols: List of protocols for use with ALPN
:type protocols: List[bytes]
"""
with open(rootpath, 'rb') as rootf:
rootblob = rootf.read()
trust_root = ssl.trustRootFromCertificates(
[ssl.Certificate.loadPEM(rootblob)])
tls_options = ssl.optionsForClientTLS(host,
trustRoot=trust_root,
clientCertificate=client_creds,
acceptableProtocols=protocols)
endpoint = endpoints.SSL4ClientEndpoint(reactor, host, port, tls_options)
d = endpoints.connectProtocol(endpoint, MQTTClient(client_id))
def _socket_connected(client):
return client.connect()
d.addCallback(_socket_connected)
return d
def ConnectToChaperone(cls, reactor, chaperoneDetails, playgroundAddress):
if cls.__muxer:
cls.__muxer.chaperone.connectionLost("Chaperone and/or Address Change")
if cls.__muxer.chaperone.transport:
cls.__muxer.chaperone.transport.loseConnection()
if len(chaperoneDetails) == 2:
addr, port = chaperoneDetails
chaperoneEndpoint = TCP4ClientEndpoint(reactor, addr, int(port))
elif len(chaperoneDetails) == 1:
chaperoneEndpoint = UNIXClientEndpoint(reactor,
chaperoneDetails[0])
else:
raise ValueError('expected (addr, port) or (socket,) tuple but got %s' % chaperoneDetails)
cls.__muxer = BotMuxer(playgroundAddress)
cls.__playgroundAddress = playgroundAddress
return connectProtocol(chaperoneEndpoint, cls.__muxer.chaperone)
def new_proxy_conn(self, conn_id):
"""Create a connection to HTTP proxy corresponding to the given ID.
Return a Deferred object of the proxy connector.
"""
logging.info("adding connection id " + conn_id)
try:
assert conn_id not in self.proxy_write_queues_dict
self.proxy_write_queues_dict[conn_id] = dict()
self.proxy_write_queues_index_dict[conn_id] = 100000
self.proxy_connectors_dict[conn_id] = ProxyConnector(self, conn_id)
point, connector = self.proxy_point, self.proxy_connectors_dict[
conn_id]
d = connectProtocol(point, connector)
d.addCallback(lambda ignored: self.proxy_write(conn_id))
d.addErrback(lambda ignored: logging.error("cannot connect proxy"))
except AssertionError:
logging.error("duplicate id")
def test_binary_handshake(self):
ep = clientFromString(reactor, self.transit)
a1 = yield connectProtocol(ep, Accumulator())
binary_bad_handshake = b"\x00\x01\xe0\x0f\n\xff"
# the embedded \n makes the server trigger early, before the full
# expected handshake length has arrived. A non-wormhole client
# writing non-ascii junk to the transit port used to trigger a
# UnicodeDecodeError when it tried to coerce the incoming handshake
# to unicode, due to the ("\n" in buf) check. This was fixed to use
# (b"\n" in buf). This exercises the old failure.
a1.transport.write(binary_bad_handshake)
exp = b"bad handshake\n"
yield a1.waitForBytes(len(exp))
self.assertEqual(a1.data, exp)
a1.transport.loseConnection()
def SetupConnection(self, addr, endpoint=None):
if len(self.Peers
) + self.peers_connecting < settings.CONNECTED_PEER_MAX:
try:
host, port = addr.split(':')
if endpoint:
point = endpoint
else:
point = TCP4ClientEndpoint(self.reactor,
host,
int(port),
timeout=5)
self.peers_connecting += 1
d = connectProtocol(point, NeoNode()) # type: Deferred
d.addErrback(self.clientConnectionFailed, addr)
return d
except Exception as e:
logger.error(f"Setup connection with with {e}")
def create_client(reactor, host, port):
"""
Start a Nats Protocol and connect it to a NATS endpoint over TCP4
which subscribes a subject with a callback that sends a response
if it gets a reply_to.
"""
log.info("Start client.")
point = TCP4ClientEndpoint(reactor, host, port)
nats_protocol = txnats.io.NatsProtocol(verbose=False, on_connect=listen)
# Because NatsProtocol implements the Protocol interface, Twisted's
# connectProtocol knows how to connected to the endpoint.
connecting = connectProtocol(point, nats_protocol)
# Log if there is an error making the connection.
connecting.addErrback(lambda np: log.info("{p}", p=np))
# Log what is returned by the connectProtocol.
connecting.addCallback(lambda np: log.info("{p}", p=np))
return connecting
def requestSignOfToken(user_id, ballot_id, blind_token):
destination_deferred = yield TCP4ClientEndpoint(reactor,
accountverifier_ip,
accountverifier_port)
connection_deferred = yield connectProtocol(destination_deferred, AMP())
result_deferred = yield connection_deferred.callRemote(
OnlineAccountVerifier_SignBlindToken,
user_id=user_id,
ballot_id=ballot_id,
blind_token=blind_token)
def format_results(pickled_result):
signed_blind_token = pickle.loads(pickled_result['ok'])
return signed_blind_token
# Inlinecallback return value.
returnValue(format_results(result_deferred))
def get_ldap_client(self):
"""
Returns a Deferred that fires with an asynchronous LDAP client.
"""
log = self.log
log.debug(
"{classname}: Entered `get_ldap_client()`. self.id == {instance_id}",
classname=self.__class__.__name__,
instance_id=id(self))
client = self.client_
if not client is None:
self.clear_scheduled_unbind_()
log.debug(
"{classname}: Cleared scheduled UNBIND; returning existing LDAP client.",
classname=self.__class__.__name__)
returnValue(client)
start_tls = self.start_tls
endpoint_s = self.endpoint_s
bind_dn = self.bind_dn
bind_passwd = self.bind_passwd
reactor = self.reactor
ep = endpoints.clientFromString(reactor, endpoint_s)
log.debug("LDAP endpoint: {endpoint}", endpoint=endpoint_s)
client = yield endpoints.connectProtocol(ep, ldapclient.LDAPClient())
self.client_ = client
log.debug("Client connection established to LDAP endpoint.")
try:
if start_tls:
yield client.startTLS()
log.debug("{classname}: LDAP client initiated StartTLS.",
event_type='ldap_starttls',
classname=self.__class__.__name__)
if bind_dn and bind_passwd:
yield client.bind(bind_dn, bind_passwd)
log.debug("LDAP client BIND as '{bind_dn}'.",
event_type='ldap_bind',
bind_dn=bind_dn)
except Exception:
self.unbind_client_()
raise
self.clear_scheduled_unbind_()
log.debug("'{classname}': Returning new LDAP client.",
classname=self.__class__.__name__)
returnValue(client)
def handle_addr(self, peers):
if self.remote_nodeid is not None and self.conn_debug:
reload_node_dict()
print("{} EXTRACTING ADDR FROM {}".format(
self.nodename, node_2_id_lookup[self.remote_nodeid]))
if peers is not None:
for remote_ip, remote_nodeid in peers:
if (
remote_ip, remote_nodeid
) not in self.node.connected_servers and str(
remote_nodeid
) != self.node.node_server_id and self.node.curr_outgoing_conns < self.node.MAX_OUTGOING_CONN:
host, port = str(remote_ip).split(":")
point = TCP4ClientEndpoint(reactor, str(host), int(port))
xpr = XpeerClientProtocol(None, self.node)
self.node.xpeerprotocols.append(xpr)
d = connectProtocol(point, xpr)
d.addCallback(self.node.gotProtocol)
self.node.curr_outgoing_conns += 1
self.node.Portal.update_connections_count(
self.node.curr_outgoing_conns,
self.node.curr_incoming_conns)
elif self.node.curr_outgoing_conns >= self.node.MAX_OUTGOING_CONN:
reload_node_dict()
print("{} REACHED MAX OUTGOING CONNECTION.".format(
self.nodename))
#after conn is complete send my server info to server i'm connected to so it can connect to my server
finalize = json.dumps({
'myserveraddr':
[self.node.node_server_ip, self.node.node_server_id],
'myname':
self.nodename,
'msgtype':
'finalize'
})
self.transport.write(finalize + "\n")
self.lc_ping.start(60 * 3)
self.send_init_blockchain_request()
def handle_hello(self, data):
self.remote_nodeid = data['data']
if self.remote_nodeid == self.nodeid:
print("Connected to myself.")
self.transport.loseConnection()
else:
host_ip = str(data['remote_ip'])
self.lc_ping.start(60)
self.send_addr()
if host_ip not in self.factory.connection_list:
self.factory.peers[self.remote_nodeid] = self
self.factory.pair[self.remote_nodeid] = host_ip
ip = host_ip.split(':')[0]
port = host_ip.split(':')[1]
self.factory.connection_list.add(host_ip)
self.factory.host_list.add(host_ip)
point = TCP4ClientEndpoint(reactor, ip, int(port))
d = connectProtocol(point, MyProtocol(factory))
d.addCallback(gotProtocol)
def main():
obj_hash = hash_broadcast_replicate()
# endpoint = TCP4ServerEndpoint(reactor, 5999)
# mcx = MyFactory()#peer1 initialization
# endpoint.listen(mcx)
PEER_LIST = [
"localhost:5999", "localhost:5998", "localhost:5997", "localhost:5996"
] #4 node p2p n/w hosted on local host having different ports
for peer in PEER_LIST:
endpoint = TCP4ServerEndpoint(reactor, 5999)
mcx = MyFactory() # peers initialization
endpoint.listen(mcx)
host, port = peer.split(":")
point = TCP4ClientEndpoint(reactor, host, int(port))
d = connectProtocol(point, MyProtocol(mcx, 2))
d.addCallback(gotProtocol)
reactor.run()
def __listenerStarted(cls, result, reactor, gateAddr, gatePort,
callbackPort, callbackProtocolFactory, point,
connectD):
gateKey = (gateAddr, gatePort)
if cls.GATES.has_key(gateKey):
cls.logger.info("Already connected.")
cls.__controlConnected("Already Connected", callbackPort,
cls.GATES[gateKey][1],
callbackProtocolFactory, point, connectD)
#d = Deferred()
else:
cls.logger.info("Starting outbound connection to gate.")
gatePoint = TCP4ClientEndpoint(reactor, gateAddr, gatePort)
gateProtocol = GateProtocol()
cls.GATES[gateKey] = (gatePoint, gateProtocol)
d = connectProtocol(gatePoint, gateProtocol)
d.addCallback(cls.__controlConnected, callbackPort, gateProtocol,
callbackProtocolFactory, point, connectD)
d.addErrback(cls.__controlConnectFailed, gateKey, connectD)
def setUpClass(cls):
assert (cls.channel) # set by client implementation
# if channel.startswith("serial:"):
# serial_device=channel[7:]
# self.transport=SerialPort(RemoteTestProtocol(), serial_device, reactor)
# logging.info("Connecting via {0} ...".format(serial_device))
if cls.channel.startswith("tcp:"):
prefix, host, port = cls.channel.split(':')
port = int(port)
logging.info("Connecting via {0}:{1} ...".format(host, port))
cls.endpoint = TCP4ClientEndpoint(reactor, host, port)
cls.protocol = None
d = connectProtocol(cls.endpoint, RemoteTestClientProtocol())
d.addCallback(cls.gotProtocol)
# start blocking reactor with event loop in separate thread
Thread(target=reactor.run, args=(False, )).start()
def connect_to(self, ip, port):
"""This method connect to a node *'as a client'*
[description]
:param ip: id address
:type ip: str
:param port: port number
:type port: int
*@Override from ClientProtocol*
"""
def to_do(protocol):
protocol.send_handshake()
time.time(60)
protocol.send_get_blockchain()
connection_point = TCP4ClientEndpoint(reactor, ip, int(port))
d = connectProtocol(connection_point,
P2Protocol(self.factory, node_type=2))
d.addCallback(to_do)
def sync_with_node(self, finalize):
finalize = json.loads(finalize)
sender_server_ip, sender_server_id = finalize["myserveraddr"]
if self.node.curr_outgoing_conns < self.node.MAX_OUTGOING_CONN and (
sender_server_ip,
sender_server_id) not in self.node.connected_servers:
host, port = sender_server_ip.split(":")
point = TCP4ClientEndpoint(reactor, str(host), int(port))
xpr = XpeerClientProtocol(None, self.node)
self.node.xpeerprotocols.append(xpr)
d = connectProtocol(point, xpr)
d.addCallback(self.node.gotProtocol)
self.node.curr_outgoing_conns += 1
self.node.Portal.update_connections_count(
self.node.curr_outgoing_conns, self.node.curr_incoming_conns)
elif self.node.curr_outgoing_conns >= self.node.MAX_OUTGOING_CONN:
reload_node_dict()
print("{} REACHED MAX OUTGOING CONNECTION.".format(self.nodename))
def trigger_session(src_range, dst_range, **kwargs):
""" This function triggers a single session by creating an instance of the Trigger
class and then calling the connectProtocol method on its deffered.
It also adds an errBack so we can see if it fails in the logs."""
# Default arguements
service_type = config.default_service_type
bidirectional = config.default_bidirectional
session_duration = config.default_session_duration
traffic = config.default_traffic
ditgoptarg = config.default_ditgoptarg
# Generate a randomized IP if required
src, dst = randomize_ip(src_range, dst_range)
# Deal with any optionally supplied kwargs
if kwargs.has_key('service_type'):
service_type = kwargs['service_type']
if kwargs.has_key('session_duration'):
session_duration = kwargs['session_duration']
if isinstance(session_duration, list):
sd = random.randint(session_duration[0], session_duration[1])
print "SD = %d" % sd
session_duration = float(sd)
if kwargs.has_key('exponential'):
session_duration = random.expovariate(1.0/session_duration)
if kwargs.has_key('traffic'):
traffic = kwargs['traffic']
if kwargs.has_key('bidirectional'):
bidirectional = kwargs['bidirectional']
if kwargs.has_key('ditgoptarg'):
ditgoptarg = kwargs['ditgoptarg']
# Create an instance of Trigger & call its connect method
prot = Trigger(src, dst, service_type, session_duration, traffic, bidirectional, ditgoptarg)
d = connectProtocol(config.point, prot)
d.addErrback(err1)
def get_ballot_information(prev_result):
destination = TCP4ClientEndpoint(reactor, self.twisted_ballotregulator_ip, self.twisted_ballotregulator_port)
requestsearchuser_deferred = connectProtocol(destination, AMP())
def requestsearchuser_connected(ampProto):
return ampProto.callRemote(OnlineBallotRegulator_SearchBallotsAvailableForAllBallots)
requestsearchuser_deferred.addCallback(requestsearchuser_connected)
def done(result):
'''
Returns the record ascociated with the ballot_id
:param result:
:return:
'''
unpickled_result = pickle.loads(result['ok'])
# Transform the list results into a dictionary.
record_list = []
for record in unpickled_result:
mapper = {}
mapper['ballot_id'] = record[0]
mapper['ballot_name'] = record[1]
mapper['ballot_address'] = record[2]
mapper['timestamp'] = record[3]
# Append each row's dictionary to a list
record_list.append(mapper)
# Check the available ballots for *our* ballot
for record in record_list:
if record['ballot_id'] == ballot_id:
return record
# If we reach here we havent found *our* ballot in the list available
raise BallotNotAvailable(ballot_id)
def done_errback(failure):
raise failure.raiseException()
parsed_results = requestsearchuser_deferred.addCallback(done).addErrback(done_errback)
return parsed_results
def handle_peers(self, data):
log("Recieved peers from node " + str(self.remotePeer) + " - Total : " + str(len(data['peers'])))
# print data['peers']
for node, info in data['peers'].iteritems():
log("Trying to connect to node - " + node )
if(node == self.factory.nodeId):
log("That's me in the recieved peer list - IGNORING", "warning")
continue
if(node in self.factory.peers):
log("Already connected to this node - IGNORING", "warning")
continue
if info['type'] != "SERVER":
log("That node is a "+ data['peers'][node]['type'] +" - IGNORING", "warning");
continue
location = info['location']
host, port = location.split(":")
point = TCP4ClientEndpoint(reactor, host, int(port))
d = connectProtocol(point, MyPeerServer(self.factory))
d.addCallback(gotProtocol)
async def connect(self, host, port, connect_timeout,
source_address=None, socket_options=None):
# HostnameEndpoint only supports setting source host, not source port
if source_address is not None:
raise NotImplementedError(
"twisted backend doesn't support setting source_address")
# factory = protocol.Factory.forProtocol(TwistedSocketProtocol)
endpoint = HostnameEndpoint(self._reactor, host, port)
d = connectProtocol(endpoint, TwistedSocketProtocol())
# XX d.addTimeout(...)
protocol = await d
if socket_options is not None:
for opt in socket_options:
if opt[:2] == (socket.IPPROTO_TCP, socket.TCP_NODELAY):
protocol.transport.setTcpNoDelay(opt[2])
else:
raise NotImplementedError(
"unrecognized socket option for twisted backend")
return TwistedSocket(protocol)
def requestRegisterNewBallot(ballot_name, ballot_options_array,
ballot_end_date):
ballot_options_array_pickled = pickle.dumps(ballot_options_array)
destination_deferred = yield TCP4ClientEndpoint(reactor,
ballotregulator_ip,
ballotregulator_port)
connection_deferred = yield connectProtocol(destination_deferred, AMP())
result_deferred = yield connection_deferred.callRemote(
OnlineBallotRegulator_RegisterBallotId,
ballot_name=ballot_name,
ballot_options_array_pickled=ballot_options_array_pickled,
ballot_end_date=ballot_end_date)
def format_results(result):
return result['ballot_address']
# Inlinecallback return value.
returnValue(format_results(result_deferred))
def get_ldap_client_(self):
"""
Get an authenticated LDAP client.
"""
log = self.log
endpoint_s = self.endpoint_s
bind_dn = self.bind_dn
bind_passwd = self.bind_passwd
base_dn = self.base_dn
reactor = self.reactor
use_starttls = self.use_starttls
starttls_trust_anchor = self.starttls_trust_anchor
log.debug("Endpoint: {endpoint}", endpoint=endpoint_s)
e = clientFromString(reactor, endpoint_s)
client = yield connectProtocol(e, ldapclient.LDAPClient())
if use_starttls:
log.debug("StartTLS trust anchor: {trust}",
trust=starttls_trust_anchor)
yield client.startTLS(starttls_trust_anchor)
yield client.bind(bind_dn, bind_passwd)
defer.returnValue(client)
def main(reactor):
log.startLogging(sys.stdout)
entry = {
"dn": "gn=Jane+sn=Doe,ou=people,dc=example,dc=fr",
"c": "US",
"gn": "Jane",
"l": "Philadelphia",
"objectClass": "addressbookPerson",
"postalAddress": "230",
"postalCode": "314159",
"sn": "Doe",
"st": "PA",
"street": "Mobius Strip",
"userPassword": "******",
}
endpoint_str = "tcp:host=localhost:port=8080"
e = clientFromString(reactor, endpoint_str)
d = connectProtocol(e, LDAPClient())
d.addCallback(onConnect, entry)
d.addErrback(onError, reactor)
return d
def main(reactor):
host = "demo.nats.io"
port = 4222
# TODO: make a NatsClient that does this, choosing the proper endpoint
point = TCP4ClientEndpoint(reactor, host, port)
nats_protocol = txnats.io.NatsProtocol(verbose=False,
on_msg=my_on_msg,
on_connect=somePubSubbing)
# Because NatsProtocol implements the Protocol interface, Twisted's
# connectProtocol knows how to connected to the endpoint.
connecting = connectProtocol(point, nats_protocol)
# Log if there is an error making the connection.
connecting.addErrback(lambda np: log.info("{p}", p=np))
# Log what is returned by the connectProtocol.
connecting.addCallback(lambda np: log.info("{p}", p=np))
return connecting
def spawnNewConnection(self, dstAddr, dstPort):
if self._connections.has_key((dstAddr, dstPort)):
d = Deferred()
self._connComponents.reactor.callLater(
0, d.errback,
Failure("Already have a connection for this destination"))
return d
logger.info(
"Port map for %d (resvId %d) spawning new connection from %s %d" %
(self._portNum, self.__resvId, dstAddr, dstPort))
gConn = self._createDataProtocol(dstAddr, dstPort)
point = TCP4ClientEndpoint(self._connComponents.reactor,
self._connComponents.revAddr,
self._connComponents.revPort)
spawnD = Deferred()
d = connectProtocol(point, gConn)
self._connections[(dstAddr, dstPort)] = ("deferred", spawnD)
d.addCallback(self.__revConnected, self.__resvId, dstAddr, dstPort,
point, gConn)
d.addErrback(self.__revFailed, dstAddr, dstPort)
return spawnD
