func mainEasyTest() { c := conf.TestConf() dcr, err := rest.DeviceCmdPoll(c.URL, c.DeviceID, c.AccessKey, nil, nil, nil) if err != nil { say.Infof("Error: %s", err.Error()) } else { say.Infof("Ok: %+v", dcr) } }
func main() { say.Level = say.DEBUG say.Infof("POLLING COMMANDS TEST. Send command from another terminal") mainInfinityLoop() //Choose another main function }
func (c *Conn) SendCommand(command map[string]interface{}) { c.lastCommandId++ requestId := c.lastCommandId command["requestId"] = requestId r := make(chan bool, 1) c.queueLock.Lock() c.queue[requestId] = func(res map[string]interface{}) { r <- true } c.queueLock.Unlock() c.postCommand(command) select { case <-time.After(CommandResponseTimeout * time.Second): c.queueLock.Lock() delete(c.queue, requestId) c.queueLock.Unlock() say.Infof("Timed out waiting for response to command: %+v", command) case <-r: } }
func main() { say.Level = say.DEBUG say.Infof("POLLING NOTIFICATIONS TEST. Send notification from another terminal") mainInfinityLoop() //Choose another main function }
func DeviceNotificationPollAsync( deviceHiveURL, deviceGuid, accessKey string, out chan DeviceNotificationResource, control PollAsync, // cannot be nil ) { tr := &http.Transport{} client := &http.Client{Transport: tr} requestOut := make(chan *http.Request, 1) local := make(chan []DeviceNotificationResource, 1) isStopped := make(chan struct{}) for { go func() { for { dnrs, err := DeviceNotificationPoll(deviceHiveURL, deviceGuid, accessKey, nil, client, requestOut) select { case <-requestOut: default: } select { case <-isStopped: return default: } if err != nil { say.Infof("Polling notifications error: %s", err.Error()) time.Sleep(time.Second) continue } if len(dnrs) == 0 { continue } local <- dnrs break } }() select { case dnrs := <-local: for _, dnr := range dnrs { out <- dnr } continue case <-control: select { case req := <-requestOut: isStopped <- struct{}{} tr.CancelRequest(req) return default: } } } }
func main() { say.Level = say.DEBUG f, c, err := conf.FromArgs() if err != nil { say.Infof("Load conf err: %s", err.Error()) return } say.Infof("Conf(%s): %+v", f, c) err = rest.DeviceRegisterEasy(c.URL, c.DeviceID, c.AccessKey, c.DeviceName) if err != nil { say.Infof("Error: %s", err.Error()) } else { say.Infof("Ok") } }
func mainInfinityLoopWithInterruption() { c := conf.TestConf() control := rest.NewPollAsync() out := make(chan rest.DeviceCmdResource, 16) go rest.DeviceCmdPollAsync(c.URL, c.DeviceID, c.AccessKey, out, control) for { select { case item := <-out: say.Infof("item: %+v", item) case <-time.After(15 * time.Second): say.Infof("start Stop()") control.Stop() say.Infof("finish Stop()") return } } }
func main() { name := "TestRestNotification" parameters := map[string]interface{}{"key1": "value1"} f, c, err := conf.FromArgs() if err != nil { say.Infof("Load conf err: %s", err.Error()) return } say.Infof("Conf(%s): %+v", f, c) dnir, err := rest.DeviceNotificationInsert(c.URL, c.DeviceID, c.AccessKey, name, parameters) if err != nil { say.Infof("Error: %s", err.Error()) } else { say.Infof("Ok: %+v", dnir) } }
func main() { var id uint32 = 782346 status := "UpdateCommandTestStatus" result := "UpdateCommandTestResult" f, c, err := conf.FromArgs() if err != nil { say.Infof("Load conf err: %s", err.Error()) return } say.Infof("Conf(%s): %+v", f, c) err = rest.DeviceCmdUpdate(c.URL, c.DeviceID, c.AccessKey, id, status, result) if err != nil { say.Infof("Error: %s", err.Error()) } else { say.Infof("ok") } }
func mainInfinityLoop() { c := conf.TestConf() control := rest.NewPollAsync() out := make(chan rest.DeviceCmdResource, 16) go rest.DeviceCmdPollAsync(c.URL, c.DeviceID, c.AccessKey, out, control) for { select { case item := <-out: say.Infof("item: %+v", item) } } }
func DeviceRegisterEasy(deviceHiveURL, deviceGuid, accessKey, deviceName, deviceKey, networkName, networkKey, networkDesc string) (err error) { api := gopencils.Api(deviceHiveURL) resource := api.Res("device").Id(deviceGuid) resource.SetHeader("Authorization", "Bearer "+accessKey) // device class dc := map[string]interface{}{ "name": "go-gateway-class", "version": "0.1", "offlineTimeout": 10} // network (optional) n := map[string]interface{}{ "name": networkName, "key": networkKey, "description": networkDesc} // device d := map[string]interface{}{ // [optional] "key": deviceKey, "name": deviceName, "status": "Online", "deviceClass": dc} // omit "network" if all fields are empty if len(networkName) != 0 || len(networkKey) != 0 || len(networkDesc) != 0 { d["network"] = n } // omit device key if empty if len(deviceKey) != 0 { d["key"] = deviceKey } resp, err2 := resource.Put(d) say.Infof("DeviceRegisterEasy Response: %+v \r\n %+v", resp, resp.Raw) if err2 == nil { err = resource.ProcessedError() } return }
func main() { say.SetLevelWithConfName("info") configFile, config, err := conf.FromArgs() switch { case err != nil: say.Fatalf("Cannot read configuration in `%s` with error: %s", configFile, err.Error()) case configFile == "": say.Infof("You should specify configuration file. Starting with test configuration: %+v", config) default: say.Infof("Starting DeviceHive gateway with configuration in '%s': %+v", configFile, config) } say.SetLevelWithConfName(config.LoggingLevel) bus, err := dbus.SystemBus() if err != nil { say.Infof("Cannot get system bus with error: %s", err.Error()) say.Infof("Trying to use session bus for testing purposes...") if bus, err = dbus.SessionBus(); err != nil { say.Fatalf("Cannot get session bus with error: %s\n", err.Error()) return } } reply, err := bus.RequestName(DBusConnName, dbus.NameFlagDoNotQueue) switch { case err != nil: say.Fatalf("Cannot request name '%s' with error: %s\n", DBusConnName, err.Error()) case reply != dbus.RequestNameReplyPrimaryOwner: say.Fatalf("The name '%s' already taken.", DBusConnName) } if config.DeviceNotificationReceive == conf.DeviceNotificationReceiveByWS { say.Infof("Starting as websocket...") wsImplementation(bus, config) return } if config.DeviceNotificationReceive == conf.DeviceNotificationReceiveByREST { say.Infof("Starting as rest...") restImplementation(bus, config) return } }
func (c *Conn) runInternal(accessKey string, init func()) error { origin := "http://localhost/" url := c.WebSocketURL() + "/device" say.Verbosef("Connecting using WS to %s", url) ws, _, err := websocket.DefaultDialer.Dial(url, http.Header{"Origin": []string{origin}, "Authorization": []string{"Bearer " + accessKey}}) if err != nil { say.Infof("Dial error: %s", err.Error()) return err } c.ws = ws go func() { for m := range c.senderQ.Out() { say.Verbosef("THROTTLING: Message has been received from priotiorized chan: %+v", m) c.SendCommand(m) } }() go c.writePump() go func() { for { m := <-c.receive go c.handleMessage(m) } }() go init() c.readPump() return nil }
func wsImplementation(bus *dbus.Conn, config conf.Conf) { var conn *ws.Conn for { info, err := rest.GetApiInfo(config.URL) if err == nil { say.Verbosef("API info: %+v", info) c := ws.New(info.WebSocketServerUrl, config.DeviceID, config.SendNotificationQueueCapacity, func(m map[string]interface{}) { p := m["parameters"] params := "" if p != nil { b, err := json.Marshal(p) if err != nil { say.Fatalf("Could not generete JSON from command %+v\nWith error %s", m, err.Error()) } params = string(b) } say.Verbosef("COMMAND %s -> %s(%v)", info.WebSocketServerUrl, m["command"].(string), params) bus.Emit("/com/devicehive/cloud", "com.devicehive.cloud.CommandReceived", uint32(m["id"].(float64)), m["command"].(string), params) }) conn = &c if err == nil { break } } say.Infof("API info error: %s", err.Error()) time.Sleep(5 * time.Second) } w := NewDbusObjectWrapper(conn) go conn.Run(config.AccessKey, func() { conn.RegisterDevice(config.DeviceID, config.DeviceName, config.DeviceKey, config.NetworkName, config.NetworkKey, config.NetworkDesc) conn.Authenticate(config.DeviceID, config.DeviceKey) conn.SubscribeCommands() }) bus.Export(w, "/com/devicehive/cloud", DBusConnName) // Introspectable n := &introspect.Node{ Name: "/com/devicehive/cloud", Interfaces: []introspect.Interface{ introspect.IntrospectData, prop.IntrospectData, { Name: "com.devicehive.cloud", Methods: introspect.Methods(w), }, }, } bus.Export(introspect.NewIntrospectable(n), "/com/devicehive/cloud", "org.freedesktop.DBus.Introspectable") root := &introspect.Node{ Children: []introspect.Node{ { Name: "com/devicehive/cloud", }, }, } bus.Export(introspect.NewIntrospectable(root), "/", "org.freedesktop.DBus.Introspectable") select {} }
func restImplementation(bus *dbus.Conn, config conf.Conf) { err := rest.DeviceRegisterEasy(config.URL, config.DeviceID, config.AccessKey, config.DeviceName, config.DeviceKey, config.NetworkName, config.NetworkKey, config.NetworkDesc) if err != nil { say.Infof("DeviceRegisterEasy error: %s", err.Error()) return } go func() { nControl := rest.NewPollAsync() cControl := rest.NewPollAsync() nOut := make(chan rest.DeviceNotificationResource, 16) cOut := make(chan rest.DeviceCmdResource, 16) go rest.DeviceNotificationPollAsync(config.URL, config.DeviceID, config.AccessKey, nOut, nControl) go rest.DeviceCmdPollAsync(config.URL, config.DeviceID, config.AccessKey, cOut, cControl) for { select { case n := <-nOut: parameters := "" if n.Parameters != nil { b, err := json.Marshal(n.Parameters) if err != nil { say.Infof("Could not generate JSON from parameters of notification %+v\nWith error %s", n, err.Error()) continue } parameters = string(b) } say.Verbosef("NOTIFICATION %s -> %s(%v)", config.URL, n.Notification, parameters) bus.Emit(restObjectPath, restCommandName, uint32(n.Id), n.Notification, parameters) case c := <-cOut: parameters := "" if c.Parameters != nil { b, err := json.Marshal(c.Parameters) if err != nil { say.Infof("Could not generate JSON from parameters of command %+v\nWith error %s", c, err.Error()) continue } parameters = string(b) } say.Verbosef("COMMAND %s -> %s(%v)", config.URL, c.Command, parameters) bus.Emit(restObjectPath, restCommandName, uint32(c.Id), c.Command, parameters) } } }() w := NewDbusRestWrapper(config) bus.Export(w, "/com/devicehive/cloud", DBusConnName) // Introspectable n := &introspect.Node{ Name: "/com/devicehive/cloud", Interfaces: []introspect.Interface{ introspect.IntrospectData, prop.IntrospectData, { Name: "com.devicehive.cloud", Methods: introspect.Methods(w), }, }, } bus.Export(introspect.NewIntrospectable(n), "/com/devicehive/cloud", "org.freedesktop.DBus.Introspectable") root := &introspect.Node{ Children: []introspect.Node{ { Name: "com/devicehive/cloud", }, }, } bus.Export(introspect.NewIntrospectable(root), "/", "org.freedesktop.DBus.Introspectable") select {} }