apigatewayutils -> lambdautils, better name for MultiEventTypeHandler & move it to lambdautils

Author: joonas-fi

cmd/alertmanager/lambdahandler.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"github.com/aws/aws-lambda-go/events"
 	"github.com/aws/aws-lambda-go/lambda"
+	"github.com/function61/lambda-alertmanager/pkg/lambdautils"
 )
 
 func lambdaHandler() {
@@ -24,7 +25,7 @@ func lambdaHandler() {
 		return asJson, err
 	}
 
-	lambda.StartHandler(multiLambdaEventTypeDispatcher{func(ctx context.Context, polymorphicEvent interface{}) ([]byte, error) {
+	handler := func(ctx context.Context, polymorphicEvent interface{}) ([]byte, error) {
 		switch event := polymorphicEvent.(type) {
 		case *events.CloudWatchEvent:
 			return nil, handleCloudwatchScheduledEvent(ctx, event.Time)
@@ -37,5 +38,7 @@ func lambdaHandler() {
 		default:
 			return nil, errors.New("cannot identify type of request")
 		}
-	}})
+	}
+
+	lambda.StartHandler(lambdautils.NewMultiEventTypeHandler(handler))
 }

cmd/alertmanager/restapi.go

@@ -8,15 +8,15 @@ import (
 	"github.com/function61/gokit/jsonfile"
 	"github.com/function61/lambda-alertmanager/pkg/alertmanagertypes"
 	"github.com/function61/lambda-alertmanager/pkg/amstate"
-	"github.com/function61/lambda-alertmanager/pkg/apigatewayutils"
+	"github.com/function61/lambda-alertmanager/pkg/lambdautils"
 	"os"
 	"time"
 )
 
 func handleRestCall(ctx context.Context, req events.APIGatewayProxyRequest) (*events.APIGatewayProxyResponse, error) {
 	app, err := getApp(ctx)
 	if err != nil {
-		return apigatewayutils.InternalServerError(err.Error()), nil
+		return lambdautils.InternalServerError(err.Error()), nil
 	}
 
 	synopsis := req.HTTPMethod + " " + req.Path
@@ -29,26 +29,26 @@ func handleRestCall(ctx context.Context, req events.APIGatewayProxyRequest) (*ev
 		// pragmatic here because we want acks to be ack-able from emails
 		id := req.QueryStringParameters["id"]
 		if id == "" {
-			return apigatewayutils.BadRequest("id not specified"), nil
+			return lambdautils.BadRequest("id not specified"), nil
 		}
 
 		return handleAcknowledgeAlert(ctx, id)
 	case "POST /alerts/ingest":
 		alert := amstate.Alert{}
 		if err := jsonfile.Unmarshal(bytes.NewBufferString(req.Body), &alert, true); err != nil {
-			return apigatewayutils.BadRequest(err.Error()), nil
+			return lambdautils.BadRequest(err.Error()), nil
 		}
 		alert.Id = amstate.NewAlertId()
 
 		created, err := ingestAlertsAndReturnCreatedFlag(ctx, []amstate.Alert{alert}, app)
 		if err != nil {
-			return apigatewayutils.InternalServerError(err.Error()), nil
+			return lambdautils.InternalServerError(err.Error()), nil
 		}
 
 		if created {
-			return apigatewayutils.Created(), nil
+			return lambdautils.Created(), nil
 		} else {
-			return apigatewayutils.NoContent(), nil
+			return lambdautils.NoContent(), nil
 		}
 	case "GET /deadmansswitch/checkin": // /deadmansswitch/checkin?subject=ubackup_done&ttl=24h30m
 		// same semantic hack here as acknowledge endpoint
@@ -59,16 +59,16 @@ func handleRestCall(ctx context.Context, req events.APIGatewayProxyRequest) (*ev
 	case "POST /deadmansswitch/checkin": // {"subject":"ubackup_done","ttl":"24h30m"}
 		checkin := alertmanagertypes.DeadMansSwitchCheckinRequest{}
 		if err := jsonfile.Unmarshal(bytes.NewBufferString(req.Body), &checkin, true); err != nil {
-			return apigatewayutils.BadRequest(err.Error()), nil
+			return lambdautils.BadRequest(err.Error()), nil
 		}
 
 		return handleDeadMansSwitchCheckin(ctx, checkin)
 	case "GET /deadmansswitches":
 		return handleGetDeadMansSwitches(ctx, app)
 	case "POST /prometheus-alertmanager/api/v1/alerts":
-		return apigatewayutils.InternalServerError("not implemented yet"), nil
+		return lambdautils.InternalServerError("not implemented yet"), nil
 	default:
-		return apigatewayutils.BadRequest(fmt.Sprintf("unknown endpoint: %s", synopsis)), nil
+		return lambdautils.BadRequest(fmt.Sprintf("unknown endpoint: %s", synopsis)), nil
 	}
 }
 
@@ -77,46 +77,46 @@ func handleGetAlerts(
 	req events.APIGatewayProxyRequest,
 	app *amstate.App,
 ) (*events.APIGatewayProxyResponse, error) {
-	return apigatewayutils.RespondJson(app.State.ActiveAlerts())
+	return lambdautils.RespondJson(app.State.ActiveAlerts())
 }
 
 func handleAcknowledgeAlert(ctx context.Context, id string) (*events.APIGatewayProxyResponse, error) {
 	if err := alertAck(ctx, id); err != nil {
-		return apigatewayutils.InternalServerError(err.Error()), nil
+		return lambdautils.InternalServerError(err.Error()), nil
 	}
 
-	return apigatewayutils.OkText(fmt.Sprintf("Ack ok for %s", id))
+	return lambdautils.OkText(fmt.Sprintf("Ack ok for %s", id))
 }
 
 func handleGetDeadMansSwitches(
 	ctx context.Context,
 	app *amstate.App,
 ) (*events.APIGatewayProxyResponse, error) {
-	return apigatewayutils.RespondJson(app.State.DeadMansSwitches())
+	return lambdautils.RespondJson(app.State.DeadMansSwitches())
 }
 
 func handleDeadMansSwitchCheckin(ctx context.Context, raw alertmanagertypes.DeadMansSwitchCheckinRequest) (*events.APIGatewayProxyResponse, error) {
 	if raw.Subject == "" || raw.TTL == "" {
-		return apigatewayutils.BadRequest("subject or ttl empty"), nil
+		return lambdautils.BadRequest("subject or ttl empty"), nil
 	}
 
 	now := time.Now()
 
 	ttl, err := parseTtlSpec(raw.TTL, now)
 	if err != nil {
-		return apigatewayutils.BadRequest(err.Error()), nil
+		return lambdautils.BadRequest(err.Error()), nil
 	}
 
 	alertAcked, err := deadmansswitchCheckin(ctx, raw.Subject, ttl)
 	if err != nil {
-		return apigatewayutils.InternalServerError(err.Error()), nil
+		return lambdautils.InternalServerError(err.Error()), nil
 	}
 
 	if alertAcked {
-		return apigatewayutils.OkText("Check-in noted; alert that was firing for this dead mans's switch was acked")
+		return lambdautils.OkText("Check-in noted; alert that was firing for this dead mans's switch was acked")
 	}
 
-	return apigatewayutils.OkText("Check-in noted")
+	return lambdautils.OkText("Check-in noted")
 }
 
 func ackLink(alert amstate.Alert) string {

pkg/apigatewayutils/apigatewayutils.go renamed to pkg/lambdautils/apigatewayutils.go

@@ -1,4 +1,4 @@
-package apigatewayutils
+package lambdautils
 
 import (
 	"encoding/json"

cmd/alertmanager/multilambdaeventtypedispatcher.go renamed to pkg/lambdautils/multieventtypehandler.go

@@ -1,4 +1,4 @@
-package main
+package lambdautils
 
 // This design is not pretty.. https://stackoverflow.com/a/52572943
 
@@ -8,8 +8,29 @@ import (
 	"errors"
 	"fmt"
 	"github.com/aws/aws-lambda-go/events"
+	"github.com/aws/aws-lambda-go/lambda"
 )
 
+type multiEventTypeHandlerFn func(ctx context.Context, polymorphicEvent interface{}) ([]byte, error)
+
+type multiEventTypeHandler struct {
+	fn multiEventTypeHandlerFn
+}
+
+func NewMultiEventTypeHandler(fn multiEventTypeHandlerFn) lambda.Handler {
+	return &multiEventTypeHandler{fn}
+}
+
+func (m *multiEventTypeHandler) Invoke(ctx context.Context, reqRaw []byte) ([]byte, error) {
+	probe := &eventTypeProbe{}
+	polymorphicEvent, err := probe.IdentifyAndUnmarshal(reqRaw)
+	if err != nil {
+		return nil, err
+	}
+
+	return m.fn(ctx, polymorphicEvent)
+}
+
 // we introduce just enough fields to determine what type of trigger this is, so we can
 // deserialize JSON with proper type
 type eventTypeProbe struct {
@@ -63,17 +84,3 @@ func (e *eventTypeProbe) IdentifyAndUnmarshal(reqRaw []byte) (interface{}, error
 
 	return typeOfRequest, nil
 }
-
-type multiLambdaEventTypeDispatcher struct {
-	fn func(ctx context.Context, polymorphicEvent interface{}) ([]byte, error)
-}
-
-func (h multiLambdaEventTypeDispatcher) Invoke(ctx context.Context, reqRaw []byte) ([]byte, error) {
-	probe := &eventTypeProbe{}
-	polymorphicEvent, err := probe.IdentifyAndUnmarshal(reqRaw)
-	if err != nil {
-		return nil, err
-	}
-
-	return h.fn(ctx, polymorphicEvent)
-}