deploy: container history

daemon/inertiad/daemon/up.go

@@ -97,10 +97,11 @@ func (s *Server) upHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// Update container management history
-	s.deployment.UpdateContainerHistory(s.docker)
-
-	logger.WriteSuccess("Project startup initiated!", http.StatusCreated)
+	// Update container management history following a successful build and deployment
+	err := s.deployment.UpdateContainerHistory(s.docker)
+	if err != nil {
+		stream.Error(res.ErrInternalServer("failed to update container history following build", err))
+	}
 
 	stream.Success(res.Msg("Project startup initiated!", http.StatusCreated))
 

daemon/inertiad/project/data.go

@@ -7,15 +7,16 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
+	"time"
 
 	"github.com/ubclaunchpad/inertia/daemon/inertiad/crypto"
 	bolt "go.etcd.io/bbolt"
 )
 
 var (
 	// database buckets
-	envVariableBucket     = []byte("envVariables")
-	builtContainersBucket = []byte("builtContainers")
+	envVariableBucket      = []byte("envVariables")
+	deployedProjectsBucket = []byte("deployedProjects")
 )
 
 // DeploymentDataManager stores persistent deployment configuration
@@ -51,7 +52,7 @@ func NewDataManager(dbPath string, keyPath string) (*DeploymentDataManager, erro
 	}
 	if err = db.Update(func(tx *bolt.Tx) error {
 		_, err := tx.CreateBucketIfNotExists(envVariableBucket)
-		_, err = tx.CreateBucketIfNotExists(builtContainersBucket)
+		_, err = tx.CreateBucketIfNotExists(deployedProjectsBucket)
 		return err
 	}); err != nil {
 		return nil, fmt.Errorf("failed to instantiate database: %s", err.Error())
@@ -139,11 +140,46 @@ func (c *DeploymentDataManager) GetEnvVariables(decrypt bool) ([]string, error)
 	return envs, err
 }
 
