コード例 #1
0
ファイル: update.go プロジェクト: robertocs/cepiot
func (a *UpdateAction) Do(n notices.Notice) (err error) {

	// A litle (or very) dirty. Add "hidden" parameters as notification data
	// and remove them after executing template (better copy first level fields in a new map?)
	n["__attrName"] = a.ActionData.Parameters["name"]
	n["__attrValue"] = a.ActionData.Parameters["value"]
	n["__attrType"] = a.ActionData.Parameters["type"]
	text := util.ExpandFromMap(updateTemplateText, n)
	mylog.Debug("UpdateAction text to send:", text)
	delete(n, "__attrName")
	delete(n, "__attrValue")
	delete(n, "__attrType")

	req, err := http.NewRequest("POST", config.UpdateEndpoint(), strings.NewReader(text))
	if err != nil {
		mylog.Alert("UpdateAction.Do", err)
	}
	req.Header.Add("Content-Type", "application/json")
	resp, err := httpClient.Do(req)
	if err != nil {
		mylog.Alert("UpdateAction.Do", err)
		return err
	}
	respDump, err := httputil.DumpResponse(resp, true)
	mylog.Debugf("UpdateAction.Do server response: (%q,%v)\n", string(respDump), err)
	return err
}
コード例 #2
0
ファイル: sms.go プロジェクト: robertocs/cepiot
func (a *SMSAction) Do(n notices.Notice) (err error) {
	if mylog.Debugging {
		defer func() { mylog.Debugf("exit SMSAction.Do  %+v", err) }()
	}

	text := util.ExpandFromMap(a.ActionData.Template, n)
	mylog.Debug("SMSAction text to send:", text)
	msg := fmt.Sprintf(`{"to":["tel:%s"], "message": %q}`, a.Parameters["to"], text)
	mylog.Debug("SMSAction msg to send:", msg)
	req, err := http.NewRequest("POST", config.SMSEndpoint(), strings.NewReader(msg))
	if err != nil {
		mylog.Alert("SMSAction.Do", err)
	}
	req.Header.Add("API_KEY", config.APIKey())
	req.Header.Add("API_SECRET", config.APISecret())
	req.Header.Add("Content-Type", "application/json")
	mylog.Debug("SMSAction.Do msg:", msg)
	resp, err := httpClient.Do(req)
	if err != nil {
		mylog.Alert("SMSAction.Do", err)
		return err
	}
	respDump, err := httputil.DumpResponse(resp, true)
	mylog.Debugf("SMSAction.Do server response: (%q,%v)\n", string(respDump), err)
	return err
}
コード例 #3
0
ファイル: rule_controller.go プロジェクト: robertocs/cepiot
func (rs *controller) Post(w http.ResponseWriter, request *http.Request, p httprouter.Params) {
	defer request.Body.Close()

	data, err := ioutil.ReadAll(request.Body)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
	var rule Rule
	err = json.Unmarshal(data, &rule)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
	err = Save(&rule)
	if err != nil {
		if mgo.IsDup(err) {
			http.Error(w, err.Error(), http.StatusBadRequest)
		} else {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
		return
	}
	axn, err := rule.GetAction()
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
	actions.Add(axn)
	req, err := http.NewRequest("POST", config.RuleEndpoint(), strings.NewReader(rule.EPL))
	if err != nil {
		mylog.Alert("rule controller POST", err)
	}
	resp, err := httpClient.Do(req)
	if err != nil {
		mylog.Alert("rule controller POST", err, resp)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	if resp.StatusCode/100 != 2 {
		mylog.Alert("rule controller POST", resp.Status)
		http.Error(w, resp.Status, http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusCreated)
	dataBack, err := json.Marshal(rule)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Write(dataBack)

}
コード例 #4
0
ファイル: handler.go プロジェクト: robertocs/cepiot
func PanicHandler(h http.Handler) http.Handler {
	return http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			defer func() {
				if excp := recover(); excp != nil {
					mylog.Alert(excp)
					debug.PrintStack()
					http.Error(w, "Internal panic. Contact support team.", 500)
				}
			}()
			h.ServeHTTP(w, r)
		})
}
コード例 #5
0
ファイル: main.go プロジェクト: robertocs/cepiot
func main() {
	var err error

	fmt.Println("Hello World!")
	mylog.SetLevel("debug")
	if err = config.LoadConfig("cepiot.conf"); err != nil {
		mylog.Alert(err)
		os.Exit(-1)
	}
	if err = rules.Initialize(); err != nil {
		mylog.Alert(err)
		os.Exit(-1)
	}
	router := httprouter.New()
	notices.AddRoutes(router)
	actions.AddRoutes(router)
	rules.AddRoutes(router)
	err = http.ListenAndServe(config.Port(), util.PanicHandler(router))
	if err != nil {
		mylog.Alert(err)
	}

}
コード例 #6
0
ファイル: rule_controller.go プロジェクト: robertocs/cepiot
func (rs *controller) Del(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
	err := Delete(p[0].Value)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	req, err := http.NewRequest("DELETE", config.RuleEndpoint()+"/"+p[0].Value, nil)
	if err != nil {
		mylog.Alert("rule controller DELETE", err)
	}
	resp, err := httpClient.Do(req)
	if err != nil {
		mylog.Alert("rule controller DELETE", err, resp)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	if resp.StatusCode/100 != 2 {
		mylog.Alert("rule controller DELETE", resp.Status)
		http.Error(w, resp.Status, http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)
	fmt.Fprintln(w, "deleted", p[0].Value)
}
コード例 #7
0
ファイル: email.go プロジェクト: robertocs/cepiot
func (a *EmailAction) Do(n notices.Notice) (err error) {
	if mylog.Debugging {
		mylog.Debugf("enter EmailAction.Do %+v %+v", a, n)
		defer func() { mylog.Debugf("exit EmailAction.Do  %+v", err) }()
	}

	text := util.ExpandFromMap(a.ActionData.Template, n)
	mylog.Debugf("text to send %q", text)
	err = smtp.SendMail(config.SMTPServer(), nil,
		a.Parameters["from"],
		[]string{a.Parameters["to"]},
		[]byte(text))
	if err != nil {
		mylog.Alert("EmailAction.Do", err)
	}
	return err
}