go/door_daemon_zmq/main.go

   1 // (c) Bernhard Tittelbach, 2013
   2
   3 package main
   4
   5 import (
   6     "fmt"
   7     "os"
   8     "flag"
   9     "time"
  10     "log/syslog"
  11     "log"
  12 )
  13
  14 //~ func StringArrayToByteArray(ss []string) [][]byte {
  15     //~ bb := make([][]byte, len(ss))
  16     //~ for index, s := range(ss) {
  17         //~ bb[index] = []byte(s)
  18     //~ }
  19     //~ return bb
  20 //~ }
  21
  22 // ---------- Main Code -------------
  23
  24 var (
  25     cmd_port_ string
  26     pub_port_ string
  27     door_tty_path_ string
  28     use_syslog_ bool
  29     Syslog_ *log.Logger
  30 )
  31
  32 func init() {
  33     flag.StringVar(&cmd_port_, "cmdport", "ipc:///run/tuer/door_cmd.ipc", "zmq command socket path")
  34     flag.StringVar(&pub_port_, "pubport", "tcp://*:4242", "zmq public/listen socket path")
  35     flag.StringVar(&door_tty_path_, "device", "/dev/door", "door tty device path")
  36     flag.BoolVar(&use_syslog_, "syslog", false, "log to syslog local1 facility")
  37     flag.Parse()
  38 }
  39
  40 func main() {
  41     zmqctx, cmd_chans, pub_chans := ZmqsInit(cmd_port_, pub_port_)
  42     defer cmd_chans.Close()
  43     defer pub_chans.Close()
  44     defer zmqctx.Close()
  45
  46     serial_wr, serial_rd, err := OpenAndHandleSerial(door_tty_path_)
  47     defer close(serial_wr)
  48     if err != nil {
  49         panic(err)
  50     }
  51
  52     if use_syslog_ {
  53         var logerr error
  54         Syslog_, logerr = syslog.NewLogger(syslog.LOG_INFO | syslog.LOG_LOCAL1, 0)
  55         if logerr != nil { panic(logerr) }
  56         Syslog_.Print("started")
  57         defer Syslog_.Print("exiting")
  58     }
  59
  60     //~ serial_wr <- "f"
  61     //~ firmware_version := <- serial_rd
  62     //~ log.Print("Firmware version:", firmware_version)
  63     var next_incoming_serial_is_client_reply bool
  64     timeout_chan := make(chan bool)
  65     defer close(timeout_chan)
  66     for {
  67         select {
  68             case incoming_ser_line, is_notclosed := <- serial_rd:
  69                 if is_notclosed {
  70                     //~ if Syslog_ != nil { Syslog_.Print(ByteArrayToString(incoming_ser_line)) }
  71                     if Syslog_ != nil { Syslog_.Printf("%s",incoming_ser_line) }
  72                     if next_incoming_serial_is_client_reply {
  73                         next_incoming_serial_is_client_reply = false
  74                         cmd_chans.Out() <- incoming_ser_line
  75                     }
  76                     pub_chans.Out() <- incoming_ser_line
  77                 } else {
  78                     Syslog_.Print("serial device disappeared, exiting")
  79                     os.Exit(1)
  80                 }
  81             case tv, timeout_notclosed := <- timeout_chan:
  82                 if timeout_notclosed && tv && next_incoming_serial_is_client_reply {
  83                         next_incoming_serial_is_client_reply = false
  84                         cmd_chans.Out() <- [][]byte{[]byte("ERROR"), []byte("No reply from firmware")}
  85                 }
  86             case incoming_request, ic_notclosed := <- cmd_chans.In():
  87                 if ! ic_notclosed {
  88                     Syslog_.Print("zmq socket died, exiting")
  89                     os.Exit(2)
  90                 }
  91                 if string(incoming_request[0]) == "log" {
  92                     if len(incoming_request) < 2 {
  93                         cmd_chans.Out() <- [][]byte{[]byte("ERROR"), []byte("argument missing")}
  94                         continue
  95                     }
  96                     if Syslog_ == nil {
  97                         cmd_chans.Out() <- [][]byte{[]byte("ERROR"), []byte("syslog logging not enabled")}
  98                         continue
  99                     }
 100                     Syslog_.Printf("Log: %s",incoming_request[1:])
 101                     cmd_chans.Out() <- [][]byte{[]byte("Ok")}
 102                     continue
 103                 }
 104                 if Syslog_ != nil { Syslog_.Printf("%s",incoming_request) }
 105                  if err := HandleCommand(incoming_request, serial_wr, serial_rd); err != nil {
 106                     out_msg := [][]byte{[]byte("ERROR"), []byte(err.Error())}
 107                     cmd_chans.Out() <- out_msg
 108                  } else {
 109                     pub_chans.Out() <- incoming_request
 110                     next_incoming_serial_is_client_reply = true
 111                     go func(){time.Sleep(3*time.Second); timeout_chan <- true;}()
 112                  }
 113         }
 114     }
 115 }