func NewAnnouncer(uuid string, addresses []string, servicetype string, desc *appdescriptor.AppDescriptor) (a *Announcer) {
cfg := config.DefaultLocalhost()
a = new(Announcer)
a.announced = eventual2go.NewCompleter()
a.logger = log.New(cfg.Logger(), fmt.Sprintf("announcer %s ", uuid), log.Lshortfile)
a.new = eventual2go.NewStreamController()
a.servicetype = servicetype
addrs := []string{}
a.clientPorts = map[string]int{}
for _, addr := range addresses {
as := strings.Split(addr, ":")
addrs = append(addrs, as[0])
p, _ := strconv.ParseInt(as[1], 0, 0)
a.clientPorts[as[0]] = int(p)
a.logger.Println("adding address", as[0], int(p))
}
cfg.NetworkInterfaces = addrs
a.node = node.New(uuid, cfg, desc.AsTagSet())
a.r = eventual2go.NewReactor()
a.r.React("first_join", a.announce)
a.r.AddFuture("first_join", a.node.Join().First())
a.r.React("service_found", a.replyToServiceQuery)
a.r.AddStream("service_found", a.node.Queries().WhereNot(isService(a.servicetype)))
a.logger.Println("setup finished")
return
}
func New(addr string, port int) (d *Daemon) {
d = new(Daemon)
d.clients = map[string]*eventual2go.StreamController{}
d.announcer = map[string]*service.Announcer{}
d.logger = log.New(os.Stdout, "daemon ", log.Lshortfile)
d.logger.Println("starting up")
incoming, _ := connection.NewIncoming(addr)
d.logger.Println("launched incoming at", incoming.Port())
msg := incoming.In().Where(ValidMessage)
ct := NewClientTracker(addr, port)
r := eventual2go.NewReactor()
r.React("new_client", d.newClient(incoming.Port()))
r.AddStream("new_client", ct.new.Stream)
r.React("client_gone", d.clientGone)
r.AddStream("client_gone", ct.gone.Stream)
r.React("client_service", d.clientService)
r.AddStream("client_service", msg.Where(IsMessage(EXPORT)).Transform(ToNewServiceMessage))
r.AddStream("client_service", msg.Where(IsMessage(IMPORT)).Transform(ToNewServiceMessage))
d.logger.Println("starting tracker")
ct.Run()
d.logger.Println("started")
return
}
// NewInputFromConfig creates a new Input instance for a given configuration.
func NewInputFromConfig(cfg *config.Config) (i *Input, err error) {
m, err := manager.New(cfg)
if err != nil {
return
}
i = &Input{
m: m,
cfg: cfg,
r: eventual2go.NewReactor(),
listen: map[string]interface{}{},
logger: log.New(cfg.Logger(), fmt.Sprintf("%s INPUT ", cfg.UUID()), 0),
results: &messages.ResultStream{m.MessagesOfType(messages.RESULT).Transform(connection.ToMessage)},
}
i.logger.Println("Launching with tagset", cfg.Tags())
i.r.React(connectionEvent{}, i.onConnection)
i.r.AddStream(connectionEvent{}, m.Connected().Stream)
i.r.React(arriveEvent{}, i.sendListenFunctions)
i.r.AddStream(arriveEvent{}, m.PeerArrive().Stream)
i.r.React(startListenEvent{}, i.startListen)
i.r.React(stopListenEvent{}, i.stopListen)
return
}
func (a *Announcer) initReactor() {
a.r = eventual2go.NewReactor()
a.r.React("first_join", a.announce)
a.r.AddFuture("first_join", a.node.Join().First())
a.r.React("service_found", a.replyToService(a.servicetype))
a.r.AddStream("service_found", a.node.Queries().WhereNot(isService(a.servicetype)))
a.logger.Println("setup finished")
}
func (p *ClientTracker) Run() {
p.logger.Println("starting")
r := eventual2go.NewReactor()
r.React("ping", p.checkInclient)
r.AddStream("ping", p.listenUdp())
r.React("check", p.checkclients)
go func(reactor *eventual2go.Reactor) {
for range time.Tick(1 * time.Second) {
reactor.Fire("check", nil)
}
}(r)
}
func NewExport(a *appdescriptor.AppDescriptor, cfg *config.Config) (e *Export) {
e = new(Export)
e.Service = service.NewService(a, service.EXPORTING, cfg, []byte{0})
e.logger = log.New(cfg.Logger(), fmt.Sprintf("export %s ", e.UUID()), log.Lshortfile)
e.requests = e.Messages(messages.REQUEST)
e.listeners = map[string][]string{}
e.r = eventual2go.NewReactor()
e.r.React("listen", e.newListener)
e.r.AddStream("listen", e.IncomingMessages(messages.LISTEN))
e.r.React("listen_stop", e.stopListener)
e.r.AddStream("listen", e.IncomingMessages(messages.STOP_LISTEN))
e.r.React("reply", e.deliverResult)
return
}
func New() (sr *SerialReactor, err error) {
c := &serial.Config{Name: "/dev/ttyUSB1", Baud: 9600}
s, err := serial.OpenPort(c)
if err != nil {
return
}
sr = &SerialReactor{
Reactor: eventual2go.NewReactor(),
s: s,
}
go sr.listen()
return
}
func New(cfg *config.Config) (m *Manager, err error) {
m = &Manager{
r: eventual2go.NewReactor(),
connected: typed_events.NewBoolStreamController(),
peers: map[config.UUID]*peer.Peer{},
arrive: config.NewUUIDStreamController(),
leave: config.NewUUIDStreamController(),
guaranteedMessages: map[messages.Message]*peer.Peer{},
messageIn: connection.NewMessageStreamController(),
logger: log.New(cfg.Logger(), fmt.Sprintf("%s MANAGER ", cfg.UUID()), 0),
shutdown: eventual2go.NewShutdown(),
shutdownComplete: eventual2go.NewCompleter(),
}
m.r.React(peerLeave{}, m.peerLeave)
m.r.React(peerConnected{}, m.peerConnected)
m.r.OnShutdown(m.onShutdown)
for _, iface := range cfg.Interfaces() {
var i *connection.Incoming
i, err = connection.NewIncoming(iface)
if err != nil {
m.logger.Println("ERROR setting up incoming:", err)
m.Shutdown()
return
}
m.shutdown.Register(i)
m.messageIn.Join(i.In().Where(filterMessages))
var t *tracker.Tracker
t, err = tracker.New(iface, i.Port(), cfg)
if err != nil {
m.logger.Println("ERROR setting up tracker:", err)
m.Shutdown()
return
}
m.tracker = append(m.tracker, t)
m.shutdown.Register(t)
m.r.AddStream(peerLeave{}, t.Leave().Stream)
var d *discoverer.Discoverer
d = discoverer.New(t.Join(), i, cfg)
m.r.AddStream(peerConnected{}, d.ConnectedPeers().Stream)
}
return
}
func NewService(dsc *servicedescriptor.ServiceDescriptor, servicetype string, cfg *config.Config, codecs []byte) (s *Service) {
s = new(Service)
if cfg.UUID == "" {
id, _ := uid.NewV4()
cfg.UUID = id.String()
}
s.uuid = cfg.UUID
s.logger = log.New(cfg.Logger(), fmt.Sprintf("service %s ", s.uuid), log.Lshortfile)
s.serviceDescriptor = dsc
s.logger.Println("ServiceDesctiptor TagsSet is", dsc.AsTagSet())
s.servicetype = servicetype
s.codecs = codecs
s.newpeers = eventual2go.NewStreamController()
s.gonepeers = eventual2go.NewStreamController()
s.incoming = map[string]*connection.Incoming{}
s.in = eventual2go.NewStreamController()
s.connectedServices = map[string]*ServiceConnection{}
s.connected = eventual2go.NewCompleter()
s.disconnected = eventual2go.NewCompleter()
s.remove = eventual2go.NewCompleter()
s.r = eventual2go.NewReactor()
s.r.React("service_arrived", s.serviceArrived)
s.r.React("service_gone", s.serviceGone)
s.r.React("announce_finish", s.announced)
s.r.React("service_shake_hand", s.serviceHandshake)
s.r.AddStream("service_shake_hand", s.in.Where(messages.Is(messages.HELLO)))
s.r.React("service_shake_hand_reply", s.serviceHandShakeReply)
s.r.AddStream("service_shake_hand_reply", s.in.Where(messages.Is(messages.HELLO_OK)))
s.createIncoming(cfg)
s.createAnnouncer(cfg)
return
}
// NewOutputFromConfig creates a new Output instance for a given configuration.
func NewOutputFromConfig(cfg *config.Config) (o *Output, err error) {
m, err := manager.New(cfg)
o = &Output{
cfg: cfg,
m: m,
requests: &messages.RequestStream{m.MessagesOfType(messages.REQUEST).Transform(connection.ToMessage)},
listeners: map[string]map[config.UUID]interface{}{},
logger: log.New(cfg.Logger(), fmt.Sprintf("%s OUTPUT ", cfg.UUID()), 0),
r: eventual2go.NewReactor(),
}
o.logger.Println("Launching with tagset", cfg.Tags())
o.r.React(startListenEvent{}, o.onListen)
o.r.AddStream(startListenEvent{}, m.MessagesOfType(messages.LISTEN).Stream)
o.r.React(stopListenEvent{}, o.onStopListen)
o.r.AddStream(stopListenEvent{}, m.MessagesOfType(messages.STOPLISTEN).Stream)
o.r.React(leaveEvent{}, o.onPeerGone)
o.r.React(replyEvent{}, o.deliverResult)
return
}