Exemplo n.º 1
0
    def clientconnector():
        return Pipeline(
            chunks_to_lines(),
            lines_to_tokenlists(),
            Graphline(
                WHITEBOARD=FilterAndTagWrapper(
                    Pipeline(
                        publishTo(whiteboardBackplane),
                        # well, should be to separate pipelines, this is lazier!
                        subscribeTo(whiteboardBackplane),
                    )),
                AUDIO=Pipeline(
                    SimpleDetupler(1),  # remove 'SOUND' tag
                    SpeexDecode(3),
                    FilterAndTagWrapperKeepingTag(
                        Pipeline(
                            publishTo(audioBackplane),
                            # well, should be to separate pipelines, this is lazier!
                            subscribeTo(audioBackplane),
                        ), ),
                    RawAudioMixer(),
                    SpeexEncode(3),
                    Entuple(prefix=["SOUND"], postfix=[]),
                ),
                ROUTER=Router(
                    ((lambda tuple: tuple[0] == "SOUND"), "audio"),
                    ((lambda tuple: tuple[0] != "SOUND"), "whiteboard"),
                ),
                linkages={
                    # incoming messages go to a router
                    ("", "inbox"): ("ROUTER", "inbox"),

                    # distribute messages to appropriate destinations
                    ("ROUTER", "audio"): ("AUDIO", "inbox"),
                    ("ROUTER", "whiteboard"): ("WHITEBOARD", "inbox"),

                    # aggregate all output
                    ("AUDIO", "outbox"): ("", "outbox"),
                    ("WHITEBOARD", "outbox"): ("", "outbox"),

                    # shutdown routing, not sure if this will actually work, but hey!
                    ("", "control"): ("ROUTER", "control"),
                    ("ROUTER", "signal"): ("AUDIO", "control"),
                    ("AUDIO", "signal"): ("WHITEBOARD", "control"),
                    ("WHITEBOARD", "signal"): ("", "signal")
                },
            ),
            tokenlists_to_lines(),
        )
Exemplo n.º 2
0
def EventServerClients(rhost, rport, backplane="WHITEBOARD"):
    # plug a TCPClient into the backplae
    from Kamaelia.Internet.TCPClient import TCPClient

    loadingmsg = "Fetching sketch from server..."

    return Pipeline(
        subscribeTo(backplane),
        TagAndFilterWrapper(
            Graphline(
                GETIMG=OneShot(msg=[["GETIMG"]]),
                PIPE=Pipeline(
                    tokenlists_to_lines(),
                    TCPClient(host=rhost, port=rport),
                    chunks_to_lines(),
                    lines_to_tokenlists(),
                ),
                BLACKOUT=OneShot(
                    msg=[["CLEAR", 0, 0, 0],
                         ["WRITE", 100, 100, 24, 255, 255, 255, loadingmsg]]),
                linkages={
                    ("self", "inbox"): ("PIPE", "inbox"),
                    ("self", "control"): ("PIPE", "control"),
                    ("PIPE", "outbox"): ("self", "outbox"),
                    ("PIPE", "signal"): ("self", "signal"),
                    ("GETIMG", "outbox"): ("PIPE", "inbox"),
                    ("BLACKOUT", "outbox"): ("self", "outbox"),
                },
            )),
        publishTo(backplane),
    )  #.activate()
Exemplo n.º 3
0
def EventServerClients(rhost, rport, backplane="WHITEBOARD"):
        # plug a TCPClient into the backplae
        from Kamaelia.Internet.TCPClient import TCPClient

        loadingmsg = "Fetching sketch from server..."

        return pipeline( subscribeTo(backplane),
                         TagAndFilterWrapper(
                         Graphline( GETIMG = OneShot(msg=[["GETIMG"]]),
                                    PIPE = pipeline(
                                            tokenlists_to_lines(),
                                            TCPClient(host=rhost,port=rport),
                                            chunks_to_lines(),
                                            lines_to_tokenlists(),
                                        ),
                                    BLACKOUT = OneShot(msg=[["CLEAR",0,0,0],["WRITE",100,100,24,255,255,255,loadingmsg]]),
                                    linkages = { ("self","inbox") : ("PIPE","inbox"),
                                                 ("self","control") : ("PIPE","control"),
                                                 ("PIPE","outbox") : ("self","outbox"),
                                                 ("PIPE","signal") : ("self","signal"),
                                                 ("GETIMG","outbox") : ("PIPE","inbox"),
                                                 ("BLACKOUT","outbox") : ("self","outbox"),
                                               },
                                  )
                         ),
                         publishTo(backplane),
                       ) #.activate()
