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.
}