Beispiel #1
0
func main() {
	dcams.ManifestFileName = "fakeClient.manifest"
	fakeClient, err := dcams.Open()
	if err != nil {
		//What do we need: 1 pull
		REQ, err := dcams.NewREQ("springInput")
		dieOnErr(err)
		fakeClient.Add(REQ)
		fakeClient.WriteFile()
		log.Printf("fakeClient REQ key:    [\"%s\"]", REQ.PublicKey)
		log.Fatal("Manually swap keys with remote client trusted list!")
	}

	log.Println("Connect")
	err = fakeClient.Connect()
	dieOnErr(err)

	m := Location{Id: "blah", Neighbors: []string{}, Frq: 1.618}
	mmsg, _ := json.Marshal(m)
	log.Println(string(mmsg))
	err = fakeClient.Resource("springInput").Write(string(mmsg))
	dieOnErr(err)
	asd, err := fakeClient.Resource("springInput").Read()
	dieOnErr(err)
	log.Println("ClientFinal", asd)
}
Beispiel #2
0
func main() {
	dcams.ManifestFileName = "testserver.manifest"
	testserver, _ := dcams.Open()

	log.Println(testserver)

	log.Println("Connect")
	testserver.Connect()

	var c Map
	dieOnErr(c.readData("http://localhost:9000/public/rsrc/locations.json"))

	log.Println("Fake data forever")
	for i := 0; ; i++ {
		select {
		case _ = <-time.After(time.Millisecond * 5000):

			msg := c.nextEvent()
			mmsg, _ := json.Marshal(msg)
			//log.Println(string(mmsg))
			err := testserver.Local[0].Write(string(mmsg))
			dieOnErr(err)
		}
	}
}
Beispiel #3
0
func main() {
	dcams.ManifestFileName = "springdata.manifest"
	testserver, err := dcams.Open()
	if err != nil {
		//What do we need: 1 pub, 1 REP
		pub, err := dcams.NewPub("springData")
		dieOnErr(err)
		testserver.Add(pub)
		REP, err := dcams.NewREP("springInput")
		dieOnErr(err)
		testserver.Add(REP)
		testserver.WriteFile()
		log.Printf("springdata  publish key: [\"%s\"]", pub.PublicKey)
		log.Printf("springInput REP key:     [\"%s\"]", REP.PublicKey)
		log.Fatal("Manually swap keys with remote client trusted list!")
	}
	//log.Println(testserver)
	log.Println("Connect")

	//subscribe to model
	go modelDataSub()

	//Connect to upstream visualization server
	testserver.Connect()

	// Connect to model for shuttling upstream requests
	shuttleRequests, _ := zmq.NewSocket(zmq.PUSH)
	shuttleRequests.Bind("tcp://127.0.0.1:5560")

	// async recv upstream visualization requests
	go upstreamRequests(testserver)

	log.Println("Shuttle Model Data forever")
	for i := 0; ; i++ {
		select {
		case d := <-modelData:
			//
			mmsg, _ := json.Marshal(d)
			//log.Println("shuttling", string(mmsg))
			//log.Println("shuttling", d[0])
			err := testserver.Resource("springData").Write(string(mmsg))
			dieOnErr(err)

		case modelUpdate := <-changerequests:
			//shuttle updates to the model
			log.Println("Got request", modelUpdate)
			mmsg, err := json.Marshal(modelUpdate)
			dieOnErr(err)

			//log.Println("shuttling", string(mmsg))
			_, err = shuttleRequests.Send(string(mmsg), 0)
			dieOnErr(err)
		}
	}
}
Beispiel #4
0
func main() {
	dcams.ManifestFileName = "testserver.manifest"
	testserver, err := dcams.Open()
	if err != nil {
		//What do we need: 1 push
		push, err := dcams.NewPush("testserverData")
		dieOnErr(err)
		testserver.Add(push)
		testserver.WriteFile()
		log.Fatal("testserver not ready, add key to trusted list ", push.PublicKey)
	}

	dcams.ManifestFileName = "web.manifest"
	web, err := dcams.Open()
	if err != nil {
		//What do we need: 1 pull
		pull, err := dcams.NewPull("testserverData")
		dieOnErr(err)
		web.Add(pull)
		web.WriteFile()
		log.Fatal("webserver not ready, add key to trusted list ", pull.PublicKey)
	}

	log.Println(testserver)
	log.Println(web)

	log.Println("Connect")
	testserver.Connect()
	web.Connect()

	err = testserver.Resource("testserverData").Write("Hello")
	dieOnErr(err)

	out, err := web.Resource("testserverData").Read()
	dieOnErr(err)
	log.Println("Got:", out)
}
Beispiel #5
0
func main() {
	dcams.ManifestFileName = "springdata.manifest"
	testserver, err := dcams.Open()
	if err != nil {
		//What do we need: 1 pub, 1 REP
		pub, err := dcams.NewPub("springData")
		dieOnErr(err)
		testserver.Add(pub)
		REP, err := dcams.NewREP("springInput")
		dieOnErr(err)
		testserver.Add(REP)
		testserver.WriteFile()
		log.Printf("springdata  publish key: [\"%s\"]", pub.PublicKey)
		log.Printf("springInput REP key:     [\"%s\"]", REP.PublicKey)
		log.Fatal("Manually swap keys with remote client trusted list!")
	}
	//log.Println(testserver)
	log.Println("Connect")
	testserver.Connect()
	go handleClientChange(testserver)

	var c Map
	dieOnErr(c.readData("http://localhost:9000/public/rsrc/substations.json"))

	log.Println("Fake data forever")
	for i := 0; ; i++ {
		select {
		case _ = <-time.After(time.Millisecond * 500):

			msg := c.nextEvent()
			mmsg, _ := json.Marshal(msg)
			//log.Println(string(mmsg))
			//fmt.Printf(".")
			err := testserver.Resource("springData").Write(string(mmsg))
			dieOnErr(err)
		case e := <-publish:
			//log.Println("Got", e)
			c.SetfrqByName(e.Id, e.Frq)
		}
	}
}
Beispiel #6
0
//connect and read all data published by the simulation side of things
func eventsClient() {
	dcams.ManifestFileName = "web.manifest"
	web, err := dcams.Open()
	if err != nil {
		//What do we need: 1 sub, 1 REQ
		sub, err := dcams.NewSub("springData")
		dieOnErr(err)
		web.Add(sub)
		REQ, err := dcams.NewREQ("springInput")
		dieOnErr(err)
		web.Add(REQ)
		web.WriteFile()
		log.Printf("springdata subscribe key: [\"%s\"]", sub.PublicKey)
		log.Printf("springdata REQ key:       [\"%s\"]", REQ.PublicKey)
		log.Println("Manually swap keys with remote client trusted list!")
		return //skips the connect
	}
	web.Connect()

	// handles messages coming from user
	go eventRequester(web)

	//handles messages going to users. Each websocket reads the publish
	for {
		mNodeState, err := web.Resource("springData").Read()
		if err != nil {
			continue
		}
		var newdata Nodes
		if err := json.Unmarshal([]byte(mNodeState), &newdata); err != nil {
			//ignore things that arent Nodess marshalled as json
			continue
		}
		//log.Println(NodeState)
		publish <- newdata
	}
}