Exemplo n.º 4
0
 def clientconnector():
     return Pipeline(
         chunks_to_lines(),
         lines_to_tokenlists(),
         Graphline(
             WHITEBOARD = FilterAndTagWrapper(
                 Pipeline( publishTo(whiteboardBackplane),
                           # well, should be to separate pipelines, this is lazier!
                           subscribeTo(whiteboardBackplane),
                         )),
             AUDIO = Pipeline(
                 SimpleDetupler(1),     # remove 'SOUND' tag
                 SpeexDecode(3),
                 FilterAndTagWrapperKeepingTag(
                     Pipeline( publishTo(audioBackplane),
                                 # well, should be to separate pipelines, this is lazier!
                             subscribeTo(audioBackplane),
                             ),
                     ),
                 RawAudioMixer(),
                 SpeexEncode(3),
                 Entuple(prefix=["SOUND"],postfix=[]),
                 ),
             ROUTER = Router( ((lambda tuple : tuple[0]=="SOUND"), "audio"),
                              ((lambda tuple : tuple[0]!="SOUND"), "whiteboard"),
                            ),
             linkages = {
                 # incoming messages go to a router
                 ("", "inbox") : ("ROUTER", "inbox"),
                 
                 # distribute messages to appropriate destinations
                 ("ROUTER",      "audio") : ("AUDIO",      "inbox"),
                 ("ROUTER", "whiteboard") : ("WHITEBOARD", "inbox"),
                 
                 # aggregate all output
                 ("AUDIO",      "outbox") : ("", "outbox"),
                 ("WHITEBOARD", "outbox") : ("", "outbox"),
                 
                 # shutdown routing, not sure if this will actually work, but hey!
                 ("", "control") : ("ROUTER", "control"),
                 ("ROUTER", "signal") : ("AUDIO", "control"),
                 ("AUDIO", "signal") : ("WHITEBOARD", "control"),
                 ("WHITEBOARD", "signal") : ("", "signal")
                 },
             ),
         tokenlists_to_lines(),
         )
Exemplo n.º 5
0
    def main(self):
        kpidb = self.kpidb
        while not self.dataReady("inbox"):
            yield 1
        data = self.recv("inbox")
        #got userid
        padding, userid = struct.unpack(
            '!2L', xtea.xtea_decrypt(kpidb.getRootKey(), data))

        #check if the user is valid
        if kpidb.isValidUser(userid) == False:
            #print "Invalid UserID" # todo shutdown
            return

        #generate a random number and encrypt it with user's key
        challenge = random.getrandbits(32)
        temp = struct.pack('!2L', 0, challenge)
        #look up user key from key database
        userkey = kpidb.getKPIKeys().getKey(userid)
        data = xtea.xtea_encrypt(userkey, temp)
        #print data, challenge, userkey
        self.send(data, "outbox")
        yield 1
        while not self.dataReady("inbox"):
            yield 1
        #got response to challenge
        data = self.recv("inbox")
        temp = xtea.xtea_decrypt(userkey, data)
        padding, response = struct.unpack('!2L', temp)
        #validate response
        if response == challenge + 1:
            self.send("SUCCESS", "outbox")
            yield 1
        else:
            #print "authenication failure"
            return  # shutdown

        #got OK ack
        while not self.dataReady("inbox"):
            yield 1
        data = self.recv("inbox")
        if data == "OK":
            #print "received ack from client"
            pass
        else:
            return  #shutdown

        #notify new user
        self.send(userid, "notifyuser")

        #subscribe to DataManagement backplane
        subscriber = subscribeTo("DataManagement")
        #make authenticator passthrough the data from DataManagement backplane
        self.link((subscriber, "outbox"), (self, "outbox"), passthrough=2)
        subscriber.activate()
        yield 1

        while 1:
            yield 1