-// AddBuiltContainer stores and tracks metadata from successful builds
-func (c *DeploymentDataManager) AddBuiltContainer(commitHash string, containerID string) error {
+// AddProjectBuildData stores and tracks metadata from successful builds
+// TODO: definitely need to add more context to errors
+func (c *DeploymentDataManager) AddProjectBuildData(projectName string, mdata DeploymentMetadata) error {
+	// encode metadata so it can be stored as byte array
+	encodedMdata, err := json.Marshal(mdata)
+	if err != nil {
+		return err
+	}
 	return c.db.Update(func(tx *bolt.Tx) error {
-		containersBucket := tx.Bucket(builtContainersBucket)
-		return containersBucket.Put([]byte(commitHash), []byte(containerID))
+		deployedProjectsBucket := tx.Bucket(deployedProjectsBucket)
+		// if bkt with project name doesnt exist create new bkt, otherwise update existing bucket
+		if projectBkt := deployedProjectsBucket.Bucket([]byte(projectName)); projectBkt == nil {
+			projectBkt, err := deployedProjectsBucket.CreateBucket([]byte(projectName))
+			if err != nil {
+				return err
+			}
+
+			if err := projectBkt.Put([]byte(time.Now().String()), encodedMdata); err != nil {
+				return err
+			}
+		} else {
+			if err := c.UpdateProjectBuildData(projectName, encodedMdata); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}
+
+// UpdateProjectBuildData updates existing project bkt with recent build's metadata
+func (c *DeploymentDataManager) UpdateProjectBuildData(projectName string, mdata []byte) error {
+	return c.db.Update(func(tx *bolt.Tx) error {
+		deployedProjectsBucket := tx.Bucket(deployedProjectsBucket)
+		projectBkt := deployedProjectsBucket.Bucket([]byte(projectName))
+
+		if err := projectBkt.Put([]byte(time.Now().String()), mdata); err != nil {
+			return err
+		}
+
+		return nil
 	})
 }
 

daemon/inertiad/project/data_test.go

@@ -65,36 +65,36 @@ func TestDataManager_EnvVariableOperations(t *testing.T) {
 	}
 }
 
-// func TestDataManager_builtContainerOperations(t *testing.T) {
-// 	type args struct {
-// 		commitHash string
-// 		date       string
-// 	}
-// 	tests := []struct {
-// 		name    string
-// 		args    args
-// 		wantErr bool
-// 	}{
-// 		{"valid build", args{"hash", "2:20pm"}, false},
-// 	}
-// 	for _, tt := range tests {
-// 		t.Run(tt.name, func(t *testing.T) {
-// 			dir := "./test_config"
-// 			err := os.Mkdir(dir, os.ModePerm)
-// 			assert.Nil(t, err)
-// 			defer os.RemoveAll(dir)
+func TestDataManager_ProjectBuildDataOperations(t *testing.T) {
+	type args struct {
+		projectName string
+		metadata    DeploymentMetadata
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{"valid project build", args{"projectA", DeploymentMetadata{"hash", "ID", "status", "time"}}, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dir := "./test_config"
+			err := os.Mkdir(dir, os.ModePerm)
+			assert.Nil(t, err)
+			defer os.RemoveAll(dir)
 
-// 			// // Instantiate
-// 			// c, err := NewDataManager(path.Join(dir, "deployment.db"), path.Join(dir, "key"))
-// 			// assert.Nil(t, err)
+			// Instantiate
+			c, err := NewDataManager(path.Join(dir, "deployment.db"), path.Join(dir, "key"))
+			assert.Nil(t, err)
 
-// 			// // Add
-// 			// err = c.AddBuiltContainer(tt.args.commitHash, tt.args.date)
-// 			// assert.Equal(t, tt.wantErr, (err != nil))
+			// Add
+			err = c.AddProjectBuildData(tt.args.projectName, tt.args.metadata)
+			assert.Equal(t, tt.wantErr, (err != nil))
 
-// 		})
-// 	}
-// }
+		})
+	}
+}
 
 func TestDataManager_destroy(t *testing.T) {
 	dir := "./test_config"

daemon/inertiad/project/deployment.go

@@ -36,6 +36,8 @@ type Deployer interface {
 	GetBranch() string
 	CompareRemotes(string) error
 
+	UpdateContainerHistory(cli *docker.Client) error
+
 	GetDataManager() (*DeploymentDataManager, bool)
 
 	Watch(*docker.Client) (<-chan string, <-chan error)
@@ -70,6 +72,15 @@ type DeploymentConfig struct {
 	PemFilePath   string
 }
 
+// DeploymentMetadata is used to store metadata relevant
+// to the most recent deployment
+type DeploymentMetadata struct {
+	Hash            string
+	ContainerID     string
+	ContainerStatus string
+	StartedAt       string
+}
+
 // NewDeployment creates a new deployment
 func NewDeployment(
 	projectDirectory string,
@@ -317,25 +328,49 @@ func (d *Deployment) CompareRemotes(remoteURL string) error {
 // UpdateContainerHistory will update container bucket with recent build's
 // metadata
 func (d *Deployment) UpdateContainerHistory(cli *docker.Client) error {
-	// Retrieve container ID for recently deployed project
+
+	// Get project hash
+	head, err := d.repo.Head()
+	if err != nil {
+		return err
+	}
+	// Retrieve container for recently deployed project
 	ctx := context.Background()
-	var containerID string
+	var recentlyBuiltContainer types.Container
 	containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
 	if err != nil {
 		return err
 	}
 	for _, container := range containers {
 		if container.Names[0] == d.project {
-			containerID = container.ID
+			recentlyBuiltContainer = container
 		}
 	}
-	// Retrieve project hash
-	head, err := d.repo.Head()
+
+	// Get container metadata
+	var containerID string
+	if len(recentlyBuiltContainer.ID) > 0 {
+		containerID = recentlyBuiltContainer.ID
+	}
+	containerJSON, err := cli.ContainerInspect(ctx, containerID)
 	if err != nil {
-		return err
+		return err // TODO: Add more context to error
+	}
+	containerState := containerJSON.ContainerJSONBase.State // similar to running "docker inspect {container}"
+	var containerStatus, containerStartedAtTime string
+	if containerState != nil {
+		containerStatus = containerState.Status
+		containerStartedAtTime = containerState.StartedAt
 	}
+
+	metadata := DeploymentMetadata{
+		Hash:            head.Hash().String(),
+		ContainerID:     containerID,
+		ContainerStatus: containerStatus,
+		StartedAt:       containerStartedAtTime}
+
 	// Update db with newly built container metadata
-	d.dataManager.AddBuiltContainer(head.Hash().String(), containerID)
+	d.dataManager.AddProjectBuildData(d.project, metadata)
 
 	return err
 }