func UpdateSphereAvahiService(isPaired, isMaster bool) error { tmpl, err := template.New("avahi").Parse(src) if err != nil { return err } serviceDefinition := new(bytes.Buffer) err = tmpl.Execute(serviceDefinition, map[string]interface{}{ "Serial": config.Serial(), "Master": isMaster, "Paired": isPaired, "User": config.String("", "userId"), "Site": config.String("", "siteId"), "MasterNode": config.String("", "masterNodeId"), "SiteUpdated": config.Int(0, "siteUpdated"), "RestPort": config.MustInt("homecloud.rest.port"), }) if err != nil { return err } log.Debugf("Saving service definition", serviceDefinition.String()) if runtime.GOOS != "linux" { log.Warningf("Avahi service definition is not being saved, as platform != linux") return nil } if _, err := os.Stat("/data/etc/avahi/services"); err != nil { log.Warningf("Avahi service definition is not being saved, as /data/etc/avahi/services does not exist") return nil } err = ioutil.WriteFile("/data/etc/avahi/services/ninjasphere.service", []byte(serviceDefinition.String()), 0644) // HACK: Remove this if it doesn't fix Chris's problem exec.Command("service", "avahi-daemon", "restart").Output() return err }
func (s *SchedulerService) Init(moduleID string) error { siteID := config.MustString("siteId") s.Scheduler = &controller.Scheduler{} s.Scheduler.SetLogger(s.Log) s.Scheduler.SetSiteID(siteID) s.Scheduler.SetConfigStore(s.ConfigStore) s.Scheduler.SetConnection(s.Conn, time.Millisecond*time.Duration(config.Int(10000, "scheduler", "timeout"))) var err error topic := fmt.Sprintf("$site/%s/service/%s", siteID, "scheduler") announcement := &nmodel.ServiceAnnouncement{ Schema: "http://schema.ninjablocks.com/service/scheduler", } if s.Service, err = s.Conn.ExportService(s, topic, announcement); err != nil { return err } if err := s.Scheduler.Start(s.Model); err != nil { return err } return nil }
"github.com/lucasb-eyer/go-colorful" "github.com/ninjasphere/go-ninja/api" "github.com/ninjasphere/go-ninja/config" "github.com/ninjasphere/go-ninja/logger" "github.com/ninjasphere/go-ninja/model" ledmodel "github.com/ninjasphere/sphere-go-led-controller/model" "github.com/ninjasphere/sphere-go-led-controller/remote" "github.com/ninjasphere/sphere-go-led-controller/ui" "github.com/ninjasphere/sphere-go-led-controller/util" ) var log = logger.GetLogger("sphere-go-led-controller") var enableRemotePanes = config.Bool(false, "led.remote.enabled") var remotePort = config.Int(3115, "led.remote.port") var fps Tick = Tick{ name: "Pane FPS", } type LedController struct { controlEnabled bool controlRequested bool controlRendering bool commandReceived bool controlLayout *ui.PaneLayout pairingLayout *ui.PairingLayout conn *ninja.Connection serial io.ReadWriteCloser
import ( "fmt" "image" "image/color" "strings" "time" "github.com/ninjasphere/gestic-tools/go-gestic-sdk" "github.com/ninjasphere/go-ninja/api" "github.com/ninjasphere/go-ninja/config" "github.com/ninjasphere/sphere-go-led-controller/fonts/clock" ) var enableClockPane = config.Bool(true, "led.clock.enabled") var enableAlarm = config.Bool(true, "led.clock.alarmEnabled") var alarmFlashTimes = config.Int(2, "led.clock.alarmFlashTimes") * 2 var alarmFlashInterval = config.MustDuration("led.clock.alarmFlashInterval") type ClockPane struct { alarm *time.Time timer *time.Timer tapThrottle *throttle lights []*ninja.ServiceClient tickTock bool } func NewClockPane() *ClockPane { var pane *ClockPane pane = &ClockPane{ timer: time.AfterFunc(time.Minute, func() { pane.alarm = nil
func main() { log.Infof("Welcome home, Ninja.") if config.Bool(true, "homecloud.waitForNTP") { waitForNTP() } // The MQTT Connection conn, err := ninja.Connect("sphere-go-homecloud") if err != nil { log.Fatalf("Failed to connect to sphere: %s", err) } // An MQTT Connection used for outbound syncing connections syncConn := &models.SyncConnection{} syncConn.Conn, err = ninja.Connect("sphere-go-homecloud.sync") if err != nil { log.Fatalf("Failed to connect to sphere (sync): %s", err) } // Our redis pool pool := &redis.Pool{ MaxIdle: config.MustInt("homecloud.redis.maxIdle"), MaxActive: config.Int(10, "homecloud.redis.maxActive"), IdleTimeout: config.MustDuration("homecloud.redis.idleTimeout"), Wait: true, Dial: func() (redis.Conn, error) { c, err := redis.Dial("tcp", fmt.Sprintf("%s:%d", config.String("", "homecloud.redis.host"), config.MustInt("homecloud.redis.port"))) if err != nil { return nil, err } return c, err }, TestOnBorrow: func(c redis.Conn, t time.Time) error { _, err := c.Do("PING") return err }, } // Not pretty. rpc.RedisPool = pool // Wait until we connect to redis successfully. for { c := pool.Get() if c.Err() == nil { c.Close() break } log.Warningf("Failed to connect to redis: %s", c.Err()) time.Sleep(time.Second) } // Build the object graph using dependency injection injectables := []interface{}{} injectables = append(injectables, pool, conn, syncConn) injectables = append(injectables, &homecloud.HomeCloud{}, &homecloud.TimeSeriesManager{}, &homecloud.DeviceManager{}, &homecloud.ModuleManager{}) injectables = append(injectables, state.NewStateManager()) injectables = append(injectables, &rest.RestServer{}) injectables = append(injectables, models.GetInjectables()...) err = inject.Populate(injectables...) if err != nil { log.Fatalf("Failed to construct the object graph: %s", err) } // Run PostConstruct on any objects that have it for _, node := range injectables { if n, ok := node.(postConstructable); ok { go func(c postConstructable) { if err := c.PostConstruct(); err != nil { log.Fatalf("Failed PostConstruct on object %s: %s", reflect.TypeOf(c).String(), err) } }(n) } } support.WaitUntilSignal() // So long, and thanks for all the fish. }