Exemplo n.º 6
0
 def clientconnector():
     return Pipeline(
         chunks_to_lines(),
         lines_to_tokenlists(),
         FilterAndTagWrapper(
             Pipeline(
                 publishTo(backplane),
                 # well, should be to separate pipelines, this is lazier!
                 subscribeTo(backplane),
             )),
         tokenlists_to_lines(),
     )
Exemplo n.º 7
0
 def clientconnector():
     return pipeline(
         chunks_to_lines(),
         lines_to_tokenlists(),
         FilterAndTagWrapper(
             pipeline( publishTo(backplane),
                         # well, should be to separate pipelines, this is lazier!
                       subscribeTo(backplane),
                     )
             ),
         tokenlists_to_lines(),
         )
Exemplo n.º 8
0
    def main(self):
        kpidb = self.kpidb
        while not self.dataReady("inbox"):
            yield 1
        data = self.recv("inbox")
        padding,userid = struct.unpack('!2L',
                xtea.xtea_decrypt(kpidb.getRootKey(),data))
        print "Authenticator received userid:", userid
        if kpidb.isValidUser(userid) == False:
            print "Invalid UserID" # todo shutdown
            return

        challenge = random.getrandbits(32)
        temp = struct.pack('!2L',0, challenge)
        userkey = kpidb.getKPIKeys().getKey(userid)
        data = xtea.xtea_encrypt(userkey, temp)
        print data, challenge, userkey
        self.send(data, "outbox")
        yield 1
        while not self.dataReady("inbox"):
            yield 1
        data = self.recv("inbox")
        temp = xtea.xtea_decrypt(userkey,data)
        padding, response = struct.unpack('!2L', temp)
	print data, response
	if response == challenge + 1:
            self.send("SUCCESS", "outbox")
            yield 1
        else:
            print "authenication failure"
            return # shutdown

        #new user added 
        self.send(userid, "notifyuser")

        #subscribe to data Management back plane
        subscriber = subscribeTo("DataManagement")
        self.link( (subscriber, "outbox"), (self, "outbox"), passthrough=2)
        subscriber.activate()
        yield 1

        while 1:
            yield 1
Exemplo n.º 9
0
def RelayMulticastData():  # Protocol handler for each connected client
    return subscribeTo("MulticastProxy")
Exemplo n.º 10
0
            ("CANVAS", "outbox"): ("self", "outbox"),
        },
    )

mainsketcher = \
    Graphline( SKETCHER = makeBasicSketcher(width=1024,height=768),
               CONSOLE = Pipeline(ConsoleReader(),text_to_tokenlists(),parseCommands()),

               linkages = { ('self','inbox'):('SKETCHER','inbox'),
                            ('SKETCHER','outbox'):('self','outbox'),
                            ('CONSOLE','outbox'):('SKETCHER','inbox'),
                          }
                 )

# primary whiteboard
Pipeline(subscribeTo("WHITEBOARD"), TagAndFilterWrapper(mainsketcher),
         publishTo("WHITEBOARD")).activate()

if __name__ == "__main__":
    import sys, getopt, re

    rhost, rport, serveport = parseOptions()

    # setup a server, if requested
    if serveport:
        LocalEventServer("WHITEBOARD", port=serveport).activate()

    # connect to remote host & port, if requested
    if rhost and rport:
        EventServerClients(rhost, rport, "WHITEBOARD").activate()
Exemplo n.º 11
0
def SubscribeToSplitData():  # Protocol handler for each connected client
    return subscribeTo("Splitting")
Exemplo n.º 12
0
                          ("CANVAS","surfacechanged") : ("HISTORY", "inbox"),
                          },
                    )

