Enable switch toggling

1 files changed, 76 insertions, 33 deletions

diff --git a/main.go b/main.go
index d2d1fd7..5a12a93 100644
--- a/main.go
+++ b/main.go
@@ -10,18 +10,20 @@ import (
         "golang.org/x/crypto/ssh"
         "io/ioutil"
         "net"
-        "sort"
+        "time"
 )
 
 const CMD_PATH = "/var/etc/persistent/power_control.sh"
 
 type Device struct {
-        Root     *Device
-        Username string
-        Password string
-        Port     int
-        Host     string
-        Devices  []string
+        Root      *Device
+        Name      string
+        Username  string
+        Password  string
+        Port      int
+        Host      string
+        Devices   []string
+        sshClient *ssh.Client
 }
 
 func (d *Device) GetUsername() string {
@@ -54,11 +56,12 @@ func (d *Device) GetPort() int {
         }
 }
 
-func (d *Device) newSession() (*ssh.Client, *ssh.Session, error) {
+func (d *Device) Connect() error {
         cfg := &ssh.ClientConfig{
                 User:            d.GetUsername(),
                 Auth:            []ssh.AuthMethod{ssh.Password(d.GetPassword())},
                 HostKeyCallback: ssh.InsecureIgnoreHostKey(),
+                Timeout:         0,
         }
 
         // These devices use really old crufty versions of SSH
@@ -67,32 +70,49 @@ func (d *Device) newSession() (*ssh.Client, *ssh.Session, error) {
 
         conn, err := ssh.Dial("tcp", fmt.Sprintf("%s:%d", d.Host, d.GetPort()), cfg)
         if err != nil {
-                return nil, nil, err
+                return err
         }
 
-        s, err := conn.NewSession()
-        if err != nil {
-                conn.Close()
-                return nil, nil, err
+        d.sshClient = conn
+        return nil
+}
+
+func (d *Device) Disconnect() {
+        d.sshClient.Close()
+}
+
+func (d *Device) newSession() (*ssh.Session, error) {
+        for i := 3; i > 0; i-- {
+                if s, err := d.sshClient.NewSession(); err == nil {
+                        return s, nil
+                } else if err != nil && i == 0 {
+                        fmt.Printf("Session error, failing: %s\n", err)
+                        return nil, err
+                }
+
+                fmt.Println("Session error, reconnecting")
+                d.Connect()
         }
 
-        return conn, s, nil
+        return nil, errors.New("Unable to connect via SSH")
 }
 
 func (d *Device) runCommand(cmd string) ([]DeviceOutput, error) {
-        conn, sess, err := d.newSession()
+        sess, err := d.newSession()
         if err != nil {
+                fmt.Printf("Session error: %s\n", err)
                 return nil, err
         }
-        defer conn.Close()
         defer sess.Close()
 
         out, err := sess.Output(cmd)
         if err != nil {
+                fmt.Printf("Command error: %s\n", err)
                 return nil, err
         }
 
         if out == nil {
+                fmt.Printf("Nil return\n")
                 return nil, nil
         } else {
                 var r []DeviceOutput
@@ -169,20 +189,20 @@ type DeviceOutput struct {
         PowerFactor float64 `json:"power_factor"`
 }
 
-func LoadAppConfig(filename string) (map[string]*Device, error) {
+func LoadAppConfig(filename string) ([]*Device, error) {
         raw, err := ioutil.ReadFile(filename)
         if err != nil {
                 return nil, err
         }
 
-        var cfg map[string]*Device
+        var cfg []*Device
         err = json.Unmarshal(raw, &cfg)
         if err != nil {
                 return nil, err
         }
 
-        if def, ok := cfg["DEFAULT"]; ok {
-                delete(cfg, "DEFAULT")
+        if def := cfg[0]; def.Name == "DEFAULT" {
+                cfg = cfg[1:]
 
                 for _, v := range cfg {
                         v.Root = def
@@ -205,32 +225,53 @@ func (o *Output) Toggle(on bool) error {
         return err
 }
 
+func GatherReports(devs []*Device) {
+        t := time.NewTicker(10 * time.Second)
+        defer t.Stop()
+
+        for {
+                <-t.C
+                for _, d := range devs {
+                        d.GetReport()
+                }
+        }
+}
+
+func StopBlinking(devs []*Device) {
+        t := time.NewTicker(10 * time.Second)
+        defer t.Stop()
+
+        for {
+                <-t.C
+                for _, d := range devs {
+                        d.DisableBlink()
+                }
+        }
+}
+
 func main() {
-        cfg, err := LoadAppConfig("config.json")
+        devs, err := LoadAppConfig("config.json")
         if err != nil {
                 fmt.Println(err)
                 return
         }
 
-        devs := make([]string, 0, len(cfg))
-        for k, _ := range cfg {
-                devs = append(devs, k)
-        }
-        sort.Strings(devs)
-
         reg := []*accessory.Accessory{}
         accs := make(map[*characteristic.Characteristic]*Output, 10)
 
         for _, k := range devs {
-                v := cfg[k]
-                fmt.Println("Connecting to ", v)
+                fmt.Printf("Connecting to %s\n", k.Name)
+
+                if err = k.Connect(); err != nil {
+                        panic(err)
+                }
 
-                report, err := v.GetReport()
+                report, err := k.GetReport()
                 if err != nil {
                         panic(err)
                 }
 
-                for i, d := range v.Devices {
+                for i, d := range k.Devices {
                         // Unnamed outputs are unused
                         if d == "" {
                                 continue
@@ -244,7 +285,7 @@ func main() {
                                 output.Toggle(on)
                         })
                         accs[sw.Switch.On.Characteristic] = &Output{
-                                Device: v,
+                                Device: k,
                                 Name:   d,
                         }
                         sw.Switch.On.UpdateValue(report[i].Engaged)
@@ -254,7 +295,7 @@ func main() {
 
         br := accessory.NewBridge(accessory.Info{Name: "mFi Bridge"})
 
-        t, err := hc.NewIPTransport(hc.Config{Pin: "00102003"}, br.Accessory, reg...)
+        t, err := hc.NewIPTransport(hc.Config{Pin: "00102003", Port: "6969"}, br.Accessory, reg...)
         if err != nil {
                 fmt.Println(err)
         }
@@ -263,5 +304,7 @@ func main() {
                 <-t.Stop()
         })
 
+        // Gathering reports also keeps the SSH connections alive
+        go GatherReports(devs)
         t.Start()
 }