Beispiel #1
0
func updateMPD(comp *backend.Component) error {

	mpd := comp.Internal.(*mpdClientComponent)
	if !mpd.connected {
		defer mpd.connect()
		return nil
	}

	status, err := mpd.client.Status()
	if err != nil {
		mpd.connected = false
		return err
	}

	song, err := mpd.client.CurrentSong()
	if err != nil {
		mpd.connected = false
		return err
	}

	res := map[string]interface{}{
		"song":   song,
		"status": status,
	}
	json, err := config.RenderJson(res)
	if err != nil {
		return err
	}

	if json != mpd.lastJSONString {
		mpd.lastJSONString = json
		comp.StateSink <- res
	}
	return nil
}
Beispiel #2
0
func updateWeather(component *backend.Component) error {
	weather := component.Internal.(*weatherTracker)

	nextCheck := weather.lastCheck.Add(time.Duration(weather.delay) * time.Minute)

	if time.Now().Before(nextCheck) {
		logrus.Debugf("Component: %s skipping update. Next check at %s", component.URN(), nextCheck.Local())
		return nil
	}

	coord := owm.Coordinates{
		Longitude: core.Global.Longitude,
		Latitude:  core.Global.Latitude,
	}

	if err := weather.current.CurrentByCoordinates(&coord); err != nil {
		logrus.Warnf("Component: %s failed to update current weather conditions: %s", component.URN(), err)
		return err
	}

	json, err := config.RenderJson(weather.current)
	if err != nil {
		logrus.Warnf("Component: %s failed to update current weather conditions: %s", component.URN(), err)
		return err
	}

	if json != weather.lastJSON {
		weather.lastJSON = json
		component.StateSink <- weather.current
	}

	weather.lastCheck = time.Now()
	return nil
}
Beispiel #3
0
func updateNetgear(comp *backend.Component) error {
	net := comp.Internal.(*netgearComponent)

	start := time.Now()

	if net.isUpdating {
		logrus.Infof("Component: %s ignoring polling request. update still running", comp.URN())
		return nil
	}
	net.isUpdating = true
	defer func() {
		net.isUpdating = false
	}()
	logrus.Debugf("Component: %s Updating attached devices", comp.URN())

	res, err := net.router.Login()
	if err != nil {
		return err
	}

	if res {
		device, err := net.router.GetAttachedDevices()
		var preparedDevices []netgear.AttachedDevice

		if err != nil {
			return err
		}

		for i, dev := range device {
			if net.knownDevices[dev.Mac] != "" {
				if net.trackOnlyKnown {
					dev.Name = net.knownDevices[dev.Mac]
					preparedDevices = append(preparedDevices, dev)
				} else {
					device[i].Name = net.knownDevices[dev.Mac]
				}
			}
		}
		if net.trackOnlyKnown {
			device = preparedDevices
		}

		str, err := config.RenderJson(device)
		if err != nil {
			return err
		}

		net.last = str
		comp.StateSink <- device
	} else {
		return fmt.Errorf("Failed to login")
	}
	logrus.Debugf("Component: %s updated connected devices in %s", comp.URN(), time.Now().Sub(start))
	return nil
}
Beispiel #4
0
func apiRule(call otto.FunctionCall) otto.Value {
	obj := call.Argument(0).Object()

	nameValue, err := obj.Get("name")
	if err != nil {
		logrus.Errorf("Error: %v", err)
		return otto.Value{}
	}
	name := nameValue.String()

	rule := &JsRule{
		Name: name,
		VM:   call.Otto,
	}

	obj.Call("init")

	call.Otto.Set(rule.Name, obj)

	logrus.Infof("Registered javascript: %#v", rule)

	eventbus.EventBus.Subscribe(eventbus.STATE_CHANGED, func(event eventbus.Event) {
		data, _ := config.RenderJson(event)
		o, err := call.Otto.Object(rule.Name)
		if err != nil {
			logrus.Warnf("JavaScript-Error: %s: %s error=%s", rule.Name, o, err)
		}

		val, err := call.Otto.Object("(" + data + ")")
		if err != nil {
			logrus.Warnf("JavaScript-Error: %s: %s error=%s", rule.Name, val, err)
		}

		resultValue, err := o.Call("onChange", val)
		if err != nil {
			logrus.Warnf("JavaScript-Error: %s: %s error=%s", rule.Name, resultValue, err)
		}
		result := resultValue.String()

		if rule.result != result {
			logrus.Infof("Sending update %s -> %s (old: %s)", rule.Name, result, rule.result)
			event := eventbus.Event{
				Topic:  eventbus.STATE_CHANGED,
				Origin: "rule." + rule.Name,
				Error:  nil,
				Data:   result,
			}
			eventbus.EventBus.Publish(event)
			rule.result = result
		}
	})

	return otto.Value{}
}
Beispiel #5
0
func apiSubscribe(call otto.FunctionCall) otto.Value {
	topic := call.Argument(0).String()
	func_name := call.Argument(1).String()

	logrus.Infof("[Plugins/rules] javascript vm subscibed to %s", topic, func_name)

	eventbus.EventBus.Subscribe(topic, func(event eventbus.Event) {
		data, _ := config.RenderJson(event)
		jsCmd := fmt.Sprintf("(%s.bind(Home))(%s)", func_name, data)
		result, err := call.Otto.Run(jsCmd)
		if err != nil {
			logrus.Warnf("JavaScript-Error: %s error=%s", result, err)
		}
	})
	return otto.Value{}
}