mainsketcher = \
    Graphline( SKETCHER = makeBasicSketcher(width=1024,height=768),
               CONSOLE = pipeline(ConsoleReader(),text_to_tokenlists(),parseCommands()),

               linkages = { ('self','inbox'):('SKETCHER','inbox'),
                            ('SKETCHER','outbox'):('self','outbox'),
                            ('CONSOLE','outbox'):('SKETCHER','inbox'),
                          }
                 )

# primary whiteboard
pipeline( subscribeTo("WHITEBOARD"),
          TagAndFilterWrapper(mainsketcher),
          publishTo("WHITEBOARD")
        ).activate()

if __name__=="__main__":
    import sys, getopt, re

    rhost, rport, serveport = parseOptions()

    # setup a server, if requested
    if serveport:
        LocalEventServer("WHITEBOARD", port=serveport).activate()

    # connect to remote host & port, if requested
    if rhost and rport:
Exemplo n.º 13
0
def EventServerClients(rhost,
                       rport,
                       whiteboardBackplane="WHITEBOARD",
                       audioBackplane="AUDIO"):
    # plug a TCPClient into the backplae
    from Kamaelia.Internet.TCPClient import TCPClient
    from Kamaelia.Chassis.Carousel import Carousel

    loadingmsg = "Fetching sketch from server..."

    failuremsg = "FAILED: Couldn't connect to server:"
    failuremsg2 = str(rhost) + " on port " + str(rport)

    return Graphline(
        NETWORK=Graphline(
            PIPE=Pipeline(
                tokenlists_to_lines(),
                TCPClient(host=rhost, port=rport),
                chunks_to_lines(),
                lines_to_tokenlists(),
            ),
            SHUTDOWN=TriggeredOneShot(msg=shutdownMicroprocess()),
            linkages={
                ("", "inbox"): ("PIPE", "inbox"),
                ("PIPE", "outbox"): ("", "outbox"),

                # shutdown stuff - TCPClient may have caused it, so need to
                # loop the shutdown message back round to the front of the pipe
                # as well as propagating it onwards
                ("", "control"): ("PIPE", "control"),
                ("PIPE", "signal"): ("SHUTDOWN", "inbox"),
                ("SHUTDOWN", "outbox"): ("PIPE", "control"),
                ("SHUTDOWN", "signal"): ("", "signal"),
            }),
        ROUTER=Router(
            ((lambda tuple: tuple[0] == "SOUND"), "audio"),
            ((lambda tuple: tuple[0] != "SOUND"), "whiteboard"),
        ),
        WHITEBOARD=FilterAndTagWrapper(
            Pipeline(
                publishTo(whiteboardBackplane),
                #
                subscribeTo(whiteboardBackplane),
            )),
        AUDIO=Pipeline(
            SimpleDetupler(1),  # remove 'SOUND' tag
            SpeexDecode(3),
            FilterAndTagWrapperKeepingTag(
                Pipeline(
                    publishTo(audioBackplane),
                    #
                    subscribeTo(audioBackplane),
                ), ),
            RawAudioMixer(),
            SpeexEncode(3),
            Entuple(prefix=["SOUND"], postfix=[]),
        ),
        GETIMG=OneShot(msg=[["GETIMG"]]),
        BLACKOUT=OneShot(
            msg=[["CLEAR", 0, 0, 0],
                 ["WRITE", 100, 100, 24, 255, 255, 255, loadingmsg]]),
        FAILURE=TriggeredOneShot(
            msg=[["WRITE", 100, 200, 32, 255, 96, 96, failuremsg],
                 ["WRITE", 100, 232, 24, 255, 160, 160, failuremsg2]]),
        linkages={
            # incoming messages from network connection go to a router
            ("NETWORK", "outbox"): ("ROUTER", "inbox"),

            # distribute messages to appropriate destinations
            ("ROUTER", "audio"): ("AUDIO", "inbox"),
            ("ROUTER", "whiteboard"): ("WHITEBOARD", "inbox"),

            # aggregate all output, and send across the network connection
            ("AUDIO", "outbox"): ("NETWORK", "inbox"),
            ("WHITEBOARD", "outbox"): ("NETWORK", "inbox"),

            # initial messages sent to the server, and the local whiteboard
            ("GETIMG", "outbox"): ("NETWORK", "inbox"),
            ("BLACKOUT", "outbox"): ("WHITEBOARD", "inbox"),

            # shutdown routing, not sure if this will actually work, but hey!
            ("NETWORK", "signal"): ("FAILURE", "inbox"),
            ("FAILURE", "outbox"): ("WHITEBOARD", "inbox"),
            ("FAILURE", "signal"): ("ROUTER", "control"),
            ("ROUTER", "signal"): ("AUDIO", "control"),
            ("AUDIO", "signal"): ("WHITEBOARD", "control"),
            ("WHITEBOARD", "signal"): ("", "signal"),
        })
