def parsleyTests(messages):
NetstringProtocol = makeProtocol(grammarSource, Sender, Receiver)
proto = NetstringProtocol()
transport = StringTransport()
proto.makeConnection(transport)
for message in messages:
proto.dataReceived(message)
def __init__(self, reactor, plm):
self.reactor = reactor
self.plm = plm
self.protocol = parsley.makeProtocol(self.insteon_grammar,
self.senderFactory,
self.receiverFactory,
{'InsteonAddress': InsteonAddress,
'InsteonMessageFlags': InsteonMessageFlags})
currentRule = 'receiveNetstring'
def __init__(self, sender):
self.sender = sender
def prepareParsing(self, parser):
pass
def finishParsing(self, reason):
pass
def netstringReceived(self, string):
self.sender.sendNetstring(string)
NetstringProtocol = makeProtocol(
grammar, NetstringSender, NetstringReceiver)
class NetstringFactory(Factory):
protocol = NetstringProtocol
def main(reactor):
server = TCP4ServerEndpoint(reactor, 1234)
d = server.listen(NetstringFactory())
d.addCallback(lambda p: Deferred()) # listen forever
return d
react(main, [])
self.sender.sendStreamConnect(
self.factory.session.id, self.factory.dest,
self.factory.port, self.factory.localPort)
self.currentRule = 'State_connect'
def connect(self, result, message=None):
if result != c.RESULT_OK:
self.factory.resultNotOK(result, message)
return
self.factory.streamConnectionEstablished(self)
self.currentRule = 'State_readData'
StreamConnectProtocol = makeProtocol(
grammar.samGrammarSource,
StreamConnectSender,
StreamConnectReceiver)
class StreamConnectFactory(SAMFactory):
protocol = StreamConnectProtocol
def __init__(self, clientFactory, session, host, dest, port=None, localPort=None):
self._clientFactory = clientFactory
self.session = session
self.host = host
self.dest = dest
self.port = port
self.localPort = localPort
self.deferred = Deferred(self._cancel);
def _sendRequest(self):
self.sender.sendRequest(
c.CMD_CONNECT, self.factory.host, self.factory.port)
self.currentRule = 'SOCKS5ClientState_readResponse'
def serverResponse(self, status, address, port):
if status != c.SOCKS5_GRANTED:
raise e.socks5ErrorMap.get(status)()
self.factory.proxyConnectionEstablished(self)
self.currentRule = 'SOCKSState_readData'
SOCKS5Client = makeProtocol(
grammar.grammarSource,
SOCKS5Sender,
stack(SOCKS5AuthDispatcher, SOCKS5Receiver),
grammar.bindings)
class SOCKS5ClientFactory(_SOCKSClientFactory):
protocol = SOCKS5Client
authMethodMap = {
'anonymous': c.AUTH_ANONYMOUS,
'login': c.AUTH_LOGIN,
}
def __init__(self, host, port, proxiedFactory, methods={'anonymous': ()}):
if not methods:
raise ValueError('no auth methods were specified')
self.host = host
print 'Tunnel removed'
self.factory.i2pTunnelRemoved()
self.sender.sendQuit()
self.currentRule = 'State_quit'
else:
if info in ['tunnel is active',
'tunnel shutting down']:
# Try again. TODO: Limit retries
self.sender.sendClear()
else:
print 'clear ERROR: %s ' % info
# A Protocol for making an I2P client tunnel via BOB
I2PClientTunnelCreatorBOBClient = makeProtocol(
grammar.bobGrammarSource,
BOBSender,
I2PClientTunnelCreatorBOBReceiver)
# A Protocol for making an I2P server tunnel via BOB
I2PServerTunnelCreatorBOBClient = makeProtocol(
grammar.bobGrammarSource,
BOBSender,
I2PServerTunnelCreatorBOBReceiver)
# A Protocol for removing a BOB I2P tunnel
I2PTunnelRemoverBOBClient = makeProtocol(
grammar.bobGrammarSource,
BOBSender,
I2PTunnelRemoverBOBReceiver)
currentRule = 'receiveNetstring'
def __init__(self, sender):
self.sender = sender
def prepareParsing(self, parser):
pass
def finishParsing(self, reason):
pass
def netstringReceived(self, string):
self.sender.sendNetstring(string[::-1])
NetstringReverser = makeProtocol(
grammar, NetstringSender, NetstringReverserReceiver)
class NetstringReverserFactory(ServerFactory):
protocol = NetstringReverser
def main(reactor):
server = TCP4ServerEndpoint(reactor, 1234)
d = server.listen(NetstringReverserFactory())
d.addCallback(lambda p: Deferred())
return d
react(main, [])
print('Tunnel removed')
self.factory.i2pTunnelRemoved()
self.sender.sendQuit()
self.currentRule = 'State_quit'
else:
if info in ['tunnel is active',
'tunnel shutting down']:
# Try again. TODO: Limit retries
self.sender.sendClear()
else:
print('clear ERROR: %s ' % info)
# A Protocol for making an I2P client tunnel via BOB
I2PClientTunnelCreatorBOBClient = makeProtocol(
grammar.bobGrammarSource,
BOBSender,
I2PClientTunnelCreatorBOBReceiver)
# A Protocol for making an I2P server tunnel via BOB
I2PServerTunnelCreatorBOBClient = makeProtocol(
grammar.bobGrammarSource,
BOBSender,
I2PServerTunnelCreatorBOBReceiver)
# A Protocol for removing a BOB I2P tunnel
I2PTunnelRemoverBOBClient = makeProtocol(
grammar.bobGrammarSource,
BOBSender,
I2PTunnelRemoverBOBReceiver)
additionArgs = additionParsed = None
def auth_addition(self, *a):
self.additionArgs = a
self.sender.transport.write('addition!')
self.currentRule = 'authAddition'
def authedAddition(self, x):
self.additionParsed = x
del self.currentRule
self.w._sendRequest()
AdditionAuthSOCKS5Client = makeProtocol(
grammar.grammarSource + authAdditionGrammar, client.SOCKS5Sender,
stack(client.SOCKS5AuthDispatcher, AuthAdditionWrapper,
client.SOCKS5Receiver), grammar.bindings)
class TestSOCKS5Client(unittest.TestCase):
def makeProto(self, *a, **kw):
protoClass = kw.pop('_protoClass', client.SOCKS5Client)
fac = FakeSOCKS5ClientFactory(*a, **kw)
fac.protocol = protoClass
proto = fac.buildProtocol(None)
transport = proto_helpers.StringTransport()
transport.abortConnection = lambda: None
proto.makeConnection(transport)
return fac, proto
def test_initialHandshake(self):
self.sender = sender
self.netstrings = []
self.connected = False
self.lossReason = None
def netstringReceived(self, s):
self.netstrings.append(s)
def prepareParsing(self, parser):
self.connected = True
def finishParsing(self, reason):
self.lossReason = reason
TestingNetstringProtocol = parsley.makeProtocol(netstrings.grammar, netstrings.NetstringSender, FakeReceiver)
def build_testing_protocol():
protocol = TestingNetstringProtocol()
transport = StringTransport()
protocol.makeConnection(transport)
return protocol, transport
def test_receiving_empty_netstring():
protocol, transport = build_testing_protocol()
protocol.dataReceived("0:,")
assert protocol.receiver.netstrings == [""]
def ctcp_ACTION(self, line, arguments):
self.w.action(
line, IRCUser.fromFull(line.prefix), line.params[0], arguments)
class CAPNegotiator(WrapperBase):
def connectionMade(self):
self.w.sender.sendLine('CAP LS')
self.w.connectionMade()
def irc_CAP(self, line):
if line.params[1] == 'LS':
supported = set(line.params[2].split())
toRequest = supported.intersection(self.w.capExtensions)
if toRequest:
self.w.sender.sendCommand('CAP', ['REQ', ' '.join(toRequest)])
else:
self.w.sender.sendLine('CAP END')
elif line.params[1] == 'ACK':
print line
self.w.sender.sendLine('CAP END')
else:
self.w.unknownCommand(line)
IRCClient = parsley.makeProtocol(
ircGrammar,
IRCSender,
parsley.stack(NullIRCReceiver, BaseIRCFunctionality, IRCDispatcher),
bindings)
def __init__(self, sender):
self.sender = sender
self.netstrings = []
self.connected = False
self.lossReason = None
def netstringReceived(self, s):
self.netstrings.append(s)
def prepareParsing(self, parser):
self.connected = True
def finishParsing(self, reason):
self.lossReason = reason
TestingNetstringProtocol = parsley.makeProtocol(
netstrings.grammar, netstrings.NetstringSender, FakeReceiver)
def build_testing_protocol():
protocol = TestingNetstringProtocol()
transport = StringTransport()
protocol.makeConnection(transport)
return protocol, transport
def test_receiving_empty_netstring():
protocol, transport = build_testing_protocol()
protocol.dataReceived('0:,')
assert protocol.receiver.netstrings == ['']
def test_receiving_one_netstring_by_byte():
protocol, transport = build_testing_protocol()
for c in '4:spam,':
currentRule = 'receiveNetstring'
def __init__(self, sender):
self.sender = sender
def prepareParsing(self, parser):
pass
def finishParsing(self, reason):
pass
def netstringReceived(self, string):
self.sender.sendNetstring(string)
NetstringProtocol = makeProtocol(grammar, NetstringSender, NetstringReceiver)
class NetstringFactory(Factory):
protocol = NetstringProtocol
def main(reactor):
server = TCP4ServerEndpoint(reactor, 1234)
d = server.listen(NetstringFactory())
d.addCallback(lambda p: Deferred()) # listen forever
return d
react(main, [])
additionArgs = additionParsed = None
def auth_addition(self, *a):
self.additionArgs = a
self.sender.transport.write("addition!")
self.currentRule = "authAddition"
def authedAddition(self, x):
self.additionParsed = x
del self.currentRule
self.w._sendRequest()
AdditionAuthSOCKS5Client = makeProtocol(
grammar.grammarSource + authAdditionGrammar,
client.SOCKS5Sender,
stack(client.SOCKS5AuthDispatcher, AuthAdditionWrapper, client.SOCKS5Receiver),
grammar.bindings,
)
class TestSOCKS5Client(unittest.TestCase):
def makeProto(self, *a, **kw):
protoClass = kw.pop("_protoClass", client.SOCKS5Client)
fac = FakeSOCKS5ClientFactory(*a, **kw)
fac.protocol = protoClass
proto = fac.buildProtocol(None)
transport = proto_helpers.StringTransport()
transport.abortConnection = lambda: None
proto.makeConnection(transport)
return fac, proto
self.sender.join("#colontea")
def unknownCommand(self, line):
print line
def unknownCTCP(self, line, command, params):
print line, command, params
IRCClient = parsley.makeProtocol(
parslirc.ircGrammar,
parslirc.IRCSender,
parsley.stack(
parslirc.IRCDispatcher,
parslirc.CTCPDispatcher,
parslirc.CAPNegotiator,
parslirc.BaseIRCFunctionality,
SpewingWrapper,
parslirc.NullIRCReceiver,
),
parslirc.bindings,
)
class IRCClientFactory(Factory):
protocol = IRCClient
def main(reactor, description):
client = clientFromString(reactor, description)
d = client.connect(policies.SpewingFactory(IRCClientFactory()))
def _sendRequest(self):
self.sender.sendRequest(c.CMD_CONNECT, self.factory.host,
self.factory.port)
self.currentRule = 'SOCKS5ClientState_readResponse'
def serverResponse(self, status, address, port):
if status != c.SOCKS5_GRANTED:
raise e.socks5ErrorMap.get(status)()
self.factory.proxyConnectionEstablished(self)
self.currentRule = 'SOCKSState_readData'
SOCKS5Client = makeProtocol(grammar.grammarSource, SOCKS5Sender,
stack(SOCKS5AuthDispatcher, SOCKS5Receiver),
grammar.bindings)
class SOCKS5ClientFactory(_SOCKSClientFactory):
protocol = SOCKS5Client
authMethodMap = {
'anonymous': c.AUTH_ANONYMOUS,
'login': c.AUTH_LOGIN,
}
def __init__(self, host, port, proxiedFactory, methods={'anonymous': ()}):
if not methods:
raise ValueError('no auth methods were specified')
self.host = host
def postLookup(self, dest):
# Help keep the session open
if cmpSAM(self.factory.samVersion, '3.2') >= 0:
self.startPinging()
else:
try:
self.sender.transport.setTcpKeepAlive(1)
except AttributeError as e:
eprint(e)
self.factory.sessionCreated(self, dest)
# A Protocol for making a SAM session
SessionCreateProtocol = makeProtocol(
grammar.samGrammarSource,
SessionCreateSender,
SessionCreateReceiver)
class SessionCreateFactory(SAMFactory):
protocol = SessionCreateProtocol
def __init__(self, nickname, style='STREAM', keyfile=None, localPort=None, options={}, sigType=None):
if style != 'STREAM':
raise error.UnsupportedSocketType()
self.nickname = nickname
self.style = style
self._keyfile = keyfile
self.localPort = localPort
self.options = options
self.sigType = sigType
receivedLogger = Logger('Receiving')
def _doLog(a):
receivedLogger.debug('{a!r}', a=a)
return a
globalBindings = {
'parseInt8': parseInt8,
'parseInt16': parseInt16,
'parseInt32': parseInt32,
'parseInt64': parseInt64,
'log': _doLog,
'Message': Message
}
KafkaClientProtocol = makeProtocol(grammar_source, KafkaSender, KafkaReceiver,
bindings=globalBindings)
@inlineCallbacks
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)
def prepareParsing(self, parser):
pass
def finishParsing(self, reason):
pass
def netstringFirstHalfReceived(self, string):
self.sender.sendNetstring(string)
def netstringSecondHalfReceived(self, string):
pass
pass # begin protocol definition
NetstringProtocol = makeProtocol(
grammar,
stack(NetstringReversalWrapper, NetstringSender),
stack(NetstringSplittingWrapper, SplitNetstringReceiver))
class NetstringFactory(Factory):
protocol = NetstringProtocol
def main(reactor):
server = TCP4ServerEndpoint(reactor, 1234)
d = server.listen(NetstringFactory())
d.addCallback(lambda p: Deferred()) # listen forever
return d
react(main, [])
currentRule = 'receiveNetstring'
def __init__(self, sender):
self.sender = sender
def prepareParsing(self, parser):
pass
def finishParsing(self, reason):
pass
def netstringReceived(self, string):
self.sender.sendNetstring(string[::-1])
NetstringReverser = makeProtocol(grammar, NetstringSender,
NetstringReverserReceiver)
class NetstringReverserFactory(ServerFactory):
protocol = NetstringReverser
def main(reactor):
server = TCP4ServerEndpoint(reactor, 1234)
d = server.listen(NetstringReverserFactory())
d.addCallback(lambda p: Deferred())
return d
react(main, [])
