def resolveHostName(self, resolutionReceiver, hostName, *args,
**kwargs):
portNumber = kwargs.pop('portNumber')
r = Resolution(name=hostName)
resolutionReceiver.resolutionBegan(r)
if hostName in HOST_MAP:
resolutionReceiver.addressResolved(
IPv4Address('TCP', HOST_MAP[hostName], portNumber))
resolutionReceiver.resolutionComplete()
return r
def test_request_state(self):
url = "https://www.globaleaks.org/"
request = forge_request(url)
self.api.render(request)
self.assertFalse(request.client_using_tor)
self.assertEqual(request.responseCode, 200)
request = forge_request(url,
client_addr=IPv4Address(
'TCP', '127.0.0.1', 12345))
self.api.render(request)
self.assertFalse(request.client_using_tor)
self.assertEqual(request.responseCode, 200)
request = forge_request(uri='http://127.0.0.1:8083/',
client_addr=IPv4Address(
'TCP', '127.0.0.1', 12345))
self.api.render(request)
self.assertTrue(request.client_using_tor)
self.assertEqual(request.responseCode, 200)
class MiniUDP(DatagramProtocol):
def datagramReceived(self, data, (host, port)):
try:
self.buffer += data
print "Recieved data: ", repr(data)
logdata = {'DATA': self.buffer.strip("\r\n\x00")}
self.transport.getPeer = lambda: IPv4Address('UDP', host, port)
self.factory.log(logdata=logdata, transport=self.transport)
except Exception as e:
print e
pass
def _create_connection(self, addr, port):
addr = IPv4Address('TCP', addr, port)
sender = self._factory.buildProtocol(addr)
client_proxy = portforward.ProxyClient()
sender.makeConnection(self.transport)
# portforward.ProxyClient is going to call setPeer but this
# probably doesn't have it...
setattr(sender, 'setPeer', lambda _: None)
client_proxy.setPeer(sender)
self._sender = sender
return sender
def makeRequest(self, method=b"GET", clientAddress=None):
"""
Create a L{DummyRequest} (change me to create a
L{twisted.web.http.Request} instead).
"""
if clientAddress is None:
clientAddress = IPv4Address("TCP", "localhost", 1234)
request = DummyRequest(b"/")
request.method = method
request.client = clientAddress
return request
def setUp(self):
'''
Set up a conencted state
'''
self.transport = proto_helpers.StringTransportWithDisconnection()
self.clock = task.Clock()
MQTTBaseProtocol.callLater = self.clock.callLater
self.factory = MQTTFactory(MQTTFactory.SUBSCRIBER)
self.addr = IPv4Address('TCP', 'localhost', 1880)
self._rebuild()
self._connect()
def listenTCP(self, port, factory, backlog=50, interface=''):
"""
Fake L{reactor.listenTCP}, that logs the call and returns an
L{IListeningPort}.
"""
self.tcpServers.append((port, factory, backlog, interface))
if isIPv6Address(interface):
address = IPv6Address('TCP', interface, port)
else:
address = IPv4Address('TCP', '0.0.0.0', port)
return _FakePort(address)
def test_login_reject_on_ip_filtering(self):
State.tenant_cache[1]['ip_filter_authenticated_enable'] = True
State.tenant_cache[1]['ip_filter_authenticated'] = '192.168.2.0/24'
handler = self.request({
'tid': 1,
'username': '******',
'password': helpers.VALID_PASSWORD1,
'token': ''
}, client_addr=IPv4Address('TCP', '192.168.1.1', 12345))
yield self.assertFailure(handler.post(), errors.AccessLocationInvalid)
def setUp(self):
self.factory = WebSocketClientFactory(protocols=['wamp.2.json'])
self.factory.protocol = WebSocketClientProtocol
self.factory.doStart()
self.proto = self.factory.buildProtocol(
IPv4Address('TCP', '127.0.0.1', 65534))
# self.transport = FakeTransport()
self.transport = MagicMock()
self.proto.transport = self.transport
self.proto.connectionMade()
def test_login_success_on_ip_filtering(self):
State.tenant_cache[1]['ip_filter']['admin'] = '192.168.2.0/24'
handler = self.request({
'tid': 1,
'username': '******',
'password': helpers.VALID_PASSWORD1,
'authcode': ''
}, client_addr=IPv4Address('TCP', '192.168.2.1', 12345))
response = yield handler.post()
self.assertTrue('session_id' in response)
self.assertEqual(len(Sessions), 1)
def test_bwHackDeprecation(self):
"""
If a value is passed for the C{_bwHack} parameter to L{IPv4Address},
a deprecation warning is emitted.
"""
# Construct this for warning side-effects, disregard the actual object.
IPv4Address("UDP", "127.0.0.3", 0, _bwHack="UDP")
message = (
"twisted.internet.address.IPv4Address._bwHack is deprecated "
"since Twisted 11.0")
return self.assertDeprecations(self.test_bwHackDeprecation, message)
def test_getHost(self):
"""
L{IListeningPort.getHost} returns an L{IPv4Address} giving a
dotted-quad of the IPv4 address the port is listening on as well as
the port number.
"""
host, portNumber = findFreePort(type=SOCK_DGRAM)
reactor = self.buildReactor()
port = reactor.listenUDP(portNumber,
DatagramProtocol(),
interface=host)
self.assertEqual(port.getHost(), IPv4Address('UDP', host, portNumber))
def test_log_message(self):
# Should be possible to customize the message which is logged.
TEST_STRING = "test-1234"
factory = WhitelistingFactory(
TestFactory(), [ip_network('127.0.0.1/32')], TEST_STRING
)
self.assertEqual(
factory.buildProtocol(IPv4Address('TCP', '127.0.0.2', 0)),
None
)
self.assertFalse("connection" in self.observer.messages[0][0])
self.assertTrue(TEST_STRING in self.observer.messages[0][0])
def from_db_tuple(cls, db: Tuple) -> "Member":
"""Instantiate a Member from a tuple created by Member.to_db_tuple()"""
member = Member(db[0], None)
member.signing_key = db[1] if db[1] is not None else None
member.head = db[2]
member.stake = db[3]
if db[4] is not None and db[5] is not None:
member.address = IPv4Address('TCP', db[4], db[5])
member.name = db[6]
return member
def test_build(self):
c = mock.Mock()
alsoProvides(c, IDilationConnector)
p0 = mock.Mock()
c.build_protocol = mock.Mock(return_value=p0)
f = InboundConnectionFactory(c)
addr = IPv4Address("TCP", "1.2.3.4", 55)
p = f.buildProtocol(addr)
self.assertIdentical(p, p0)
self.assertEqual(c.mock_calls,
[mock.call.build_protocol(addr, "<-tcp:1.2.3.4:55")])
self.assertIdentical(p.factory, f)
def test_connect(self):
reactor = MemoryReactorClock()
reactor.running = True
c = KafkaBrokerClient(reactor, 'kafka.example.com', 9092, 'clientId')
c._connect() # Force a connection attempt
c.connector.factory = c # MemoryReactor doesn't make this connection.
# Build the protocol, like a real connector would
addr = IPv4Address('TCP', '1.2.3.4', 9092)
c.buildProtocol(addr)
self.assertEqual(("<KafkaBrokerClient kafka.example.com:9092 "
"clientId='clientId' connected>"), repr(c))
def connectSSL(self, host, port, factory, contextFactory,
timeout=30, bindAddress=None):
"""
Fake L{IReactorSSL.connectSSL}, that logs the call and returns an
L{IConnector}.
"""
self.sslClients.append((host, port, factory, contextFactory,
timeout, bindAddress))
conn = _FakeConnector(IPv4Address('TCP', host, port))
factory.startedConnecting(conn)
self.connectors.append(conn)
return conn
def connectTCP(self, host, port, factory, timeout=30, bindAddress=None):
"""
Fake L{reactor.connectTCP}, that logs the call and returns an
L{IConnector}.
"""
self.tcpClients.append((host, port, factory, timeout, bindAddress))
if isIPv6Address(host):
conn = _FakeConnector(IPv6Address('TCP', host, port))
else:
conn = _FakeConnector(IPv4Address('TCP', host, port))
factory.startedConnecting(conn)
return conn
def datagramReceived(self, data, host_and_port):
try:
snmp = SNMP(data)
community = snmp.community.val
requests = [x.oid.val for x in snmp.PDU.varbindlist]
logdata = {'REQUESTS': requests, 'COMMUNITY_STRING': community}
self.transport.getPeer = lambda: IPv4Address(
'UDP', host_and_port[0], host_and_port[1])
self.factory.log(logdata=logdata, transport=self.transport)
except Exception as e:
print(e)
pass
def reset(self):
"""Delete the hashgraph and create a new one."""
DB.reset()
new_me = Member.create()
new_me.address = IPv4Address("TCP", bptc.ip, bptc.port)
new_hashgraph = Hashgraph(new_me)
self.hashgraph = new_hashgraph
self.hashgraph.add_own_event(
Event(self.hashgraph.me.verify_key, None, Parents(None, None)),
True)
self.last_push_sent = None
self.last_push_received = None
def test_login_localhost_on_ip_filtering(self):
State.tenant_cache[1]['ip_filter_authenticated_enable'] = True
State.tenant_cache[1]['ip_filter_authenticated'] = '192.168.2.0/24'
handler = self.request({
'tid': 1,
'username': '******',
'password': helpers.VALID_PASSWORD1,
'token': ''
}, client_addr=IPv4Address('TCP', '127.0.0.1', 12345))
response = yield handler.post()
self.assertTrue('session_id' in response)
self.assertEqual(len(Sessions), 1)
def test_build_protocol_custom_parameters(self):
"""Test building AMQClient instances with custom parameters."""
address = IPv4Address("TCP", "127.0.0.1", 5672)
spec = "../specs/rabbitmq/amqp0-8.stripped.rabbitmq.xml"
clock = Clock()
factory = AMQFactory(spec=spec, clock=clock)
factory.set_vhost("foo")
factory.set_heartbeat(1)
client = factory.buildProtocol(address)
self.assertEqual("foo", client.vhost)
self.assertEqual(spec, client.spec.file)
self.assertEqual(1, client.heartbeatInterval)
self.assertEqual(1, len(clock.getDelayedCalls()))
def listenSSL(self,
port,
factory,
contextFactory,
backlog=50,
interface=''):
"""
Fake L{IReactorSSL.listenSSL}, that logs the call and
returns an L{IListeningPort}.
"""
self.sslServers.append(
(port, factory, contextFactory, backlog, interface))
return _FakePort(IPv4Address('TCP', '0.0.0.0', port))
def adoptStreamPort(self, fileno, addressFamily, factory):
"""
Fake L{IReactorSocket.adoptStreamPort}, that logs the call and returns
an L{IListeningPort}.
"""
if addressFamily == AF_INET:
addr = IPv4Address('TCP', '0.0.0.0', 1234)
elif addressFamily == AF_INET6:
addr = IPv6Address('TCP', '::', 1234)
else:
raise UnsupportedAddressFamily()
self.adoptedPorts.append((fileno, addressFamily, factory))
return _FakePort(addr)
def handleQuery(self, message, protocol, address):
if protocol.transport.socket.type == socket.SOCK_STREAM:
self.peer_address = protocol.transport.getPeer()
elif protocol.transport.socket.type == socket.SOCK_DGRAM:
self.peer_address = IPv4Address('UDP', *address)
else:
print "Unexpected socket type %r" % protocol.transport.socket.type
for resolver in self.resolver.resolvers:
if hasattr(resolver, 'peer_address'):
resolver.peer_address = self.peer_address
return server.DNSServerFactory.handleQuery(self, message
protocol, address)
def setUp(self):
if False:
# debug leftover reactor events
import twisted.internet.base
twisted.internet.base.DelayedCall.debug = True
self.factory = WebSocketServerFactory(protocols=['wamp.2.json'])
self.factory.protocol = WebSocketServerProtocol
self.factory.doStart()
self.proto = self.factory.buildProtocol(IPv4Address('TCP', '127.0.0.1', 65534))
self.transport = MagicMock()
self.proto.transport = self.transport
self.proto.connectionMade()
def connectSSL(self,
host,
port,
factory,
contextFactory,
timeout=30,
bindAddress=None):
"""
Fake L{reactor.connectSSL}, that logs the call and returns an
L{IConnector}.
"""
self.sslClients.append(
(host, port, factory, contextFactory, timeout, bindAddress))
return _FakeConnector(IPv4Address('TCP', host, port))
def test_whois_protocol_no_access_list(self, config_override,
mock_pipeline_reactor):
config_override({
'sources': {
'TEST1': {}
},
})
mock_transport = Mock()
mock_transport.getPeer = lambda: IPv4Address('TCP', '127.0.0.1', 99999)
mock_factory = Mock()
mock_factory.current_connections = 10
receiver = WhoisQueryReceiver()
receiver.transport = mock_transport
receiver.factory = mock_factory
receiver.connectionMade()
assert receiver.peer_str == '[127.0.0.1]:99999'
assert receiver.query_pipeline_thread.started
assert receiver.timeOut == receiver.query_parser.timeout
mock_transport.reset_mock()
receiver.lineReceived(b' ')
receiver.lineReceived(b' !v ')
assert receiver.query_pipeline_thread.pipeline.get(block=False) == b' '
assert receiver.query_pipeline_thread.pipeline.get(
block=False) == b' !v '
receiver.query_parser.timeout = 5
receiver.query_pipeline_thread.response_callback(b'response')
assert mock_transport.mock_calls[0][0] == 'write'
assert mock_transport.mock_calls[0][1][0] == b'response'
assert mock_transport.mock_calls[1][0] == 'loseConnection'
assert len(mock_transport.mock_calls) == 2
assert receiver.timeOut == receiver.query_parser.timeout
mock_transport.reset_mock()
receiver.query_pipeline_thread.lose_connection_callback()
assert mock_transport.mock_calls[0][0] == 'loseConnection'
assert len(mock_transport.mock_calls) == 1
mock_transport.reset_mock()
receiver.query_parser.multiple_command_mode = True
receiver.query_pipeline_thread.response_callback(b'response')
assert mock_transport.mock_calls[0][0] == 'write'
assert len(mock_transport.mock_calls) == 1
receiver.connectionLost()
assert mock_factory.current_connections == 9
def testBuildProtocol(self):
portno = self.getFreePort()
f = AServerFactory(self, IPv4Address('TCP', '127.0.0.1', portno))
p = reactor.listenTCP(0, f)
self.ports.append(p)
spinUntil(lambda: p.connected)
acf = AClientFactory(self,
IPv4Address("TCP", "127.0.0.1",
p.getHost().port))
reactor.connectTCP("127.0.0.1",
p.getHost().port,
acf,
bindAddress=("127.0.0.1", portno))
spinUntil(lambda: acf.protocol is not None)
self.ports.append(acf.protocol.transport)
self.assert_(hasattr(self, "ran"))
spinUntil(lambda: acf.protocol.lostCnx)
del self.ran
def test_addresses(self):
"""
A client's transport's C{getHost} and C{getPeer} return L{IPv4Address}
instances which give the dotted-quad string form of the local and
remote endpoints of the connection respectively.
"""
host, port = findFreePort()
reactor = self.buildReactor()
server = reactor.listenTCP(0,
serverFactoryFor(Protocol),
interface=host)
serverAddress = server.getHost()
addresses = {'host': None, 'peer': None}
class CheckAddress(Protocol):
def makeConnection(self, transport):
addresses['host'] = transport.getHost()
addresses['peer'] = transport.getPeer()
reactor.stop()
clientFactory = Stop(reactor)
clientFactory.protocol = CheckAddress
reactor.connectTCP('localhost',
server.getHost().port,
clientFactory,
bindAddress=('127.0.0.1', port))
reactor.installResolver(FakeResolver({'localhost': '127.0.0.1'}))
self.runReactor(reactor)
self.assertEqual(addresses['host'],
IPv4Address('TCP', '127.0.0.1', port))
self.assertEqual(addresses['peer'],
IPv4Address('TCP', '127.0.0.1', serverAddress.port))