Exemplo n.º 14
0
def RelayMulticastData(): # Protocol handler for each connected client
     return subscribeTo("MulticastProxy")
Exemplo n.º 15
0
def EventServerClients(rhost, rport, whiteboardBackplane="WHITEBOARD", audioBackplane="AUDIO"):
        # plug a TCPClient into the backplae
        from Kamaelia.Internet.TCPClient import TCPClient
        from Kamaelia.Chassis.Carousel import Carousel

        loadingmsg = "Fetching sketch from server..."
        
        failuremsg  = "FAILED: Couldn't connect to server:"
        failuremsg2 = str(rhost)+" on port "+str(rport)

        return Graphline(
                NETWORK = Graphline(
                    PIPE = Pipeline(
                        tokenlists_to_lines(),
                        TCPClient(host=rhost,port=rport),
                        chunks_to_lines(),
                        lines_to_tokenlists(),
                        ),
                    SHUTDOWN = TriggeredOneShot(msg=shutdownMicroprocess()),
                    linkages = {
                        ("",     "inbox")  : ("PIPE", "inbox"),
                        ("PIPE", "outbox") : ("", "outbox"),
                        
                        # shutdown stuff - TCPClient may have caused it, so need to
                        # loop the shutdown message back round to the front of the pipe
                        # as well as propagating it onwards
                        ("",         "control") : ("PIPE",     "control"),
                        ("PIPE",     "signal")  : ("SHUTDOWN", "inbox"),
                        ("SHUTDOWN", "outbox")  : ("PIPE",     "control"),
                        ("SHUTDOWN", "signal")  : ("",         "signal"),
                    }
                ),
                ROUTER = Router( ((lambda tuple : tuple[0]=="SOUND"), "audio"),
                                 ((lambda tuple : tuple[0]!="SOUND"), "whiteboard"),
                               ),
                WHITEBOARD = FilterAndTagWrapper(
                    Pipeline(
                        publishTo(whiteboardBackplane),
                        #
                        subscribeTo(whiteboardBackplane),
                    )
                ),
                AUDIO = Pipeline(
                    SimpleDetupler(1),     # remove 'SOUND' tag
                    SpeexDecode(3),
                    FilterAndTagWrapperKeepingTag(
                        Pipeline(
                            publishTo(audioBackplane),
                            #
                            subscribeTo(audioBackplane),
                        ),
                    ),
                    RawAudioMixer(),
                    SpeexEncode(3),
                    Entuple(prefix=["SOUND"],postfix=[]),
                ),
                GETIMG = OneShot(msg=[["GETIMG"]]),
                BLACKOUT = OneShot(msg=[["CLEAR",0,0,0],["WRITE",100,100,24,255,255,255,loadingmsg]]),
                FAILURE = TriggeredOneShot(msg=[["WRITE", 100,200, 32, 255, 96, 96, failuremsg],
                                                ["WRITE", 100,232, 24, 255,160,160, failuremsg2]]), 
                
                linkages = {
                    # incoming messages from network connection go to a router
                    ("NETWORK", "outbox") : ("ROUTER", "inbox"),
                    
                    # distribute messages to appropriate destinations
                    ("ROUTER", "audio")      : ("AUDIO",      "inbox"),
                    ("ROUTER", "whiteboard") : ("WHITEBOARD", "inbox"),
                    
                    # aggregate all output, and send across the network connection
                    ("AUDIO",      "outbox") : ("NETWORK", "inbox"),
                    ("WHITEBOARD", "outbox") : ("NETWORK", "inbox"),
                    
                    # initial messages sent to the server, and the local whiteboard
                    ("GETIMG",   "outbox") : ("NETWORK",    "inbox"),
                    ("BLACKOUT", "outbox") : ("WHITEBOARD", "inbox"),
                    
                    # shutdown routing, not sure if this will actually work, but hey!
                    ("NETWORK", "signal") : ("FAILURE", "inbox"),
                    ("FAILURE", "outbox") : ("WHITEBOARD", "inbox"),
                    ("FAILURE",    "signal") : ("ROUTER",     "control"),
                    ("ROUTER",     "signal") : ("AUDIO",      "control"),
                    ("AUDIO",      "signal") : ("WHITEBOARD", "control"),
                    ("WHITEBOARD", "signal") : ("",           "signal"),
                }
            )
