Paste the following at the top of <%= dashboard %>.gerb
25 | 26 |6 | 7 |
8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /example/widgets/text/text.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /server.go: -------------------------------------------------------------------------------- 1 | package dashing 2 | 3 | import ( 4 | "encoding/json" 5 | "fmt" 6 | "log" 7 | "net/http" 8 | "path/filepath" 9 | "time" 10 | 11 | "gopkg.in/husobee/vestigo.v1" 12 | "gopkg.in/karlseguin/gerb.v0" 13 | ) 14 | 15 | // A Server contains webservice parameters and middlewares. 16 | type Server struct { 17 | dev bool 18 | webroot string 19 | broker *Broker 20 | } 21 | 22 | func param(r *http.Request, name string) string { 23 | return r.FormValue(fmt.Sprintf(":%s", name)) 24 | } 25 | 26 | // IndexHandler redirects to the default dashboard. 27 | func (s *Server) IndexHandler(w http.ResponseWriter, r *http.Request) { 28 | files, _ := filepath.Glob("dashboards/*.gerb") 29 | 30 | for _, file := range files { 31 | dashboard := file[11 : len(file)-5] 32 | if dashboard != "layout" { 33 | http.Redirect(w, r, fmt.Sprintf("/%s", dashboard), http.StatusTemporaryRedirect) 34 | return 35 | } 36 | } 37 | 38 | http.NotFound(w, r) 39 | } 40 | 41 | // EventsHandler opens a keepalive connection and pushes events to the client. 42 | func (s *Server) EventsHandler(w http.ResponseWriter, r *http.Request) { 43 | f, ok := w.(http.Flusher) 44 | if !ok { 45 | http.Error(w, "Streaming unsupported!", http.StatusInternalServerError) 46 | return 47 | } 48 | 49 | c, ok := w.(http.CloseNotifier) 50 | if !ok { 51 | http.Error(w, "Close notification unsupported!", http.StatusInternalServerError) 52 | return 53 | } 54 | 55 | // Create a new channel, over which the broker can 56 | // send this client events. 57 | events := make(chan *Event) 58 | 59 | // Add this client to the map of those that should 60 | // receive updates 61 | s.broker.newClients <- events 62 | 63 | // Remove this client from the map of attached clients 64 | // when the handler exits. 65 | defer func() { 66 | s.broker.defunctClients <- events 67 | }() 68 | 69 | w.Header().Set("Content-Type", "text/event-stream") 70 | w.Header().Set("Cache-Control", "no-cache") 71 | w.Header().Set("Connection", "keep-alive") 72 | w.Header().Set("X-Accel-Buffering", "no") 73 | closer := c.CloseNotify() 74 | 75 | for { 76 | select { 77 | case event := <-events: 78 | data := event.Body 79 | data["id"] = event.ID 80 | data["updatedAt"] = int32(time.Now().Unix()) 81 | json, err := json.Marshal(data) 82 | if err != nil { 83 | continue 84 | } 85 | if event.Target != "" { 86 | fmt.Fprintf(w, "event: %s\n", event.Target) 87 | } 88 | fmt.Fprintf(w, "data: %s\n\n", json) 89 | f.Flush() 90 | case <-closer: 91 | log.Println("Closing connection") 92 | return 93 | } 94 | } 95 | } 96 | 97 | // DashboardHandler serves the dashboard layout template. 98 | func (s *Server) DashboardHandler(w http.ResponseWriter, r *http.Request) { 99 | dashboard := param(r, "dashboard") 100 | if dashboard == "" { 101 | dashboard = fmt.Sprintf("events%s", param(r, "suffix")) 102 | } 103 | template, err := gerb.ParseFile(true, fmt.Sprintf("dashboards/%s.gerb", dashboard), "dashboards/layout.gerb") 104 | 105 | if err != nil { 106 | http.NotFound(w, r) 107 | return 108 | } 109 | 110 | w.Header().Set("Content-Type", "text/html; charset=UTF-8") 111 | 112 | template.Render(w, map[string]interface{}{ 113 | "dashboard": dashboard, 114 | "development": s.dev, 115 | "request": r, 116 | }) 117 | } 118 | 119 | // DashboardEventHandler accepts dashboard events. 120 | func (s *Server) DashboardEventHandler(w http.ResponseWriter, r *http.Request) { 121 | if r.Body != nil { 122 | defer r.Body.Close() 123 | } 124 | 125 | var data map[string]interface{} 126 | 127 | if err := json.NewDecoder(r.Body).Decode(&data); err != nil { 128 | http.Error(w, "", http.StatusBadRequest) 129 | return 130 | } 131 | 132 | s.broker.events <- &Event{param(r, "id"), data, "dashboards"} 133 | 134 | w.WriteHeader(http.StatusNoContent) 135 | } 136 | 137 | // WidgetHandler serves widget templates. 138 | func (s *Server) WidgetHandler(w http.ResponseWriter, r *http.Request) { 139 | widget := param(r, "widget") 140 | widget = widget[0 : len(widget)-5] 141 | template, err := gerb.ParseFile(true, fmt.Sprintf("widgets/%s/%s.html", widget, widget)) 142 | 143 | if err != nil { 144 | log.Printf("%v", err) 145 | http.NotFound(w, r) 146 | return 147 | } 148 | 149 | w.Header().Set("Content-Type", "text/html; charset=UTF-8") 150 | 151 | template.Render(w, nil) 152 | } 153 | 154 | // WidgetEventHandler accepts widget data. 155 | func (s *Server) WidgetEventHandler(w http.ResponseWriter, r *http.Request) { 156 | if r.Body != nil { 157 | defer r.Body.Close() 158 | } 159 | 160 | var data map[string]interface{} 161 | 162 | if err := json.NewDecoder(r.Body).Decode(&data); err != nil { 163 | log.Printf("%v", err) 164 | http.Error(w, "", http.StatusBadRequest) 165 | return 166 | } 167 | 168 | s.broker.events <- &Event{param(r, "id"), data, ""} 169 | 170 | w.WriteHeader(http.StatusNoContent) 171 | } 172 | 173 | // NewRouter creates a router with defaults. 174 | func (s *Server) NewRouter() http.Handler { 175 | r := vestigo.NewRouter() 176 | r.Get("/", s.IndexHandler) 177 | r.Get("/events", s.EventsHandler) 178 | r.Get("/events:suffix", s.DashboardHandler) // workaround for router edge case 179 | r.Get("/:dashboard", s.DashboardHandler) 180 | r.Post("/dashboards/:id", s.DashboardEventHandler) 181 | r.Get("/views/:widget", s.WidgetHandler) 182 | r.Post("/widgets/:id", s.WidgetEventHandler) 183 | return r 184 | } 185 | 186 | // NewServer creates a Server instance. 187 | func NewServer(b *Broker) *Server { 188 | return &Server{ 189 | dev: false, 190 | webroot: "", 191 | broker: b, 192 | } 193 | } 194 | -------------------------------------------------------------------------------- /worker.go: -------------------------------------------------------------------------------- 1 | package dashing 2 | 3 | // A Job does periodic work and sends events to a channel. 4 | type Job interface { 5 | Work(send chan *Event) 6 | } 7 | 8 | // A Worker contains a collection of jobs. 9 | type Worker struct { 10 | broker *Broker 11 | registry []Job 12 | } 13 | 14 | // Register a job for a particular worker. 15 | func (w *Worker) Register(j Job) { 16 | if j == nil { 17 | panic("Can't register nil job") 18 | } 19 | w.registry = append(w.registry, j) 20 | } 21 | 22 | // Start all jobs. 23 | func (w *Worker) Start() { 24 | for _, j := range w.registry { 25 | go j.Work(w.broker.events) 26 | } 27 | } 28 | 29 | // NewWorker returns a Worker instance. 30 | func NewWorker(b *Broker) *Worker { 31 | return &Worker{ 32 | broker: b, 33 | registry: append([]Job(nil), jobs...), 34 | } 35 | } 36 | 37 | // Global registry for background jobs. 38 | var jobs []Job 39 | 40 | // Register a job to be kicked off upon starting a worker. 41 | func Register(j Job) { 42 | if j == nil { 43 | panic("Can't register nil job") 44 | } 45 | jobs = append(jobs, j) 46 | } 47 | --------------------------------------------------------------------------------