def initComponents(self):
sub = SubscribeTo("DISCO_FEAT")
self.link((sub, 'outbox'), (self, 'inbox'))
self.addChildren(sub)
sub.activate()
return 1
def initComponents(self):
sub = SubscribeTo("JID.%s" % self.session_id)
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
return 1
def initComponents(self):
sub = SubscribeTo("DISCO_FEAT")
self.link((sub, 'outbox'), (self, 'inbox'))
self.addChildren(sub)
sub.activate()
return 1
def initComponents(self):
# We subscribe to the JID backplane component
# that will inform us when the server has
# returned the per-session jid
sub = SubscribeTo("JID")
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
return 1
def initComponents(self):
# We subscribe to the JID backplane component
# that will inform us when the server has
# returned the per-session jid
sub = SubscribeTo("JID")
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
return 1
def initComponents(self):
sub = SubscribeTo("JID.%s" % self.session_id)
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
client = SimpleHTTPClient()
self.addChildren(client)
self.link((self, '_request'), (client, 'inbox'))
self.link((client, 'outbox'), (self, '_response'))
client.activate()
return 1
def EchoEveryone(**kwargs):
peer = str(kwargs.get("peer", "<>"))
peerport = str(kwargs.get("peerport", "<>"))
return Pipeline(
PureTransformer(lambda x: "%s:%s says %s" % (peer, peerport, x)),
PublishTo("CHAT_ONE"),
# ------------
SubscribeTo("CHAT_ONE"),
)
def FilteringPubsubBackplane(backplaneID, **FilterTagWrapperOptions):
"""Sends tagged events to a backplane. Emits events not tagged by this pubsub."""
return FilterAndTagWrapper(
Pipeline(
PublishTo(backplaneID),
# well, should be to separate pipelines, this is lazier!
SubscribeTo(backplaneID),
),
**FilterTagWrapperOptions)
def __init__(self, logname, wrapper = wrapMessage):
"""
Initializes a new Logger.
-logname - the name of the log to write to
-wrapper - a method that takes a message as an argument and returns a
formatted string to put in the log.
"""
super(Logger, self).__init__()
self.logname = logname
self.bplane = Backplane('LOG_' + logname)
self.subscriber = SubscribeTo('LOG_' + logname)
self.wrapper = wrapper
#add the components as children
self.addChildren(self.subscriber, self.bplane)
self.link((self.subscriber, 'outbox'), (self, 'inbox'))
self.link((self, 'signal'), (self.bplane, 'control'))
def initComponents(self):
sub = SubscribeTo("JID")
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
sub = SubscribeTo("CONSOLE")
self.link((sub, 'outbox'), (self, 'inbox'))
self.addChildren(sub)
sub.activate()
return 1
def recordForMe(channel, programme, filename):
return \
Pipeline( SubscribeTo("nowEvents"),
ProgrammeDetector( channel_name=channel, programme_name=programme,
fromChannelLookup="LookupChannelName"),
ControllableRecorder( channel_name=channel,
fromDemuxer="DEMUXER",
fromPSI="PSI_Tables",
fromChannelLookup="LookupChannelName"),
SimpleFileWriter(filename),
)
def ChatClient(*argc, **argd):
peer = argd["peer"]
peerport = argd["peerport"]
return Pipeline(
PureTransformer(lambda x: " %s:%s says %s" %
(str(peer), str(peerport), str(x))),
PublishTo("CHAT"), # Take data from client and publish to all clients
# ----------------------
SubscribeTo("CHAT"
), # Take data from other clients and send to our client
PureTransformer(lambda x: "Chat:" + str(x).strip() + "\n"),
)
def initComponents(self):
sub = SubscribeTo("JID")
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
pub = PublishTo("DISCO_FEAT")
self.link((self, 'features-announce'), (pub, 'inbox'))
self.addChildren(pub)
pub.activate()
sub = SubscribeTo("BOUND")
self.link((sub, 'outbox'), (self, 'initiate'))
self.addChildren(sub)
sub.activate()
return 1
def initComponents(self):
sub = SubscribeTo("JID.%s" % self.session_id)
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
feedreader = FeedReaderComponent(use_etags=False)
self.addChildren(feedreader)
feedreader.activate()
client = SimpleHTTPClient()
self.addChildren(client)
self.link((self, '_feedrequest'), (client, 'inbox'))
self.link((client, 'outbox'), (feedreader, 'inbox'))
self.link((feedreader, 'outbox'), (self, '_feedresponse'))
client.activate()
client = SimpleHTTPClient()
self.addChildren(client)
self.link((self, '_delrequest'), (client, 'inbox'))
self.link((client, 'outbox'), (self, '_delresponse'))
client.activate()
return 1
def PassThroughAudio(edlfile, tmpFilePath):
"""\
Prefab.
Goes through the specified edit decision list file and reads in the audio
frames corresponding to the video frames referred to in the reframing
instructions in sequence. Outputs the audio frames out of the "outbox"
outbox.
Arguments:
- edlfile -- full filepathname of the EDL xml file
- tmpFilePath -- temp directory into which video frames have been saved
Inboxes:
- "inbox" -- NOT USED
- "control" -- Shutdown signalling
Outboxes:
- "outbox" -- raw audio data, chunked by frames
- "signal" -- Shutdown signalling
"""
backplane_name = "AUDIO_FORMAT"
return Graphline( \
GET_EDL = EditDecisionSource(edlfile),
AUDIO = Carousel( lambda edit : PassThroughAudioSegment(tmpFilePath, edit, backplane_name),
make1stRequest=True),
BACKPLANE = Backplane(backplane_name),
AUDIOFORMAT = Pipeline( SubscribeTo(backplane_name), FirstOnly() ),
linkages = {
("AUDIO", "requestNext") : ("GET_EDL", "inbox"),
("GET_EDL", "outbox") : ("AUDIO", "next"),
("AUDIO", "outbox") : ("", "outbox"),
("AUDIOFORMAT", "outbox") : ("", "audioformat"),
("GET_EDL", "signal") : ("AUDIO", "control"),
("AUDIO", "signal") : ("AUDIOFORMAT", "control"),
("AUDIOFORMAT", "signal") : ("BACKPLANE", "control"),
("BACKPLANE", "signal") : ("", "signal"),
},
)
def initComponents(self):
sub = SubscribeTo("JID")
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
sub = SubscribeTo("CONSOLE")
self.link((sub, 'outbox'), (self, 'inbox'))
self.addChildren(sub)
sub.activate()
return 1
def initComponents(self):
sub = SubscribeTo("JID")
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
pub = PublishTo("DISCO_FEAT")
self.link((self, 'features-announce'), (pub, 'inbox'))
self.addChildren(pub)
pub.activate()
sub = SubscribeTo("BOUND")
self.link((sub, 'outbox'), (self, 'initiate'))
self.addChildren(sub)
sub.activate()
return 1
def setup(self):
self.running = True
# Backplanes are like a global entry points that
# can be accessible both for publishing and
# recieving data.
# In other words, a component interested
# in advertising to many other components that
# something happened may link one of its outbox
# to a PublishTo component's inbox.
# A component wishing to receive that piece of
# information will link one of its inbox
# to the SubscribeTo component's outbox.
# This helps greatly to make components more
# loosely connected but also allows for some data
# to be dispatched at once to many (such as when
# the server returns the per-session JID that
# is of interest for most other components).
self.backplanes.append(Backplane("JID.%s" % self.session_id).activate())
# Used to inform components that the session is now active
self.backplanes.append(Backplane("BOUND.%s" % self.session_id).activate())
# Used to inform components of the supported features
self.backplanes.append(Backplane("DISCO_FEAT.%s" % self.session_id).activate())
sub = SubscribeTo("JID.%s" % self.session_id)
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
sub = SubscribeTo("BOUND.%s" % self.session_id)
self.link((sub, 'outbox'), (self, 'connected'))
self.addChildren(sub)
sub.activate()
# Add two outboxes ro the ClientSteam to support specific extensions.
ClientStream.Outboxes["%s.query" % XMPP_IBR_NS] = "Registration"
ClientStream.Outboxes["%s.query" % XMPP_LAST_NS] = "Activity"
ClientStream.Outboxes["%s.query" % XMPP_DISCO_INFO_NS] = "Discovery"
ClientStream.Outboxes["%s.query" % XMPP_DISCO_ITEMS_NS] = "PubSub Discovery of Nodes"
ClientStream.Outboxes["%s.subscribe" % XMPP_PUBSUB_NS] = "Pubsub subscription handler"
ClientStream.Outboxes["%s.unsubscribe" % XMPP_PUBSUB_NS] = "Pubsub unsubscription handler"
ClientStream.Outboxes["%s.subscriptions" % XMPP_PUBSUB_NS] = "Pubsub subscriptions handler"
ClientStream.Outboxes["%s.affiliations" % XMPP_PUBSUB_NS] = "Pubsub affiliations handler"
ClientStream.Outboxes["%s.create" % XMPP_PUBSUB_NS] = "Pubsub node creation handler"
ClientStream.Outboxes["%s.purge" % XMPP_PUBSUB_OWNER_NS] = "Pubsub node purge handler"
ClientStream.Outboxes["%s.delete" % XMPP_PUBSUB_OWNER_NS] = "Pubsub node delete handler"
ClientStream.Outboxes["%s.publish" % XMPP_PUBSUB_NS] = "Pubsub item publication handler"
ClientStream.Outboxes["%s.retract" % XMPP_PUBSUB_NS] = "Pubsub item deletion handler"
ClientStream.Outboxes["%s.x" % XMPP_PUBSUB_EVENT_NS] = ""
ClientStream.Outboxes["%s.event" % XMPP_PUBSUB_EVENT_NS] = ""
self.client = ClientStream(self.jid, self.passwordLookup, use_tls=self.usetls)
self.addChildren(self.client)
self.client.activate()
self.graph = Graphline(client = self,
logger = Logger(path='./logs/%s.log' % self.username,
stdout=True, name=self.session_id),
tcp = TCPClient(self.server, self.port),
xmlparser = XMLIncrParser(),
xmpp = self.client,
streamerr = StreamError(),
saslerr = SaslError(),
discohandler = DiscoHandler(self.jid, self.atompub, self.domain,
session_id=self.session_id,
profile=self.profile),
activityhandler = ActivityHandler(session_id=self.session_id),
rosterhandler = RosterHandler(self.jid, session_id=self.session_id),
registerhandler = RegistrationHandler(self.username, self.password,
self.session_id, profile=self.profile),
msgdummyhandler = DummyMessageHandler(session_id=self.session_id,
profile=self.profile),
presencehandler = PresenceHandler(session_id=self.session_id),
itemshandler = ItemsHandler(self.jid, self.atompub, self.domain,
session_id=self.session_id,
profile=self.profile),
pubsubmsgeventhandler = MessageHandler(self.jid, self.atompub, self.domain,
session_id=self.session_id,
profile=self.profile),
presencedisp = PresenceDispatcher(),
rosterdisp = RosterDispatcher(),
msgdisp = MessageDispatcher(),
discodisp = DiscoveryDispatcher(),
activitydisp = ActivityDispatcher(),
registerdisp = RegisterDispatcher(),
pubsubdisp = PubSubDispatcher(),
pjid = PublishTo("JID.%s" % self.session_id),
pbound = PublishTo("BOUND.%s" % self.session_id),
linkages = {('xmpp', 'terminated'): ('client', 'inbox'),
('client', 'forward'): ('xmpp', 'forward'),
('client', 'outbox'): ('tcp', 'inbox'),
('client', 'signal'): ('tcp', 'control'),
("tcp", "outbox") : ("xmlparser", "inbox"),
("xmpp", "starttls") : ("tcp", "makessl"),
("tcp", "sslready") : ("xmpp", "tlssuccess"),
("xmlparser", "outbox") : ("xmpp" , "inbox"),
("xmpp", "outbox") : ("tcp" , "inbox"),
("xmpp", "reset"): ("xmlparser", "reset"),
("client", "log"): ("logger", "inbox"),
("xmpp", "log"): ("logger", "inbox"),
("xmpp", "jid"): ("pjid", "inbox"),
("xmpp", "bound"): ("pbound", "inbox"),
("xmpp", "features"): ("client", "streamfeat"),
("xmpp", "unhandled"): ("client", "unhandled"),
("client", "doauth"): ("xmpp", "auth"),
# Registration
("xmpp", "%s.query" % XMPP_IBR_NS): ("registerdisp", "inbox"),
("registerdisp", "log"): ('logger', "inbox"),
("registerdisp", "xmpp.error"): ("registerhandler", "error"),
("registerdisp", "xmpp.result"): ("registerhandler", "inbox"),
("registerhandler", "outbox"): ("registerdisp", "forward"),
("client", "doregistration"): ("registerdisp", "forward"),
("registerdisp", "outbox"): ("xmpp", "forward"),
# Presence
("xmpp", "%s.presence" % XMPP_CLIENT_NS): ("presencedisp", "inbox"),
("presencedisp", "log"): ('logger', "inbox"),
("presencedisp", "xmpp.subscribe"): ("presencehandler", "subscribe"),
("presencedisp", "xmpp.unsubscribe"): ("presencehandler", "unsubscribe"),
("presencehandler", "outbox"): ("presencedisp", "forward"),
("presencehandler", "roster"): ("rosterdisp", "forward"),
("presencedisp", "outbox"): ("xmpp", "forward"),
# Roster
("xmpp", "%s.query" % XMPP_ROSTER_NS): ("rosterdisp", "inbox"),
("rosterdisp", "log"): ('logger', "inbox"),
('rosterdisp', 'xmpp.set'): ('rosterhandler', 'pushed'),
('rosterdisp', 'xmpp.result'): ('rosterhandler', 'inbox'),
('rosterhandler', 'result'): ('rosterdisp', 'forward'),
('rosterhandler', 'roster-updated'): ('msgdummyhandler', 'roster-received'),
("rosterdisp", "outbox"): ("xmpp", "forward"),
# Discovery
("xmpp", "%s.query" % XMPP_DISCO_INFO_NS): ("discodisp", "features.inbox"),
("xmpp", "%s.query" % XMPP_DISCO_ITEMS_NS): ("discodisp", "items.inbox"),
("xmpp", "%s.affiliations" % XMPP_PUBSUB_NS): ("discodisp", "affiliation.inbox"),
("xmpp", "%s.subscriptions" % XMPP_PUBSUB_NS): ("discodisp", "subscription.inbox"),
("discodisp", "log"): ('logger', "inbox"),
("discohandler", "features-disco"): ('discodisp', "features.forward"),
('discohandler', 'items-disco'): ('discodisp', 'items.forward'),
('discohandler', 'subscriptions-disco'): ('discodisp', 'subscription.forward'),
('discohandler', 'affiliations-disco'): ('discodisp', 'affiliation.forward'),
("discodisp", "out.features.result"): ('discohandler', "features.result"),
("discodisp",'subscription.outbox'):('xmpp','forward'),
("discodisp",'affiliation.outbox'):('xmpp','forward'),
("discodisp",'out.subscription.result'): ('discohandler','subscriptions.result'),
("discodisp",'out.affiliation.result'): ('discohandler','affiliations.result'),
("discodisp", 'out.items.result'): ('discohandler', 'items.result'),
("discodisp", 'out.items.error'): ('discohandler', 'items.error'),
("discodisp", "outbox"): ("xmpp", "forward"),
# Message
("xmpp", "%s.message" % XMPP_CLIENT_NS): ("msgdisp", "inbox"),
("msgdisp", "log"): ('logger', "inbox"),
("msgdisp", "xmpp.chat"): ('msgdummyhandler', 'inbox'),
("msgdummyhandler", "outbox"): ('msgdisp', 'forward'),
("msgdisp", "outbox"): ("xmpp", "forward"),
# Activity
("xmpp", "%s.query" % XMPP_LAST_NS): ("activitydisp", "inbox"),
("activitydisp", "log"): ('logger', "inbox"),
("activitydisp", "outbox"): ("xmpp", "forward"),
("activityhandler", 'activity-supported'): ('rosterhandler', 'ask-activity'),
("rosterhandler", 'activity'): ('activitydisp', 'forward'),
# Pubsub
("xmpp", "%s.create" % XMPP_PUBSUB_NS): ("pubsubdisp", "create.inbox"),
("xmpp", "%s.delete" % XMPP_PUBSUB_OWNER_NS): ("pubsubdisp", "delete.inbox"),
("xmpp", "%s.purge" % XMPP_PUBSUB_OWNER_NS): ("pubsubdisp", "purge.inbox"),
("xmpp", "%s.subscribe" % XMPP_PUBSUB_NS): ("pubsubdisp", "subscribe.inbox"),
("xmpp", "%s.unsubscribe" % XMPP_PUBSUB_NS):("pubsubdisp", "unsubscribe.inbox"),
("xmpp", "%s.publish" % XMPP_PUBSUB_NS): ("pubsubdisp", "publish.inbox"),
("xmpp", "%s.retract" % XMPP_PUBSUB_NS): ("pubsubdisp", "retract.inbox"),
("xmpp", "%s.x" % XMPP_PUBSUB_EVENT_NS): ("pubsubdisp", "message.inbox"),
("xmpp", "%s.event" % XMPP_PUBSUB_EVENT_NS): ("pubsubdisp", "message.inbox"),
("pubsubdisp", "log"): ('logger', "inbox"),
("discohandler", "create-node"): ("pubsubdisp", "create.forward"),
("discohandler", "delete-node"): ("pubsubdisp", "delete.forward"),
("discohandler", "subscribe-node"): ("pubsubdisp", "subscribe.forward"),
("discohandler", "unsubscribe-node"): ("pubsubdisp", "unsubscribe.forward"),
("pubsubdisp", "create.outbox"): ("xmpp", "forward"),
("pubsubdisp", "delete.outbox"): ("xmpp", "forward"),
("pubsubdisp", "purge.outbox"): ("xmpp", "forward"),
("pubsubdisp", "subscribe.outbox"): ("xmpp", "forward"),
("pubsubdisp", "unsubscribe.outbox"): ("xmpp", "forward"),
("pubsubdisp", "publish.outbox"): ("xmpp", "forward"),
("pubsubdisp", "retract.outbox"): ("xmpp", "forward"),
("pubsubdisp", "out.create.result"): ("discohandler", "created"),
("pubsubdisp", "out.subscribe.result"): ("discohandler", "subscribed"),
("pubsubdisp", "out.delete.result"): ("discohandler", "deleted"),
("pubsubdisp", "out.create.error"): ("discohandler", "error"),
("pubsubdisp", "out.delete.error"): ("discohandler", "error"),
("pubsubdisp", "out.publish.error"): ("itemshandler", "publish.error"),
("pubsubdisp", "out.retract.error"): ("itemshandler", "retract.error"),
("pubsubdisp", "out.publish.result"): ("itemshandler", "published"),
("pubsubdisp", "out.message"): ('pubsubmsgeventhandler', 'inbox'),
('itemshandler', 'publish'): ('pubsubdisp', 'publish.forward'),
('itemshandler', 'delete'): ('pubsubdisp', 'retract.forward'),
('itemshandler', 'purge'): ('pubsubdisp', 'purge.forward'),
("msgdummyhandler", "PI"): ('itemshandler', 'topublish'),
("msgdummyhandler", "GEO"): ('itemshandler', 'topublish'),
("msgdummyhandler", "DI"): ('itemshandler', 'todelete'),
("msgdummyhandler", "PN"): ('itemshandler', 'topurge'),
("msgdummyhandler", "CN"): ('discohandler', 'docreate'),
("msgdummyhandler", "DN"): ('discohandler', 'dodelete'),
("msgdummyhandler", "SN"): ('discohandler', 'dosubscribe'),
("msgdummyhandler", "UN"): ('discohandler', 'dounsubscribe'),
('pubsubmsgeventhandler', 'items-disco'): ('discodisp', 'items.forward'),
}
)
self.addChildren(self.graph)
self.graph.activate()
return 1
def setup(self):
# Backplanes are like a global entry points that
# can be accessible both for publishing and
# recieving data.
# In other words, a component interested
# in advertising to many other components that
# something happened may link one of its outbox
# to a PublishTo component's inbox.
# A component wishing to receive that piece of
# information will link one of its inbox
# to the SubscribeTo component's outbox.
# This helps greatly to make components more
# loosely connected but also allows for some data
# to be dispatched at once to many (such as when
# the server returns the per-session JID that
# is of interest for most other components).
Backplane("CONSOLE").activate()
Backplane("JID").activate()
# Used to inform components that the session is now active
Backplane("BOUND").activate()
# Used to inform components of the supported features
Backplane("DISCO_FEAT").activate()
sub = SubscribeTo("JID")
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
# We pipe everything typed into the console
# directly to the console backplane so that
# every components subscribed to the console
# backplane inbox will get the typed data and
# will decide it it's of concern or not.
Pipeline(ConsoleReader(), PublishTo('CONSOLE')).activate()
# Add two outboxes ro the ClientSteam to support specific extensions.
ClientStream.Outboxes["%s.query" % XMPP_IBR_NS] = "Registration"
ClientStream.Outboxes["%s.query" % XMPP_LAST_NS] = "Activity"
ClientStream.Outboxes["%s.query" % XMPP_DISCO_INFO_NS] = "Discovery"
self.client = ClientStream(self.jid, self.passwordLookup, use_tls=self.usetls)
self.graph = Graphline(client = self,
console = SubscribeTo('CONSOLE'),
logger = Logger(path=None, stdout=True),
tcp = TCPClient(self.server, self.port),
xmlparser = XMLIncrParser(),
xmpp = self.client,
streamerr = StreamError(),
saslerr = SaslError(),
discohandler = DiscoHandler(self.jid, self.domain),
activityhandler = ActivityHandler(),
rosterhandler = RosterHandler(self.jid),
registerhandler = RegistrationHandler(self.username, self.password),
msgdummyhandler = DummyMessageHandler(),
presencehandler = PresenceHandler(),
presencedisp = PresenceDispatcher(),
rosterdisp = RosterDispatcher(),
msgdisp = MessageDispatcher(),
discodisp = DiscoveryDispatcher(),
activitydisp = ActivityDispatcher(),
registerdisp = RegisterDispatcher(),
pjid = PublishTo("JID"),
pbound = PublishTo("BOUND"),
linkages = {('xmpp', 'terminated'): ('client', 'inbox'),
('console', 'outbox'): ('client', 'control'),
('client', 'forward'): ('xmpp', 'forward'),
('client', 'outbox'): ('tcp', 'inbox'),
('client', 'signal'): ('tcp', 'control'),
("tcp", "outbox") : ("xmlparser", "inbox"),
("xmpp", "starttls") : ("tcp", "makessl"),
("tcp", "sslready") : ("xmpp", "tlssuccess"),
("xmlparser", "outbox") : ("xmpp" , "inbox"),
("xmpp", "outbox") : ("tcp" , "inbox"),
("xmpp", "reset"): ("xmlparser", "reset"),
("client", "log"): ("logger", "inbox"),
("xmpp", "log"): ("logger", "inbox"),
("xmpp", "jid"): ("pjid", "inbox"),
("xmpp", "bound"): ("pbound", "inbox"),
("xmpp", "features"): ("client", "streamfeat"),
("client", "doauth"): ("xmpp", "auth"),
# Registration
("xmpp", "%s.query" % XMPP_IBR_NS): ("registerdisp", "inbox"),
("registerdisp", "log"): ('logger', "inbox"),
("registerdisp", "xmpp.error"): ("registerhandler", "error"),
("registerdisp", "xmpp.result"): ("registerhandler", "inbox"),
("registerhandler", "outbox"): ("registerdisp", "forward"),
("client", "doregistration"): ("registerdisp", "forward"),
("registerdisp", "outbox"): ("xmpp", "forward"),
# Presence
("xmpp", "%s.presence" % XMPP_CLIENT_NS): ("presencedisp", "inbox"),
("presencedisp", "log"): ('logger', "inbox"),
("presencedisp", "xmpp.subscribe"): ("presencehandler", "subscribe"),
("presencedisp", "xmpp.unsubscribe"): ("presencehandler", "unsubscribe"),
("presencehandler", "outbox"): ("presencedisp", "forward"),
("presencehandler", "roster"): ("rosterdisp", "forward"),
("presencedisp", "outbox"): ("xmpp", "forward"),
# Roster
("xmpp", "%s.query" % XMPP_ROSTER_NS): ("rosterdisp", "inbox"),
("rosterdisp", "log"): ('logger', "inbox"),
('rosterdisp', 'xmpp.set'): ('rosterhandler', 'pushed'),
('rosterdisp', 'xmpp.result'): ('rosterhandler', 'inbox'),
('rosterhandler', 'result'): ('rosterdisp', 'forward'),
("rosterdisp", "outbox"): ("xmpp", "forward"),
# Discovery
("xmpp", "%s.query" % XMPP_DISCO_INFO_NS): ("discodisp", "features.inbox"),
("discodisp", "log"): ('logger', "inbox"),
("discohandler", "features-disco"): ('discodisp', "features.forward"),
("discodisp", "out.features.result"): ('discohandler', "features.result"),
("discodisp", "outbox"): ("xmpp", "forward"),
# Message
("xmpp", "%s.message" % XMPP_CLIENT_NS): ("msgdisp", "inbox"),
("msgdisp", "log"): ('logger', "inbox"),
("msgdisp", "xmpp.chat"): ('msgdummyhandler', 'inbox'),
("msgdummyhandler", "outbox"): ('msgdisp', 'forward'),
("msgdisp", "outbox"): ("xmpp", "forward"),
# Activity
("xmpp", "%s.query" % XMPP_LAST_NS): ("activitydisp", "inbox"),
("activitydisp", "log"): ('logger', "inbox"),
("activitydisp", "outbox"): ("xmpp", "forward"),
("activityhandler", 'activity-supported'): ('rosterhandler', 'ask-activity'),
("rosterhandler", 'activity'): ('activitydisp', 'forward'),
}
)
self.addChildren(self.graph)
self.graph.activate()
return 1
data = self.recv("control")
print "Control: %s" % data
self.send(producerFinished(self), "signal")
return
#if not self.anyReady():
# self.pause()
yield 1
backplane = Backplane("SAMPLE")
backplane.activate()
producer = Producer()
consumer = Consumer()
published = PublishTo("SAMPLE")
subscribe = SubscribeTo("SAMPLE")
pipe1 = Pipeline(
producer,
published,
)
pipe1.activate()
pipe2 = Pipeline(
subscribe,
consumer
)
consumer2 = Consumer()
consumer2.activate()
source = selected
try:
if '#' not in source:
source = source+"#next"
except TypeError,e:
mode = None
source = None
sink = None
priorselected = None
selected = None
Backplane("VIS").activate()
Backplane("UI_Events").activate()
X = Pipeline(
SubscribeTo("VIS"),
chunks_to_lines(),
lines_to_tokenlists(),
AxonVisualiser(position=(0,0)),
ConsoleEchoer(forwarder=True),
PublishTo("UI_Events"),
).activate()
Graphline(
EXAMPLE = example,
ADDASSET = Button(caption="ADD ASSET", position=(800, 20), msg='add'),
LINKER = Button(caption="LINK", position=(800, 53), msg=("MAKELINKTO",) ),
EVENTS = SubscribeTo("UI_Events"),
MAGIC = Magic(),
class Logger(component):
"""
This component is used to write messages to file. Upon instantiation, the
a backplane is registered with the name LOG_ + logname, so that a log named
'foo.bar' would be registered under 'LOG_foo.bar'.
Please note that the Logger will not be shut down automatically. It must be
sent a shutdown message via its control box. Typically this component is to
be used by a Chassis or some other Parent component to provide a log for its
children.
"""
Inboxes = { 'inbox' : 'Receive a tuple containing the filename and message to log',
'control' : 'Receive shutdown messages',}
Outboxes = {'outbox' : 'NOT USED',
'signal' : 'Send shutdown messages',}
def __init__(self, logname, wrapper = wrapMessage):
"""
Initializes a new Logger.
-logname - the name of the log to write to
-wrapper - a method that takes a message as an argument and returns a
formatted string to put in the log.
"""
super(Logger, self).__init__()
self.logname = logname
self.bplane = Backplane('LOG_' + logname)
self.subscriber = SubscribeTo('LOG_' + logname)
self.wrapper = wrapper
#add the components as children
self.addChildren(self.subscriber, self.bplane)
self.link((self.subscriber, 'outbox'), (self, 'inbox'))
self.link((self, 'signal'), (self.bplane, 'control'))
def main(self):
self.bplane.activate()
self.subscriber.activate()
self.first_run = False
not_done = True
while not_done:
if self.dataReady('inbox'):
file = open(self.logname, 'a')
while self.dataReady('inbox'):
msg = self.recv('inbox')
file.write(self.wrapper(msg))
file.close()
while self.dataReady('control'):
msg = self.recv('control')
if isinstance(msg, (shutdownMicroprocess)):
not_done = False
self.shutdown(msg)
if not_done:
self.pause()
yield 1
def shutdown(self, msg):
"""
Sends shutdown message to signal box and removes children.
"""
self.send(msg, 'signal')
self.removeChild(self.bplane)
self.removeChild(self.subscriber)
def setup(self):
# Backplanes are like a global entry points that
# can be accessible both for publishing and
# recieving data.
# In other words, a component interested
# in advertising to many other components that
# something happened may link one of its outbox
# to a PublishTo component's inbox.
# A component wishing to receive that piece of
# information will link one of its inbox
# to the SubscribeTo component's outbox.
# This helps greatly to make components more
# loosely connected but also allows for some data
# to be dispatched at once to many (such as when
# the server returns the per-session JID that
# is of interest for most other components).
Backplane("CONSOLE").activate()
Backplane("JID").activate()
# Used to inform components that the session is now active
Backplane("BOUND").activate()
# Used to inform components of the supported features
Backplane("DISCO_FEAT").activate()
sub = SubscribeTo("JID")
self.link((sub, 'outbox'), (self, 'jid'))
self.addChildren(sub)
sub.activate()
log = Logger(path=None, stdout=True, name='XmppLogger')
Backplane('LOG_' + self.log_location).activate()
Pipeline(SubscribeTo('LOG_' + self.log_location), log).activate()
log_writable = WsgiLogWritable(self.log_location)
log.activate()
log_writable.activate()
# We pipe everything typed into the console
# directly to the console backplane so that
# every components subscribed to the console
# backplane inbox will get the typed data and
# will decide it it's of concern or not.
Pipeline(ConsoleReader(), PublishTo('CONSOLE')).activate()
# Add two outboxes ro the ClientSteam to support specific extensions.
ClientStream.Outboxes["%s.query" % XMPP_IBR_NS] = "Registration"
ClientStream.Outboxes["%s.query" % XMPP_LAST_NS] = "Activity"
ClientStream.Outboxes["%s.query" % XMPP_DISCO_INFO_NS] = "Discovery"
self.client = ClientStream(self.jid, self.passwordLookup, use_tls=self.usetls)
WsgiConfig ={
'server_software' : "Example WSGI Web Server",
'server_admin' : "Jason Baker",
'wsgi_ver' : (1,0),
}
routing = [ ["/", SimpleWsgiFactory(log_writable, WsgiConfig, simple_app, '/simple')], ]
#routing = [ ['/', Echoer]]
self.graph = Graphline(client = self,
console = SubscribeTo('CONSOLE'),
logger = PublishTo('LOG_' + self.log_location),
tcp = TCPClient(self.server, self.port),
xmlparser = XMLIncrParser(),
xmpp = self.client,
streamerr = StreamError(),
saslerr = SaslError(),
discohandler = DiscoHandler(self.jid, self.domain),
activityhandler = ActivityHandler(),
rosterhandler = RosterHandler(self.jid),
registerhandler = RegistrationHandler(self.username, self.password),
msgdummyhandler = WebMessageHandler(),
presencehandler = PresenceHandler(),
presencedisp = PresenceDispatcher(),
rosterdisp = RosterDispatcher(),
msgdisp = MessageDispatcher(),
discodisp = DiscoveryDispatcher(),
activitydisp = ActivityDispatcher(),
registerdisp = RegisterDispatcher(),
pjid = PublishTo("JID"),
pbound = PublishTo("BOUND"),
proto_man = ProtocolManager(Protocol=HTTPProtocol(routing)),
linkages = {('xmpp', 'terminated'): ('client', 'inbox'),
('console', 'outbox'): ('client', 'control'),
('client', 'forward'): ('xmpp', 'forward'),
('client', 'outbox'): ('tcp', 'inbox'),
('client', 'signal'): ('tcp', 'control'),
("tcp", "outbox") : ("xmlparser", "inbox"),
("xmpp", "starttls") : ("tcp", "makessl"),
("tcp", "sslready") : ("xmpp", "tlssuccess"),
("xmlparser", "outbox") : ("xmpp" , "inbox"),
("xmpp", "outbox") : ("tcp" , "inbox"),
("xmpp", "reset"): ("xmlparser", "reset"),
("client", "log"): ("logger", "inbox"),
("xmpp", "log"): ("logger", "inbox"),
("xmpp", "jid"): ("pjid", "inbox"),
("xmpp", "bound"): ("pbound", "inbox"),
("xmpp", "features"): ("client", "streamfeat"),
("client", "doauth"): ("xmpp", "auth"),
# Registration
("xmpp", "%s.query" % XMPP_IBR_NS): ("registerdisp", "inbox"),
("registerdisp", "log"): ('logger', "inbox"),
("registerdisp", "xmpp.error"): ("registerhandler", "error"),
("registerdisp", "xmpp.result"): ("registerhandler", "inbox"),
("registerhandler", "outbox"): ("registerdisp", "forward"),
("client", "doregistration"): ("registerdisp", "forward"),
("registerdisp", "outbox"): ("xmpp", "forward"),
# Presence
("xmpp", "%s.presence" % XMPP_CLIENT_NS): ("presencedisp", "inbox"),
("presencedisp", "log"): ('logger', "inbox"),
("presencedisp", "xmpp.subscribe"): ("presencehandler", "subscribe"),
("presencedisp", "xmpp.unsubscribe"): ("presencehandler", "unsubscribe"),
("presencehandler", "outbox"): ("presencedisp", "forward"),
("presencehandler", "roster"): ("rosterdisp", "forward"),
("presencedisp", "outbox"): ("xmpp", "forward"),
# Roster
("xmpp", "%s.query" % XMPP_ROSTER_NS): ("rosterdisp", "inbox"),
("rosterdisp", "log"): ('logger', "inbox"),
('rosterdisp', 'xmpp.set'): ('rosterhandler', 'pushed'),
('rosterdisp', 'xmpp.result'): ('rosterhandler', 'inbox'),
('rosterhandler', 'result'): ('rosterdisp', 'forward'),
("rosterdisp", "outbox"): ("xmpp", "forward"),
# Discovery
("xmpp", "%s.query" % XMPP_DISCO_INFO_NS): ("discodisp", "features.inbox"),
("discodisp", "log"): ('logger', "inbox"),
("discohandler", "features-disco"): ('discodisp', "features.forward"),
("discodisp", "out.features.result"): ('discohandler', "features.result"),
("discodisp", "outbox"): ("xmpp", "forward"),
# Message
("xmpp", "%s.message" % XMPP_CLIENT_NS): ("msgdisp", "inbox"),
("msgdisp", "log"): ('logger', "inbox"),
("msgdisp", "xmpp.chat"): ('msgdummyhandler', 'inbox'),
("msgdummyhandler", "outbox"): ('msgdisp', 'forward'),
("msgdisp", "outbox"): ("xmpp", "forward"),
('msgdummyhandler', 'proto') : ('proto_man' , 'inbox'),
('proto_man', 'outbox') : ('msgdummyhandler', 'inbox'),
# Activity
("xmpp", "%s.query" % XMPP_LAST_NS): ("activitydisp", "inbox"),
("activitydisp", "log"): ('logger', "inbox"),
("activitydisp", "outbox"): ("xmpp", "forward"),
("activityhandler", 'activity-supported'): ('rosterhandler', 'ask-activity'),
("rosterhandler", 'activity'): ('activitydisp', 'forward'),
}
)
self.addChildren(self.graph)
self.graph.activate()
return 1
from Kamaelia.UI.Pygame.Display import PygameDisplay
from Kamaelia.UI.Pygame.VideoOverlay import VideoOverlay
from Kamaelia.Util.Backplane import Backplane, PublishTo, SubscribeTo
from Kamaelia.Util.RateFilter import MessageRateLimit
PygameDisplay.setDisplayService(
PygameDisplay(width=1024, height=500).activate())
Pipeline(
UnixProcess("ffmpeg -i " + infile +
" -f yuv4mpegpipe -y /dev/stdout"),
2,
YUV4MPEGToFrame(),
50,
MessageRateLimit(25, 25),
PublishTo("VIDEO"),
Backplane("VIDEO"),
StopSelector(waitForTrigger=True),
).activate()
Pipeline(
SubscribeTo("VIDEO"),
TagWithSequenceNumber(),
DetectShotChanges(threshold),
FormatOutput(),
ConsoleEchoer(),
).activate()
Pipeline(SubscribeTo("VIDEO"), VideoOverlay()).run()
def tagger(tag):
print "creating tag", tag
return PureTransformer(lambda x: str((tag, x)) + "\n")
def tagger2(tag):
print "creating tag2", tag
return PureTransformer(lambda x: (tag, x))
if debugging:
for place in locations:
Pipeline(
SubscribeTo(place),
tagger(place),
ConsoleEchoer(),
).activate()
class Santa(Axon.Component.component):
Name = "Santa"
Outboxes = [
"feet",
"voicebox",
]
def main(self):
print "Santa's up and about!"
self.send("santasworkshop", "feet")
webcam=1),
REMWCCANVAS=ProperSurfaceDisplayer(displaysize=(190, 140 * 4 + 4),
position=(1024 - 191, 32 + 140 + 3),
bgcolour=(0, 0, 0),
webcam=2),
CAM_SPLITTER=TwoWaySplitter(),
CONSOLE=ConsoleEchoer(),
linkages={
('', 'inbox'): ('REMWCCANVAS', 'inbox'),
('LOCALWEBCAM', 'outbox'): ('CAM_SPLITTER', 'inbox'),
('CAM_SPLITTER', 'outbox2'): ('WCCANVAS', 'inbox'),
('CAM_SPLITTER', 'outbox'): ('', 'outbox'),
})
# 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(),
SoundOutput(),
######
SoundInput(),
), ),
PublishTo("AUDIO"),
).activate()
linkages={
("CANVAS", "eventsOut"): ("PAINTER", "inbox"),
#("PAINTER", "outbox") : ("CANVAS", "inbox"),
("PAINTER", "outbox"): ("TWOWAY", "inbox"),
#("CLEAR", "outbox") : ("CANVAS", "inbox"),
("CALIBRATE", "outbox"): ("CANVAS", "inbox"),
#("CANVAS", "toApp") : ("CALIBRATE", "coords"),
("TWOWAY", "outbox"): ("CALIBRATE", "coords"),
("TWOWAY", "outbox2"): ("CANVAS", "inbox"),
("CALIBBUTTON", "outbox"): ("CALIBRATE", "inbox"),
("CALIBRATE", "finaldata"): ("FILEWRITER", "inbox"),
("FILEWRITER", "outbox"): ("CALIBRATE", "inbox"),
},
)
if __name__ == "__main__":
mainsketcher = \
Graphline( SKETCHER = makeBasicSketcher(width=1024,height=768),
linkages = { ('','inbox'):('SKETCHER','inbox'),
('SKETCHER','outbox'):('','outbox'),
}
)
# primary calibrator
Pipeline(SubscribeTo("CALIBRATOR"), TagAndFilterWrapper(mainsketcher),
PublishTo("CALIBRATOR")).activate()
print("Starting calibration...")
Backplane("CALIBRATOR").run()
)
camera = Graphline( LOCALWEBCAM = VideoCaptureSource(),
WCCANVAS = ProperSurfaceDisplayer(displaysize = (190, 140), position = (1024-191,32+2), bgcolour=(0,0,0), webcam = 1),
REMWCCANVAS = ProperSurfaceDisplayer(displaysize = (190, 140*4+4), position = (1024-191,32+140+3), bgcolour=(0,0,0), webcam = 2),
CAM_SPLITTER = TwoWaySplitter(),
CONSOLE = ConsoleEchoer(),
linkages = { ('','inbox'):('REMWCCANVAS','inbox'),
('LOCALWEBCAM','outbox'):('CAM_SPLITTER','inbox'),
('CAM_SPLITTER','outbox2'):('WCCANVAS','inbox'),
('CAM_SPLITTER','outbox'):('','outbox'),
}
)
# 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(),
SoundOutput(),
######
SoundInput(),
),
),
PublishTo("AUDIO"),