Exemplo n.º 16
0
    def main(self):
        kpidb = self.kpidb
        while not self.dataReady("inbox"):
            yield 1
        data = self.recv("inbox")
        #got userid
        padding,userid = struct.unpack('!2L',
                    xtea.xtea_decrypt(kpidb.getRootKey(),data))

        #check if the user is valid
        if kpidb.isValidUser(userid) == False:
            #print "Invalid UserID" # todo shutdown
            return

        #generate a random number and encrypt it with user's key
        challenge = random.getrandbits(32)
        temp = struct.pack('!2L',0, challenge)
        #look up user key from key database
        userkey = kpidb.getKPIKeys().getKey(userid)
        data = xtea.xtea_encrypt(userkey, temp)
        #print data, challenge, userkey
        self.send(data, "outbox")
        yield 1
        while not self.dataReady("inbox"):
            yield 1
        #got response to challenge
        data = self.recv("inbox")
        temp = xtea.xtea_decrypt(userkey,data)
        padding, response = struct.unpack('!2L', temp)
        #validate response
        if response == challenge + 1:
            self.send("SUCCESS", "outbox")
            yield 1
        else:
            #print "authenication failure"
            return # shutdown

        #got OK ack
        while not self.dataReady("inbox"):
            yield 1
        data = self.recv("inbox")
        if data == "OK":
            #print "received ack from client"
            pass
        else:
            return #shutdown
            


        #notify new user
        self.send(userid, "notifyuser")

        #subscribe to DataManagement backplane
        subscriber = subscribeTo("DataManagement")
        #make authenticator passthrough the data from DataManagement backplane
        self.link( (subscriber, "outbox"), (self, "outbox"), passthrough=2)
        subscriber.activate()
        yield 1

        while 1:
            yield 1
Exemplo n.º 17
0
def SubscribeToSplitData():  # Protocol handler for each connected client
    return subscribeTo("Splitting")
Exemplo n.º 18
0
mainsketcher = \
    Graphline( SKETCHER = makeBasicSketcher(width=1024,height=768),
               CONSOLE = Pipeline(ConsoleReader(),text_to_tokenlists(),parseCommands()),

               linkages = { ('self','inbox'):('SKETCHER','inbox'),
                            ('SKETCHER','outbox'):('self','outbox'),
                            ('CONSOLE','outbox'):('SKETCHER','inbox'),
                          }
                 )



if __name__=="__main__":
    
    # primary whiteboard
    Pipeline( subscribeTo("WHITEBOARD"),
            TagAndFilterWrapper(mainsketcher),
            publishTo("WHITEBOARD")
            ).activate()
            
    # primary sound IO - tagged and filtered, so can't hear self
    Pipeline( subscribeTo("AUDIO"),
              TagAndFilterWrapperKeepingTag(
                  Pipeline(
                      RawAudioMixer(),
#                      PackageData(channels=1,sample_rate=8000,format="S16_LE"),
                      SoundOutput(),
                      ######
                      SoundInput(),
#                      ExtractData(),
                  ),