Beispiel #1
0
func getTracerExtra(req *Request) func(reason string) string {
	return func(reason string) string {
		e := HttpError{500, "Internal Server Error: " + reason}
		req.Raise(e)

		if req == nil {
			return ""
		}

		var referrer string
		if len(req.Request.Header["Referer"]) > 0 {
			referrer = req.Request.Header["Referer"][0]
		}

		params := string(utils.Encoder(req.GetArguments()))

		stack := ErrorStack{
			Host:      req.Request.Host,
			Method:    req.Request.Method,
			Protocol:  req.Request.Proto,
			RemoteIP:  req.Request.RemoteAddr,
			URI:       req.Request.URL.Path,
			Referer:   referrer,
			Arguments: params,
		}

		var doc bytes.Buffer

		t := template.Must(template.New("error_email").Parse(errorExtra))
		t.Execute(&doc, stack)

		return doc.String()
	}
}
Beispiel #2
0
func pushHandler(item *db.PendingItem, text string, settings map[string]interface{}) {
	log.Println("Sending Push Notification...")

	application_id, ok := settings["parse_application_id"].(string)
	if !ok {
		log.Println("parse_application_id is a required parameter.")
		return
	}

	api_key, ok := settings["parse_rest_api_key"].(string)
	if !ok {
		log.Println("parse_rest_api_key is a required parameter.")
		return
	}

	subject, ok := item.Context["subject"].(string)
	if !ok || subject == "" {
		subject = item.Topic
	}

	body := map[string]interface{}{}
	body["alert"] = subject
	body["title"] = subject
	body["message"] = text
	body["entity"] = item.Entity
	body["organization"] = item.Organization
	body["app_name"] = item.AppName
	body["topic"] = item.Topic
	body["created_on"] = item.CreatedOn
	body["sound"] = PUSH_SOUND
	body["badge"] = "Increment"

	data := map[string]interface{}{}
	data["data"] = body
	data["channels"] = []string{"USER_" + item.User}

	var jsonStr = utils.Encoder(&data)

	req, err := http.NewRequest("POST", PARSE_URL, bytes.NewBuffer(jsonStr))

	req.Header.Set("X-Parse-Application-Id", application_id)
	req.Header.Set("X-Parse-REST-API-Key", api_key)
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	saved_item.Insert(db.SavedPushCollection, &db.SavedItem{Data: data, Details: *item})

	log.Println("Push notification status:", resp.Status)
}
Beispiel #3
0
func performPipe(parentReq *Request, async bool) {

	pipeUrls := []string{}

	req := parentReq.Request
	defer Tracer.Notify(getTracerExtra(parentReq))

	if req.Method != "POST" {
		parentReq.Write("Pipe/Async-Pipe only supports POST request.")
		return
	}

	var calls []eachCall
	parentReq.ConvertArgument("stack", &calls)

	done := make(chan bool)
	output := make([]*utils.Q, len(calls))
	po := make(chan *utils.Q, len(calls))

	var wg sync.WaitGroup

	go func(sink <-chan *utils.Q) {
		for {
			v, more := <-sink
			if more {
				if index, ok := (*v)["index"].(int); ok {
					output[index] = v
				}
			} else {
				done <- true
				return
			}
		}

	}(po)

	for index, oneCall := range calls {
		oneCall.Host = req.Host
		pipeUrls = append(pipeUrls, oneCall.Url)

		pipeData := bytes.NewBuffer(utils.Encoder(oneCall.Data))
		pipeHttpRequest, err := http.NewRequest(oneCall.Method, oneCall.Url, pipeData)
		if err != nil {
			e := HttpError{500, oneCall.Url + " had error"}
			parentReq.Raise(e)
			return
		}

		pipeReq := Request{
			Request:    pipeHttpRequest,
			pipeOutput: po,
			pipeIndex:  index,
		}

		wg.Add(1)

		if async {
			go func(call eachCall) {
				defer wg.Done()
				eachPipe(&pipeReq)
			}(oneCall)
		} else {
			func(call eachCall) {
				defer wg.Done()
				eachPipe(&pipeReq)
			}(oneCall)
		}
	}

	defer pipeTimeTrack(time.Now(), req, strings.Join(pipeUrls, ", "))

	wg.Wait()
	close(po)

	<-done
	parentReq.Write(output)
}
Beispiel #4
0
func (r *Request) Finish(data interface{}) []byte {
	r.Writer.Header().Set("Server", serverUA)
	r.Writer.Header().Set("Access-Control-Allow-Origin", "*")
	r.Writer.Header().Set("Content-Type", "application/json")
	return utils.Encoder(data)
}