Exemplo n.º 1
0
func (self *remoteService) run(ws *websocket.Conn) error {
	for {
		mt, msg, err := ws.ReadMessage()
		if err != nil {
			fmt.Printf("remoteService.run: %#v\n", err)
			break
		}

		if mt != websocket.BinaryMessage {
			continue
		}

		cmd := cmdResult{}
		if err := json.NewDecoder(bytes.NewReader(msg)).Decode(&cmd); err != nil {
			return err
		}

		if cmd.Id == nil {
			if err := self.handleEvent(cmd.Back, cmd.Sid, stream.Event([]byte(cmd.Data))); err != nil {
				return err
			}
		} else {
			if err := self.handleCmdRes(*cmd.Id, cmd.Data); err != nil {
				return err
			}
		}
	}
	return nil
}
Exemplo n.º 2
0
func (self *httpBackendStream) Read(from uint, to uint) (stream.Stream, error) {
	if from == to {
		return stream.Empty(), nil
	}

	resp, err := self.p.Post(fmt.Sprintf(self.readUrl, from, to), nil)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	res := arrErrorObj{}
	if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
		return nil, err
	}

	if res.Err != "" {
		return nil, errors.New(res.Err)
	}

	r := make([]stream.Event, len(res.Events))
	for i, v := range res.Events {
		r[i] = stream.Event([]byte(v))
	}
	return stream.List(r), nil
}
Exemplo n.º 3
0
func (self *ledisListStream) Next() (stream.Event, error) {
	if self.num >= self.l {
		return nil, stream.EOI
	}

	res, err := self.db.LIndex(self.key, self.num)
	if err != nil {
		self.delLock.RUnlock()
		return nil, err
	}

	self.num += 1
	if self.num >= self.l {
		self.delLock.RUnlock()
	}
	return stream.Event(res), nil
}
Exemplo n.º 4
0
func addCmdHandler(s Service, d []byte) error {
	data := addCmdData{}
	if err := json.NewDecoder(bytes.NewReader(d)).Decode(&data); err != nil {
		return err
	}

	b, err := s.GetBackend(data.Back)
	if err != nil {
		return err
	}

	str, _, err := b.GetStream(data.Name)
	if err != nil {
		return err
	}

	return str.Add(stream.Event([]byte(data.Evt)))
}
Exemplo n.º 5
0
/*
Create a http.Handler that maps URLs from HTTP backend to a methods of an object implementing Backend interface.
*/
func NewHandler(b Backend, errorCb func(error)) http.Handler {
	r := mux.NewRouter()

	r.HandleFunc("/config", func(w http.ResponseWriter, r *http.Request) {
		cfg, err := b.Config()
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		if err := json.NewEncoder(w).Encode(&configRes{Cfg: cfg}); err != nil {
			sendErr(w, err, errorCb)
			return
		}
	}).Methods("POST")

	r.HandleFunc("/streams", func(w http.ResponseWriter, r *http.Request) {
		ss, err := b.Streams()
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		if err := json.NewEncoder(w).Encode(&sarrErrorObj{Streams: ss}); err != nil {
			sendErr(w, err, errorCb)
			return
		}
	}).Methods("POST")

	r.HandleFunc("/drop", func(w http.ResponseWriter, r *http.Request) {
		sendErr(w, b.Drop(), errorCb)
	}).Methods("POST")

	r.HandleFunc("/streams/{name}/push", func(w http.ResponseWriter, r *http.Request) {
		data, err := ioutil.ReadAll(r.Body)
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		s, err := b.GetStream(mux.Vars(r)["name"])
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}
		defer func() {
			if err := s.Close(); err != nil {
				errorCb(err)
			}
		}()

		sendErr(w, s.Add(stream.Event(data)), errorCb)
	}).Methods("POST")

	r.HandleFunc("/streams/{name}/interval/{from}:{to}", func(w http.ResponseWriter, r *http.Request) {
		vars := mux.Vars(r)
		s, err := b.GetStream(vars["name"])
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}
		defer func() {
			if err := s.Close(); err != nil {
				errorCb(err)
			}
		}()

		from, err := strconv.Atoi(vars["from"])
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		to, err := strconv.Atoi(vars["to"])
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		f, t, err := s.Interval(from, to)
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		if err := json.NewEncoder(w).Encode(&interErrorObj{From: f, To: t}); err != nil {
			sendErr(w, err, errorCb)
			return
		}
	}).Methods("POST")

	r.HandleFunc("/streams/{name}/read/{from}:{to}", func(w http.ResponseWriter, r *http.Request) {
		vars := mux.Vars(r)
		s, err := b.GetStream(vars["name"])
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}
		defer func() {
			if err := s.Close(); err != nil {
				errorCb(err)
			}
		}()

		from, err := strconv.Atoi(vars["from"])
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		if from < 0 {
			sendErr(w, errors.New(fmt.Sprintf("Expected \"from\" to be >= 0, got %v", from)), errorCb)
			return
		}

		to, err := strconv.Atoi(vars["to"])
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		if to < 0 {
			sendErr(w, errors.New(fmt.Sprintf("Expected \"to\" to be >= 0, got %v", to)), errorCb)
			return
		}

		str, err := s.Read(uint(from), uint(to))
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		l := 0
		if to >= 0 {
			l = to - from
		}

		res := make([]json.RawMessage, 0, l)
		for {
			evt, err := str.Next()
			if err == stream.EOI {
				break
			}
			if err != nil {
				sendErr(w, err, errorCb)
				return
			}

			bs, ok := evt.([]byte)
			if !ok {
				sendErr(w, errors.New(fmt.Sprintf("Expected []byte event, got %v", evt)), errorCb)
				return
			}

			res = append(res, json.RawMessage(bs))
		}

		if err := json.NewEncoder(w).Encode(&arrErrorObj{Events: res}); err != nil {
			sendErr(w, err, errorCb)
			return
		}
	}).Methods("POST")

	r.HandleFunc("/streams/{name}/del/{from}:{to}", func(w http.ResponseWriter, r *http.Request) {
		vars := mux.Vars(r)
		s, err := b.GetStream(vars["name"])
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}
		defer func() {
			if err := s.Close(); err != nil {
				errorCb(err)
			}
		}()

		from, err := strconv.Atoi(vars["from"])
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		if from < 0 {
			sendErr(w, errors.New(fmt.Sprintf("Expected \"from\" to be >= 0, got %v", from)), errorCb)
			return
		}

		to, err := strconv.Atoi(vars["to"])
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		if to < 0 {
			sendErr(w, errors.New(fmt.Sprintf("Expected \"to\" to be >= 0, got %v", to)), errorCb)
			return
		}

		ok, err := s.Del(uint(from), uint(to))
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		if err := json.NewEncoder(w).Encode(&boolErrorObj{Ok: ok}); err != nil {
			sendErr(w, err, errorCb)
			return
		}
	}).Methods("POST")

	r.HandleFunc("/streams/{name}/len", func(w http.ResponseWriter, r *http.Request) {
		s, err := b.GetStream(mux.Vars(r)["name"])
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}
		defer func() {
			if err := s.Close(); err != nil {
				errorCb(err)
			}
		}()

		l, err := s.Len()
		if err != nil {
			sendErr(w, err, errorCb)
			return
		}

		if err := json.NewEncoder(w).Encode(&lenErrorObj{Len: l}); err != nil {
			sendErr(w, err, errorCb)
			return
		}
	}).Methods("POST")

	return r
}