src/getstatus/getstatus.go

   1 // getstatus.go
   2 //
   3 // A sample Orchestra status polling client.
   4
   5 package main
   6
   7 import (
   8         "io"
   9         "net"
  10         "json"
  11         "flag"
  12         "fmt"
  13         "os"
  14         "strconv"
  15 )
  16
  17 type StatusRequest struct {
  18         Op      string  `json:"op"`
  19         Id      uint64  `json:"id"`
  20 }
  21
  22 type PlayerStatus struct {
  23         Status          *string         `json:"status"`
  24         Response        map[string]*string      `json:"response"`
  25 }
  26
  27 type StatusResponse struct {
  28         Status          *string         `json:"status"`
  29         Players         map[string]*PlayerStatus        `json:"players"`
  30 }
  31
  32 var (
  33         AudienceSock = flag.String("audience-sock", "/var/spool/orchestra/conductor.sock", "Path for the audience submission socket")
  34 )
  35
  36 func NewStatusRequest() (sr *StatusRequest) {
  37         sr = new(StatusRequest)
  38         sr.Op = "status"
  39         return sr
  40 }
  41
  42 func Usage() {
  43         fmt.Fprintf(os.Stderr, "Usage:\n")
  44         fmt.Fprintf(os.Stderr, "  %s [<options>] <jobid>\n", os.Args[0])
  45         flag.PrintDefaults()
  46 }
  47
  48 func main() {
  49         flag.Usage = Usage
  50         flag.Parse()
  51
  52         if flag.NArg() != 1 {
  53                 flag.Usage()
  54                 os.Exit(1)
  55         }
  56
  57         sr := NewStatusRequest()
  58         var err os.Error
  59         sr.Id, err = strconv.Atoui64(flag.Arg(0))
  60         if nil != err {
  61                 fmt.Fprintf(os.Stderr, "Failed to parse JobID: %s\n", err)
  62                 os.Exit(1)
  63         }
  64
  65         raddr, err := net.ResolveUnixAddr("unix", *AudienceSock)
  66         if err != nil {
  67                 fmt.Fprintf(os.Stderr, "Failed to resolve sockaddr: %s\n", err)
  68                 os.Exit(1)
  69         }
  70         conn, err := net.DialUnix("unix", nil, raddr)
  71         if err != nil {
  72                 fmt.Fprintf(os.Stderr, "Failed to connect to sockaddr: %s\n", err)
  73                 os.Exit(1)
  74         }
  75
  76         defer conn.Close()
  77
  78         conn.SetTimeout(0)
  79
  80         nc := net.Conn(conn)
  81
  82         r, _ := nc.(io.Reader)
  83         w, _ := nc.(io.Writer)
  84
  85         dec := json.NewDecoder(r)
  86         enc := json.NewEncoder(w)
  87
  88         // send the message
  89         err = enc.Encode(sr)
  90         if err != nil {
  91                 fmt.Fprintf(os.Stderr, "Failed to marshal & send: %s\n", err)
  92                 os.Exit(1)
  93         }
  94
  95         response := new([2]interface{})
  96         sresp := new(StatusResponse)
  97         response[1] = sresp
  98         err = dec.Decode(response)
  99         if err != nil {
 100                 // OK, the problem here is that an in the request will throw a null in the second field.
 101                 // This will cause Decode to softfault.  We'll ignore these softfaults.
 102                 utye, ok := err.(*json.UnmarshalTypeError)
 103                 if ok {
 104                         fmt.Fprintf(os.Stderr, "Unmarshalling error: %s of Type %s\n", utye.Value, utye.Type)
 105                 } else {
 106                         ufe, ok := err.(*json.UnmarshalFieldError)
 107                         if ok {
 108                                 fmt.Fprintf(os.Stderr, "Error decoding response: UFE %s of Type %s\n", ufe.Key, ufe.Type)
 109                                 os.Exit(1)
 110                         }
 111                         ute, ok := err.(*json.UnsupportedTypeError)
 112                         if ok {
 113                                 fmt.Fprintf(os.Stderr, "Error decoding response: UTE of Type %s\n", ute.Type)
 114                                 os.Exit(1)
 115                         }
 116
 117                         fmt.Fprintf(os.Stderr, "Error decoding response: %s\n", err)
 118                         os.Exit(1)
 119                 }
 120         }
 121
 122         // coerce field 0 back into a string.
 123         rerr,ok := response[0].(string)
 124         if ok {
 125                 if rerr == "OK" {
 126                         // all OK, process the sresp.
 127                         fmt.Printf("Aggregate: %s\n", *sresp.Status)
 128                         os.Exit(0)
 129                 } else {
 130                         fmt.Fprintf(os.Stderr, "Server Error: %s\n", rerr)
 131                         os.Exit(1)
 132                 }
 133         } else {
 134                 fmt.Fprintf(os.Stderr, "Couldn't unmarshal response correctly.\n");
 135                 os.Exit(1)
 136         }
 137 }