func NewClientTracker(address string, port int) (p *ClientTracker) { p = new(ClientTracker) p.address = address p.port = port p.clients = map[string]time.Time{} p.new = eventual2go.NewStreamController() p.gone = eventual2go.NewStreamController() p.logger = log.New(os.Stdout, "clienttracker ", log.Lshortfile) return }
func NewOutgoing(uuid string, targetAddress string, targetPort int) (out *eventual2go.StreamController, err error) { var o Outgoing o.Mutex = new(sync.Mutex) o.skt, err = zmq4.NewSocket(zmq4.DEALER) if err != nil { return } err = o.skt.SetIdentity(uuid) if err != nil { return } err = o.skt.Connect(fmt.Sprintf("tcp://%s:%d", targetAddress, targetPort)) if err != nil { return } out = eventual2go.NewStreamController() out.Stream.Listen(o.send) out.Stream.Closed().Then(o.Close) return }
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 newEventHandler() (eh eventHandler) { eh.stream = eventual2go.NewStreamController() eh.join = eh.stream.Where(isJoin).Transform(toMember) eh.leave = eh.stream.Where(isLeave).Transform(toMember) eh.query = eh.stream.Where(isQuery) return }
func (a *Announcer) announce(eventual2go.Data) { a.logger.Println("announcing") results := eventual2go.NewStreamController() c := results.AsChan() a.node.Query(a.servicetype, nil, results) go a.collectAnnounceResponses(c) return }
func (b *Beacon) init() { b.in = eventual2go.NewStreamController() b.stop = make(chan struct{}) b.outConns = []*net.UDPConn{} b.silence = eventual2go.NewCompleter() b.silent = true b.logger = log.New(b.conf.Logger, fmt.Sprintf("beacon %v ", b.payload[1]), log.Lshortfile) }
func NewIncoming(addr string) (i *Incoming, err error) { i = new(Incoming) i.m = new(sync.Mutex) i.addr = addr i.in = eventual2go.NewStreamController() err = i.setupSocket() if err == nil { go i.listen() } return }
func (a *Announcer) replyToExport(d eventual2go.Data) { q := d.(node.QueryEvent) a.logger.Println("found exporting service: ", q.Query.Payload) a.logger.Println(q) results := eventual2go.NewStreamController() c := results.AsChan() go a.collectAnnounceResponses(c) a.node.QueryUuid(fmt.Sprintf("%s", q.Query.Payload), IMPORTING, nil, results) }
func (a *Announcer) announce(eventual2go.Data) { a.logger.Println("announcing") var results *eventual2go.StreamController if a.servicetype == IMPORTING { results = eventual2go.NewStreamController() c := results.AsChan() go a.collectAnnounceResponses(c) } else { a.announced.Complete(nil) } a.node.Query(a.servicetype, a.node.UUID, results) 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 }
func New(uuid string, cfg *config.Config, tags map[string]string) (node *Node) { node = new(Node) node.logger = log.New(cfg.Logger(), fmt.Sprintf("node %s ", uuid), log.Lshortfile) node.logger.Println("Initializing") node.cfg = cfg node.tags = tags node.UUID = uuid node.beacons = []*beacon.Beacon{} node.logger.Println("Launching Serf Agents") node.join = eventual2go.NewStreamController() node.join.First().Then(node.silenceBeacons) node.leave = eventual2go.NewStreamController() node.query = eventual2go.NewStreamController() node.createSerfAgents() return node }
func NewAnnouncer(uuid string, servicetype string, desc *servicedescriptor.ServiceDescriptor, cfg *config.Config, ports []int) (a *Announcer) { a = &Announcer{ announced: eventual2go.NewCompleter(), clientPorts: map[string]int{}, logger: log.New(cfg.Logger(), fmt.Sprintf("announcer %s ", uuid), log.Lshortfile), new: eventual2go.NewStreamController(), node: node.New(uuid, cfg, desc.AsTagSet()), servicetype: servicetype, } a.setPorts(cfg, ports) a.initReactor() return }
func (p *ClientTracker) listenUdp() *eventual2go.Stream { addr := &net.UDPAddr{IP: net.ParseIP(p.address), Port: p.port} p.logger.Println("Starting to listen on", addr) conn, err := net.ListenUDP("udp4", addr) if err != nil { fmt.Println(err) panic(err) } s := eventual2go.NewStreamController() go func(stream *eventual2go.StreamController) { for { data := make([]byte, 128) read, _, _ := conn.ReadFromUDP(data) stream.Add(data[:read]) } }(s) return s.Stream }
func NewResultStreamController() *ResultStreamController { return &ResultStreamController{eventual2go.NewStreamController()} }
func NewNodeStreamController() *NodeStreamController { return &NodeStreamController{eventual2go.NewStreamController()} }
func NewIntStreamController() *IntStreamController { return &IntStreamController{eventual2go.NewStreamController()} }
func NewUUIDStreamController() *UUIDStreamController { return &UUIDStreamController{eventual2go.NewStreamController()} }
func NewMessageStreamController() *MessageStreamController { return &MessageStreamController{eventual2go.NewStreamController()} }
func NewStringSliceStreamController() *StringSliceStreamController { return &StringSliceStreamController{eventual2go.NewStreamController()} }
func TestCallOne2Many(t *testing.T) { i := aursir4go.NewImport(TEST_APP_DESCRIPTOR, config.DefaultLocalhost()) defer i.Remove() i.Run() e1 := aursir4go.NewExport(TEST_APP_DESCRIPTOR, config.DefaultLocalhost()) defer e1.Remove() c1 := e1.Requests().AsChan() e1.Run() e2 := aursir4go.NewExport(TEST_APP_DESCRIPTOR, config.DefaultLocalhost()) defer e2.Remove() c2 := e2.Requests().AsChan() e2.Run() i.Connected().WaitUntilComplete() e1.Connected().WaitUntilComplete() e2.Connected().WaitUntilComplete() params := []byte{4, 5, 63, 4} params1 := []byte{3} params2 := []byte{6} s := eventual2go.NewStreamController() s1, s2 := s.Split(func(d eventual2go.Data) bool { return d.(*messages.Result).Exporter == e1.UUID() }) rc1 := s1.AsChan() rc2 := s2.AsChan() i.CallAll("SayHello", params, s) select { case <-time.After(5 * time.Second): t.Fatal("Didnt Got Request 1") case d := <-c1: r := d.(*messages.Request) if r.Importer != i.UUID() { t.Error("Wrong Import UUID 1", r.Importer, i.UUID()) } var res []byte r.Decode(&res) if !bytes.Equal(res, params) { t.Error("Wrong Params 1", r.Parameter(), params) } e1.Reply(r, params1) } select { case <-time.After(2 * time.Second): t.Fatal("Didnt Got Request 2") case d := <-c2: r := d.(*messages.Request) if r.Importer != i.UUID() { t.Error("Wrong Import UUID 2", r.Importer, i.UUID()) } var res []byte r.Decode(&res) if !bytes.Equal(res, params) { t.Error("Wrong Params 2", r.Parameter(), params) } e2.Reply(r, params2) } select { case <-time.After(2 * time.Second): t.Fatal("Didnt Got Result 1") case d := <-rc1: r := d.(*messages.Result) if r.Exporter != e1.UUID() { t.Error("Wrong Export UUID", r.Exporter, e1.UUID()) } var res []byte r.Decode(&res) if !bytes.Equal(res, params1) { t.Error("Wrong Params", r.Parameter(), params1) } } select { case <-time.After(2 * time.Second): t.Fatal("Didnt Got Result 2") case d := <-rc2: r := d.(*messages.Result) if r.Exporter != e2.UUID() { t.Error("Wrong Export UUID", r.Exporter, e2.UUID()) } var res []byte r.Decode(&res) if !bytes.Equal(res, params2) { t.Error("Wrong Params", r.Parameter(), params2) } } }
func NewSignalStreamController() *SignalStreamController { return &SignalStreamController{eventual2go.NewStreamController()} }
func NewPeerStreamController() *PeerStreamController { return &PeerStreamController{eventual2go.NewStreamController()} }
func NewBoolStreamController() *BoolStreamController { return &BoolStreamController{eventual2go.NewStreamController()} }