Beispiel #1
0
func BaoHandler(w http.ResponseWriter, req *http.Request) {
	vars := mux.Vars(req)
	baoId := vars["id"]
	bao, err := model.GetBaoById(baoId)
	if err != nil {
		http.Error(w, "not found", 404)
		return
	}

	gist, err := builder.FetchGistData(bao.GistId)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	svc := cloudwatch.New(&aws.Config{Region: aws.String("us-east-1")})

	params := &cloudwatch.GetMetricStatisticsInput{
		EndTime:    aws.Time(time.Now()),
		MetricName: aws.String("Invocations"),
		Namespace:  aws.String("AWS/Lambda"),
		Period:     aws.Int64(480 * 8),
		StartTime:  aws.Time(time.Now().Add(-time.Hour * 24 * 20)),
		Statistics: []*string{
			aws.String("Sum"),
		},
		Dimensions: []*cloudwatch.Dimension{
			{
				Name:  aws.String("FunctionName"),
				Value: aws.String(bao.FunctionName),
			},
		},
		Unit: aws.String("Count"),
	}
	resp, err := svc.GetMetricStatistics(params)
	if err != nil {
		http.Error(w, err.Error(), 500)
	}
	fmt.Println(err)

	response := BaoResponse{
		Id:          baoId,
		Gist:        gist,
		Bao:         bao,
		Stats:       resp.String(),
		Root:        config.C["root"],
		DateCreated: bao.Ts.Format("3:04pm Jan 2, 2006"),
	}
	RenderTemplate(w, "bao", response)
}
Beispiel #2
0
func handler(w http.ResponseWriter, r *http.Request) {

	host := r.Host
	host_parts := strings.Split(host, ".")

	var subdomain string
	var functionName string

	if len(host_parts) == 3 {
		subdomain = host_parts[0]
		fmt.Println(subdomain)
		functionName = destinations[subdomain]
	}

	if subdomain == "test" {
		http.Error(w, "all ok", http.StatusOK)
		return
	}

	if functionName == "" && subdomain != "" {
		fmt.Printf("checking for %s in the db\n", subdomain)
		isValidHex := bson.IsObjectIdHex(subdomain)
		if isValidHex == true {
			bao, err := model.GetBaoById(subdomain)
			if err != nil {
				http.Error(w, err.Error(), http.StatusBadRequest)
				return
			}
			fmt.Println(bao)
			destinations[bao.ID.Hex()] = bao.FunctionName
			functionName = bao.FunctionName
		}
	}

	if functionName == "" {
		http.Error(w, host+" not found", http.StatusNotFound)
		return
	}

	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		handlerError(err, w)
		return
	}
	var args Args

	args.Body = string(body)

	newHeaders := make(map[string]string)
	for name, content := range r.Header {
		if len(content) > 0 {
			newHeaders[name] = content[0]
		}
	}

	newHeaders["Host"] = r.Host

	args.Headers = newHeaders
	args.Method = r.Method
	args.Path = r.URL.RequestURI()

	reqeust, err := json.Marshal(args)
	if err != nil {
		handlerError(err, w)
		return
	}

	lambdaResponse, err := InvokeLambda(functionName, reqeust)
	if err != nil {
		handlerError(err, w)
		return
	}

	var response Response
	err = json.Unmarshal(lambdaResponse.Payload, &response)
	if err != nil {
		handlerError(err, w)
		return
	}

	for key, value := range response.Headers {
		w.Header().Del(key)
		w.Header().Add(key, value)
	}

	base64logs := fmt.Sprintf("%s", *lambdaResponse.LogResult)
	logdata, err := base64.StdEncoding.DecodeString(base64logs)

	if len(response.Headers) == 0 {
		// empty reponse
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte("Empty response, maybe there was an error?\n\nAWS Log output:\n\n"))
		w.Write(logdata)
		return
	}

	fmt.Printf("%#v\n", w.Header())
	fmt.Println(response)
	data, err := base64.StdEncoding.DecodeString(response.Body)
	if err != nil {
		handlerError(err, w)
		return
	}
	w.WriteHeader(response.StatusCode)
	w.Write(data)
}