Initial refactoring

cmd/metal-api/internal/datastore/event.go

@@ -1,7 +1,11 @@
 package datastore
 
 import (
+	"fmt"
+	"time"
+
 	"github.com/metal-stack/metal-api/cmd/metal-api/internal/metal"
+	"github.com/metal-stack/metal-lib/zapup"
 )
 
 // ListProvisioningEventContainers returns all machine provisioning event containers.
@@ -35,3 +39,67 @@ func (rs *RethinkStore) CreateProvisioningEventContainer(ec *metal.ProvisioningE
 func (rs *RethinkStore) UpsertProvisioningEventContainer(ec *metal.ProvisioningEventContainer) error {
 	return rs.upsertEntity(rs.eventTable(), ec)
 }
+
+func (rs *RethinkStore) EvaluateMachineLiveliness(m metal.Machine) (metal.MachineLiveliness, error) {
+	provisioningEvents, err := rs.FindProvisioningEventContainer(m.ID)
+	if err != nil {
+		// we have no provisioning events... we cannot tell
+		return metal.MachineLivelinessUnknown, fmt.Errorf("no provisioningEvents found for ID: %s", m.ID)
+	}
+
+	old := *provisioningEvents
+
+	if provisioningEvents.LastEventTime != nil {
+		if time.Since(*provisioningEvents.LastEventTime) > metal.MachineDeadAfter {
+			if m.Allocation != nil {
+				// the machine is either dead or the customer did turn off the phone home service
+				provisioningEvents.Liveliness = metal.MachineLivelinessUnknown
+			} else {
+				// the machine is just dead
+				provisioningEvents.Liveliness = metal.MachineLivelinessDead
+			}
+		} else {
+			provisioningEvents.Liveliness = metal.MachineLivelinessAlive
+		}
+		err = rs.UpdateProvisioningEventContainer(&old, provisioningEvents)
+		if err != nil {
+			return provisioningEvents.Liveliness, err
+		}
+	}
+
+	return provisioningEvents.Liveliness, nil
+}
+
+func (rs *RethinkStore) ProvisioningEventForMachine(machineID string, event metal.ProvisioningEvent) (*metal.ProvisioningEventContainer, error) {
+	ec, err := rs.FindProvisioningEventContainer(machineID)
+	if err != nil && !metal.IsNotFound(err) {
+		return nil, err
+	}
+
+	if ec == nil {
+		ec = &metal.ProvisioningEventContainer{
+			Base: metal.Base{
+				ID: machineID,
+			},
+			Liveliness: metal.MachineLivelinessAlive,
+		}
+	}
+	now := time.Now()
+	ec.LastEventTime = &now
+
+	if event.Event == metal.ProvisioningEventAlive {
+		zapup.MustRootLogger().Sugar().Debugw("received provisioning alive event", "id", ec.ID)
+		ec.Liveliness = metal.MachineLivelinessAlive
+	} else if event.Event == metal.ProvisioningEventPhonedHome && len(ec.Events) > 0 && ec.Events[0].Event == metal.ProvisioningEventPhonedHome {
+		zapup.MustRootLogger().Sugar().Debugw("swallowing repeated phone home event", "id", ec.ID)
+		ec.Liveliness = metal.MachineLivelinessAlive
+	} else {
+		ec.Events = append([]metal.ProvisioningEvent{event}, ec.Events...)
+		ec.IncompleteProvisioningCycles = ec.CalculateIncompleteCycles(zapup.MustRootLogger().Sugar())
+		ec.Liveliness = metal.MachineLivelinessAlive
+	}
+	ec.TrimEvents(metal.ProvisioningEventsInspectionLimit)
+
+	err = rs.UpsertProvisioningEventContainer(ec)
+	return ec, err
+}

cmd/metal-api/internal/service/machine-service.go

@@ -307,27 +307,6 @@ func (r machineResource) webService() *restful.WebService {
 		Returns(http.StatusOK, "OK", v1.BootInfo{}).
 		DefaultReturns("Error", httperrors.HTTPErrorResponse{}))
 
-	ws.Route(ws.GET("/{id}/event").
-		To(viewer(r.getProvisioningEventContainer)).
-		Operation("getProvisioningEventContainer").
-		Doc("get the current machine provisioning event container").
-		Param(ws.PathParameter("id", "identifier of the machine").DataType("string")).
-		Metadata(restfulspec.KeyOpenAPITags, tags).
-		Writes(v1.MachineRecentProvisioningEvents{}).
-		Returns(http.StatusOK, "OK", v1.MachineRecentProvisioningEvents{}).
-		DefaultReturns("Error", httperrors.HTTPErrorResponse{}))
-
-	ws.Route(ws.POST("/{id}/event").
-		To(editor(r.addProvisioningEvent)).
-		Operation("addProvisioningEvent").
-		Doc("adds a machine provisioning event").
-		Param(ws.PathParameter("id", "identifier of the machine").DataType("string")).
-		Metadata(restfulspec.KeyOpenAPITags, tags).
-		Reads(v1.MachineProvisioningEvent{}).
-		Writes(v1.MachineRecentProvisioningEvents{}).
-		Returns(http.StatusOK, "OK", v1.MachineRecentProvisioningEvents{}).
-		DefaultReturns("Error", httperrors.HTTPErrorResponse{}))
-
 	ws.Route(ws.POST("/{id}/power/on").
 		To(editor(r.machineOn)).
 		Operation("machineOn").
@@ -1691,8 +1670,13 @@ func (r machineResource) freeMachine(request *restful.Request, response *restful
 		logger.Error("Failed to send response", zap.Error(err))
 	}
 
-	event := string(metal.ProvisioningEventPlannedReboot)
-	_, err = r.provisioningEventForMachine(id, v1.MachineProvisioningEvent{Time: time.Now(), Event: event, Message: "freeMachine"})
+	event := metal.ProvisioningEvent{
+		Time:    time.Now(),
+		Event:   metal.ProvisioningEventPlannedReboot,
+		Message: "freeMachine",
+	}
+
+	_, err = r.ds.ProvisioningEventForMachine(id, event)
 	if checkError(request, response, utils.CurrentFuncName(), err) {
 		return
 	}
@@ -1918,112 +1902,6 @@ func publishDeleteEvent(publisher bus.Publisher, m *metal.Machine, logger *zap.L
 	return nil
 }
 
-func (r machineResource) getProvisioningEventContainer(request *restful.Request, response *restful.Response) {
-	id := request.PathParameter("id")
-
-	// check for existence of the machine
-	_, err := r.ds.FindMachineByID(id)
-	if checkError(request, response, utils.CurrentFuncName(), err) {
-		return
-	}
-
-	ec, err := r.ds.FindProvisioningEventContainer(id)
-	if checkError(request, response, utils.CurrentFuncName(), err) {
-		return
-	}
-	err = response.WriteHeaderAndEntity(http.StatusOK, v1.NewMachineRecentProvisioningEvents(ec))
-	if err != nil {
-		zapup.MustRootLogger().Error("Failed to send response", zap.Error(err))
-		return
-	}
-}
-
-func (r machineResource) addProvisioningEvent(request *restful.Request, response *restful.Response) {
-	id := request.PathParameter("id")
-	m, err := r.ds.FindMachineByID(id)
-	if err != nil && !metal.IsNotFound(err) {
-		if checkError(request, response, utils.CurrentFuncName(), err) {
-			return
-		}
-	}
-
-	// an event can actually create an empty machine. This enables us to also catch the very first PXE Booting event
-	// in a machine lifecycle
-	if m == nil {
-		m = &metal.Machine{
-			Base: metal.Base{
-				ID: id,
-			},
-		}
-		err = r.ds.CreateMachine(m)
-		if checkError(request, response, utils.CurrentFuncName(), err) {
-			return
-		}
-	}
-
-	var requestPayload v1.MachineProvisioningEvent
-	err = request.ReadEntity(&requestPayload)
-	if checkError(request, response, utils.CurrentFuncName(), err) {
-		return
-	}
-	ok := metal.AllProvisioningEventTypes[metal.ProvisioningEventType(requestPayload.Event)]
-	if !ok {
-		if checkError(request, response, utils.CurrentFuncName(), errors.New("unknown provisioning event")) {
-			return
-		}
-	}
-
-	ec, err := r.provisioningEventForMachine(id, requestPayload)
-	if checkError(request, response, utils.CurrentFuncName(), err) {
-		return
-	}
-
-	err = response.WriteHeaderAndEntity(http.StatusOK, v1.NewMachineRecentProvisioningEvents(ec))
-	if err != nil {
-		zapup.MustRootLogger().Error("Failed to send response", zap.Error(err))
-		return
-	}
-}
-
-func (r machineResource) provisioningEventForMachine(machineID string, e v1.MachineProvisioningEvent) (*metal.ProvisioningEventContainer, error) {
-	ec, err := r.ds.FindProvisioningEventContainer(machineID)
-	if err != nil && !metal.IsNotFound(err) {
-		return nil, err
-	}
-
-	if ec == nil {
-		ec = &metal.ProvisioningEventContainer{
-			Base: metal.Base{
-				ID: machineID,
-			},
-			Liveliness: metal.MachineLivelinessAlive,
-		}
-	}
-	now := time.Now()
-	ec.LastEventTime = &now
-
-	event := metal.ProvisioningEvent{
-		Time:    now,
-		Event:   metal.ProvisioningEventType(e.Event),
-		Message: e.Message,
-	}
-	if event.Event == metal.ProvisioningEventAlive {
-		zapup.MustRootLogger().Sugar().Debugw("received provisioning alive event", "id", ec.ID)
-		ec.Liveliness = metal.MachineLivelinessAlive
-	} else if event.Event == metal.ProvisioningEventPhonedHome && len(ec.Events) > 0 && ec.Events[0].Event == metal.ProvisioningEventPhonedHome {
-		zapup.MustRootLogger().Sugar().Debugw("swallowing repeated phone home event", "id", ec.ID)
-		ec.Liveliness = metal.MachineLivelinessAlive
-	} else {
-		ec.Events = append([]metal.ProvisioningEvent{event}, ec.Events...)
-		ec.IncompleteProvisioningCycles = ec.CalculateIncompleteCycles(zapup.MustRootLogger().Sugar())
-		ec.Liveliness = metal.MachineLivelinessAlive
-	}
-	ec.TrimEvents(metal.ProvisioningEventsInspectionLimit)
-
-	err = r.ds.UpsertProvisioningEventContainer(ec)
-	return ec, err
-}
-
 // MachineLiveliness evaluates whether machines are still alive or if they have died
 func MachineLiveliness(ds *datastore.RethinkStore, logger *zap.SugaredLogger) error {
 	logger.Info("machine liveliness was requested")
@@ -2041,7 +1919,7 @@ func MachineLiveliness(ds *datastore.RethinkStore, logger *zap.SugaredLogger) er
 	errs := 0
 	for _, m := range machines {
 		p := liveliness[m.PartitionID]
-		lvlness, err := evaluateMachineLiveliness(ds, m)
+		lvlness, err := ds.EvaluateMachineLiveliness(m)
 		if err != nil {
 			logger.Errorw("cannot update liveliness", "error", err, "machine", m)
 			errs++
@@ -2068,36 +1946,6 @@ func MachineLiveliness(ds *datastore.RethinkStore, logger *zap.SugaredLogger) er
 	return nil
 }
 
-func evaluateMachineLiveliness(ds *datastore.RethinkStore, m metal.Machine) (metal.MachineLiveliness, error) {
-	provisioningEvents, err := ds.FindProvisioningEventContainer(m.ID)
-	if err != nil {
-		// we have no provisioning events... we cannot tell
-		return metal.MachineLivelinessUnknown, fmt.Errorf("no provisioningEvents found for ID: %s", m.ID)
-	}
-
-	old := *provisioningEvents
-
-	if provisioningEvents.LastEventTime != nil {
-		if time.Since(*provisioningEvents.LastEventTime) > metal.MachineDeadAfter {
-			if m.Allocation != nil {
-				// the machine is either dead or the customer did turn off the phone home service
-				provisioningEvents.Liveliness = metal.MachineLivelinessUnknown
-			} else {
-				// the machine is just dead
-				provisioningEvents.Liveliness = metal.MachineLivelinessDead
-			}
-		} else {
-			provisioningEvents.Liveliness = metal.MachineLivelinessAlive
-		}
-		err = ds.UpdateProvisioningEventContainer(&old, provisioningEvents)
-		if err != nil {
-			return provisioningEvents.Liveliness, err
-		}
-	}
-
-	return provisioningEvents.Liveliness, nil
-}
-
 // ResurrectMachines attempts to resurrect machines that are obviously dead
 func ResurrectMachines(ds *datastore.RethinkStore, publisher bus.Publisher, ep *bus.Endpoints, ipamer ipam.IPAMer, logger *zap.SugaredLogger) error {
 	logger.Info("machine resurrection was requested")
@@ -2243,8 +2091,12 @@ func (r machineResource) machineCmd(op string, cmd metal.MachineCommand, request
 
 	switch op {
 	case "machineReset", "machineOff", "machineCycle":
-		event := string(metal.ProvisioningEventPlannedReboot)
-		_, err = r.provisioningEventForMachine(id, v1.MachineProvisioningEvent{Time: time.Now(), Event: event, Message: op})
+		event := metal.ProvisioningEvent{
+			Time:    time.Now(),
+			Event:   metal.ProvisioningEventPlannedReboot,
+			Message: op,
+		}
+		_, err = r.ds.ProvisioningEventForMachine(id, event)
 		if checkError(request, response, utils.CurrentFuncName(), err) {
 			return
 		}

cmd/metal-api/internal/service/machine-service_test.go

@@ -622,41 +622,6 @@ func TestSearchMachine(t *testing.T) {
 	require.Equal(t, testdata.Partition1.Name, *result.Partition.Name)
 }
 
-func TestAddProvisioningEvent(t *testing.T) {
-	ds, mock := datastore.InitMockDB()
-	testdata.InitMockDBData(mock)
-
-	machineservice, err := NewMachine(ds, &emptyPublisher{}, bus.DirectEndpoints(), ipam.New(goipam.New()), nil, nil, nil, nil, 0)
-	require.NoError(t, err)
-
-	container := restful.NewContainer().Add(machineservice)
-	event := &metal.ProvisioningEvent{
-		Event:   metal.ProvisioningEventPreparing,
-		Message: "starting metal-hammer",
-	}
-	js, _ := json.Marshal(event)
-	body := bytes.NewBuffer(js)
-	req := httptest.NewRequest("POST", "/v1/machine/1/event", body)
-	container = injectEditor(container, req)
-	req.Header.Add("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-	container.ServeHTTP(w, req)
-
-	resp := w.Result()
-	defer resp.Body.Close()
-	require.Equal(t, http.StatusOK, resp.StatusCode, w.Body.String())
-	var result v1.MachineRecentProvisioningEvents
-	err = json.NewDecoder(resp.Body).Decode(&result)
-
-	require.Nil(t, err)
-	require.Equal(t, "0", result.IncompleteProvisioningCycles)
-	require.Len(t, result.Events, 1)
-	if len(result.Events) > 0 {
-		require.Equal(t, "starting metal-hammer", result.Events[0].Message)
-		require.Equal(t, string(metal.ProvisioningEventPreparing), result.Events[0].Event)
-	}
-}
-
 func TestOnMachine(t *testing.T) {
 	tests := []struct {
 		cmd      metal.MachineCommand

cmd/metal-api/main.go

@@ -705,7 +705,10 @@ func initRestServices(withauth bool) *restfulspec.Config {
 	if err != nil {
 		logger.Fatal(err)
 	}
-
+	eventService, err := service.NewEvent(ds, mdc, userGetter)
+	if err != nil {
+		logger.Fatal(err)
+	}
 	restful.DefaultContainer.Add(service.NewPartition(ds, nsqer))
 	restful.DefaultContainer.Add(service.NewImage(ds))
 	restful.DefaultContainer.Add(service.NewSize(ds))
@@ -720,6 +723,7 @@ func initRestServices(withauth bool) *restfulspec.Config {
 	restful.DefaultContainer.Add(service.NewFilesystemLayout(ds))
 	restful.DefaultContainer.Add(service.NewSwitch(ds))
 	restful.DefaultContainer.Add(healthService)
+	restful.DefaultContainer.Add(eventService)
 	restful.DefaultContainer.Add(rest.NewVersion(moduleName, service.BasePath))
 	restful.DefaultContainer.Filter(rest.RequestLogger(debug, lg))
 	restful.DefaultContainer.Filter(metrics.RestfulMetrics)