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, [])