How do I achieve a webpush with data coming from a socket?

Here is my current code:

#!/usr/bin/env python
from twisted.application import internet, service
from twisted.application.service import IServiceMaker, MultiService
from twisted.protocols import basic
from twisted.internet  import reactor, protocol, defer
from twisted.internet.protocol import DatagramProtocol
import datetime

class WebPUSH(basic.LineReceiver):
    logTemplate = '''
      <script type="text/javascript">
         pushHandler.addLi('%s')
      </script>
    '''
    def __init__(self):
        self.gotRequest = False

    def lineReceived(self, line):
        if not self.gotRequest:
            self.startResponse()
            self.gotRequest = True

    def startResponse(self):
        self.sendLine('HTTP/1.1 200 OK')
        self.sendLine('Content-Type: text/html; charset=utf-8')
        self.sendLine('')
        f = open('index.html', 'r')
        self.transport.write( ''.join(f.read()) )
        f.close()
        self.logTime()

    def logTime(self):
        self.sendLine( self.logTemplate % datetime.datetime.now() )
        #reactor.callLater(2, self.logTime)

class Echo(DatagramProtocol):

    def datagramReceived(self, data, (host, port)):
        WebPUSH.logTime()
        print "received %r from %s:%d" % (data, host, port)
        self.transport.write(data, (host, port))

if __name__ == '__main__':    
    f = protocol.ServerFactory()
    f.protocol = WebPUSH
    reactor.listenTCP(8080, f)
    r开发者_Python百科eactor.listenUDP(9999, Echo())

    reactor.run()

As you can see, I am trying to call a method in WebPUSH from Echo when data is received. Because I never actually instantiate WebPUSH it doesn't look like I can easily call this method. I tried converting this to use a multiservice method but that didn't seem to work although I am sure I am doing something wrong.

There aren't (as far as I could google) any good examples on multiservice with twisted or atleast one like this.

Any help will be appreciated.

---

Echo instance needs an instance of WebPUSH protocol to call .logTime().

You need to maintain loggers list, e.g., in main():

...
f.loggers = []
echo = Echo()
echo.loggers = f.loggers
...

Add to it in WebPUSH.connectionMade, remove in WebPUSH.connectionLost:

def connectionMade(self):
    self.factory.loggers.append(self)

def connectionLost(self, reason):
    self.factory.loggers.remove(self)

then in Echo.datagramReceived:

for time_logger in self.loggers:
    time_logger.logTime()

---

user970077, the example in my blog was meant to be a simplified demo to show how the webpush work. Here is what you are trying to do (incorporating JFB suggestions):

#!/usr/bin/env python
from twisted.protocols import basic
from twisted.internet  import reactor, protocol, defer
import datetime

class WebPUSH(basic.LineReceiver):
    logTemplate = '''
      <script type="text/javascript">
         pushHandler.addLi('%s')
      </script>
    '''    
    def connectionMade(self):
       self.factory.listeners.append(self)
       self.startResponse()

    def connectionLost(self, reason):
        self.factory.listeners.remove(self)

    def lineReceived(self, line):
        self.sendLine( self.logTemplate % line )

    def startResponse(self):
        self.sendLine('HTTP/1.1 200 OK')
        self.sendLine('Content-Type: text/html; charset=utf-8')
        self.sendLine('')
        with open('index.html', 'r') as f:
            self.transport.write( ''.join(f.read()) )


class WebPushFactory(protocol.ServerFactory):

    protocol = WebPUSH

    def __init__(self):
        self.listeners = []


class Echo(protocol.DatagramProtocol):

    def __init__(self, listeners):
        self.listeners = listeners

    def datagramReceived(self, data, (host, port)):
        msg = '[%s:%s] %s' % (host, port, data)
        for listener in self.listeners:
            # udp is not necessarily line-oriented
            # so we can:
            # 1) feed dataReceived and wait until the line
            # delimiter arrives in an udp package 
            # triggering lineReceived:
            #listener.dataReceived( msg  )
            # or 2) fake a line by calling lineReceived direclty:
            listener.lineReceived( msg )

        print msg
        self.transport.write(data, (host, port))

if __name__ == '__main__':
    web = WebPushFactory()
    reactor.listenTCP(8080, web)
    reactor.listenUDP(9999, Echo(web.listeners))

    reactor.run() 

And a client to test it (taken from UDP client and server with Twisted Python):

#!/usr/bin/env python
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
from twisted.internet.task import LoopingCall
import sys, time

class HeartbeatSender(DatagramProtocol):
    def __init__(self, name, host, port):
        self.name = name
        self.loopObj = None
        self.host = host
        self.port = port

    def startProtocol(self):
        # Called when transport is connected
        # I am ready to send heart beats
        self.loopObj = LoopingCall(self.sendHeartBeat)
        self.loopObj.start(2, now=False)

    def stopProtocol(self):
        "Called after all transport is teared down"
        pass

    def datagramReceived(self, data, (host, port)):
        print "received %r from %s:%d" % (data, host, port)


    def sendHeartBeat(self):
        self.transport.write(self.name, (self.host, self.port))


if __name__ == '__main__':
    sender = HeartbeatSender("sender", "127.0.0.1", 9999)
    reactor.listenMulticast(9998, sender, listenMultiple=True)
    reactor.run()