refactor command service to use one method per file (micromdm#416)

Updated the command service to have the same structure as all the other services within platform/...

Author: groob

cmd/micromdm/serve.go

@@ -217,18 +217,7 @@ func serve(args []string) error {
 		checkinHandlers = checkin.MakeHTTPHandlers(ctx, e, opts...)
 	}
 
-	var commandHandlers command.HTTPHandlers
-	{
-		e := command.Endpoints{
-			NewCommandEndpoint: command.MakeNewCommandEndpoint(sm.commandService),
-		}
-
-		opts := []httptransport.ServerOption{
-			httptransport.ServerErrorLogger(httpLogger),
-			httptransport.ServerErrorEncoder(connect.EncodeError),
-		}
-		commandHandlers = command.MakeHTTPHandlers(ctx, e, opts...)
-	}
+	commandEndpoints := command.MakeServerEndpoints(sm.commandService)
 
 	connectOpts := []httptransport.ServerOption{
 		httptransport.ServerErrorLogger(httpLogger),
@@ -325,6 +314,7 @@ func serve(args []string) error {
 	depHandlers := depapi.MakeHTTPHandler(depEndpoints, logger)
 	apnsHandlers := apns.MakeHTTPHandler(apnsEndpoints, logger)
 	depsyncHandlers := depsync.MakeHTTPHandler(depsyncEndpoints, logger)
+	commandHandler := command.MakeHTTPHandler(commandEndpoints, logger)
 
 	// API commands. Only handled if the user provides an api key.
 	if *flAPIKey != "" {
@@ -343,7 +333,7 @@ func serve(args []string) error {
 		r.Handle("/v1/dep/profiles", apiAuthMiddleware(*flAPIKey, depHandlers))
 		r.Handle("/v1/dep/syncnow", apiAuthMiddleware(*flAPIKey, depsyncHandlers))
 		r.Handle("/v1/dep/autoassigners", apiAuthMiddleware(*flAPIKey, depsyncHandlers))
-		r.Handle("/v1/commands", apiAuthMiddleware(*flAPIKey, commandHandlers.NewCommandHandler)).Methods("POST")
+		r.Handle("/v1/commands", apiAuthMiddleware(*flAPIKey, commandHandler))
 		r.Handle("/push/{udid}", apiAuthMiddleware(*flAPIKey, apnsHandlers))
 	} else {
 		mainLogger.Log("msg", "no api key specified")
@@ -478,7 +468,7 @@ func (c *server) setupCommandService() {
 	if c.err != nil {
 		return
 	}
-	c.commandService, c.err = command.New(c.db, c.pubclient)
+	c.commandService, c.err = command.New(c.pubclient)
 }
 
 func (c *server) setupWebhooks() {

platform/command/command.go

@@ -0,0 +1,71 @@
+package command
+
+import (
+	"net/http"
+
+	"github.com/go-kit/kit/endpoint"
+	"github.com/pkg/errors"
+	"golang.org/x/net/context"
+
+	"github.com/micromdm/micromdm/mdm/mdm"
+	"github.com/micromdm/micromdm/pkg/httputil"
+)
+
+const (
+	// CommandTopic is a PubSub topic that events are published to.
+	CommandTopic = "mdm.Command"
+)
+
+func (svc *CommandService) NewCommand(ctx context.Context, request *mdm.CommandRequest) (*mdm.CommandPayload, error) {
+	if request == nil {
+		return nil, errors.New("empty CommandRequest")
+	}
+	payload, err := mdm.NewCommandPayload(request)
+	if err != nil {
+		return nil, errors.Wrap(err, "creating mdm payload")
+	}
+	event := NewEvent(payload, request.UDID)
+	msg, err := MarshalEvent(event)
+	if err != nil {
+		return nil, errors.Wrap(err, "marshalling mdm command event")
+	}
+	if err := svc.publisher.Publish(context.TODO(), CommandTopic, msg); err != nil {
+		return nil, errors.Wrapf(err, "publish mdm command on topic: %s", CommandTopic)
+	}
+	return payload, nil
+}
+
+type newCommandRequest struct {
+	mdm.CommandRequest
+}
+
+type newCommandResponse struct {
+	Payload *mdm.CommandPayload `json:"payload,omitempty"`
+	Err     error               `json:"error,omitempty"`
+}
+
+func (r newCommandResponse) Failed() error   { return r.Err }
+func (r newCommandResponse) StatusCode() int { return http.StatusCreated }
+
+func decodeNewCommandRequest(ctx context.Context, r *http.Request) (interface{}, error) {
+	var req newCommandRequest
+	err := httputil.DecodeJSONRequest(r, &req)
+	return req, err
+}
+
+var errEmptyRequest = errors.New("request must contain UDID of the device")
+
+// MakeNewCommandEndpoint creates an endpoint which creates new MDM Commands.
+func MakeNewCommandEndpoint(svc Service) endpoint.Endpoint {
+	return func(ctx context.Context, request interface{}) (interface{}, error) {
+		req := request.(newCommandRequest)
+		if req.UDID == "" || req.RequestType == "" {
+			return newCommandResponse{Err: errEmptyRequest}, nil
+		}
+		payload, err := svc.NewCommand(ctx, &req.CommandRequest)
+		if err != nil {
+			return newCommandResponse{Err: err}, nil
+		}
+		return newCommandResponse{Payload: payload}, nil
+	}
+}

platform/command/endpoint.go

@@ -0,0 +1,34 @@
+package command
+
+import (
+	"github.com/go-kit/kit/endpoint"
+	"github.com/go-kit/kit/log"
+	httptransport "github.com/go-kit/kit/transport/http"
+	"github.com/gorilla/mux"
+	"github.com/micromdm/micromdm/pkg/httputil"
+)
+
+type Endpoints struct {
+	NewCommandEndpoint endpoint.Endpoint
+}
+
+func MakeServerEndpoints(s Service) Endpoints {
+	return Endpoints{
+		NewCommandEndpoint: MakeNewCommandEndpoint(s),
+	}
+}
+
+func MakeHTTPHandler(e Endpoints, logger log.Logger) *mux.Router {
+	r, options := httputil.NewRouter(logger)
+
+	// POST     /v1/commands		Add new MDM Command to device queue.
+
+	r.Methods("POST").Path("/v1/commands").Handler(httptransport.NewServer(
+		e.NewCommandEndpoint,
+		decodeNewCommandRequest,
+		httputil.EncodeJSONResponse,
+		options...,
+	))
+
+	return r
+}

platform/command/new_command.go

@@ -2,66 +2,22 @@
 package command
 
 import (
-	"time"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/metrics"
 	"github.com/micromdm/micromdm/mdm/mdm"
+	"github.com/micromdm/micromdm/platform/pubsub"
 	"golang.org/x/net/context"
 )
 
 type Service interface {
 	NewCommand(context.Context, *mdm.CommandRequest) (*mdm.CommandPayload, error)
 }
 
-// Middleware describes a service (as opposed to endpoint) middleware.
-type Middleware func(Service) Service
-
-// ServiceLoggingMiddleware returns a service middleware that logs the
-// parameters and result of each method invocation.
-func ServiceLoggingMiddleware(logger log.Logger) Middleware {
-	return func(next Service) Service {
-		return serviceLoggingMiddleware{
-			logger: logger,
-			next:   next,
-		}
-	}
-}
-
-func (mw serviceLoggingMiddleware) NewCommand(ctx context.Context, req *mdm.CommandRequest) (p *mdm.CommandPayload, err error) {
-	defer func(begin time.Time) {
-		mw.logger.Log(
-			"method", "NewCommand",
-			"error", err,
-			"took", time.Since(begin),
-		)
-	}(time.Now())
-	return mw.next.NewCommand(ctx, req)
+type CommandService struct {
+	publisher pubsub.Publisher
 }
 
-type serviceLoggingMiddleware struct {
-	logger log.Logger
-	next   Service
-}
-
-// ServiceInstrumentingMiddleware returns a service middleware that tracks the
-// number of payloads created by the service.
-func ServiceInstrumentingMiddleware(p metrics.Counter) Middleware {
-	return func(next Service) Service {
-		return serviceInstrumentingMiddleware{
-			payloads: p,
-			next:     next,
-		}
+func New(pub pubsub.Publisher) (*CommandService, error) {
+	svc := CommandService{
+		publisher: pub,
 	}
-}
-
-type serviceInstrumentingMiddleware struct {
-	payloads metrics.Counter
-	next     Service
-}
-
-func (mw serviceInstrumentingMiddleware) NewCommand(ctx context.Context, req *mdm.CommandRequest) (*mdm.CommandPayload, error) {
-	p, err := mw.next.NewCommand(ctx, req)
-	mw.payloads.Add(1)
-	return p, err
+	return &svc, nil
 }