[WIP]

api.go

@@ -82,7 +82,7 @@ func (server *Server) StartServer() error {
 
 	router.GET("/state/:runId", server.state)
 
-	jobManager, err := jobs.NewJobManager(server.Config)
+	jobManager, err := jobs.NewJobManager(server.Config, server.ConfigDB)
 	if err != nil {
 		return errors.New("Unable to create job manager: " + err.Error())
 	}

clients/deployer.go

@@ -360,24 +360,74 @@ func (client *DeployerClient) DeleteDeployment(deploymentId string, log *logging
 }
 
 func (client *DeployerClient) CreateDeployment(
+	deployment *deployer.Deployment,
+	loadTesterName string,
+	log *logging.Logger) (string, error) {
+	requestUrl := UrlBasePath(client.Url) + path.Join(
+		client.Url.Path, "v1", "deployments")
+
+	response, err := resty.R().SetBody(deployment).Post(requestUrl)
+	if err != nil {
+		return "", err
+	}
+
+	if response.StatusCode() != 202 {
+		return "", fmt.Errorf("Invalid status code returned %d: %s", response.StatusCode(), response.String())
+	}
+
+	var createResponse struct {
+		Error        bool   `json:"error"`
+		Data         string `json:"data`
+		DeploymentId string `json:"deploymentId`
+	}
+
+	if err := json.Unmarshal(response.Body(), &createResponse); err != nil {
+		return "", errors.New("Unable to parse failed create deployment response: " + err.Error())
+	}
+
+	log.Debugf("Received deployer response: %+v", createResponse)
+	if createResponse.Error {
+		return "", errors.New("Unable to create deployment: " + createResponse.Data)
+	}
+
+	deploymentId := createResponse.DeploymentId
+	if deploymentId == "" {
+		return "", errors.New("Unable to get deployment id")
+	}
+
+	log.Infof("Waiting for deployment %s to be available...", deploymentId)
+	if err := client.waitUntilDeploymentStateAvailable(deploymentId, log); err != nil {
+		return "", errors.New("Unable to waiting for deployment state to be available: " + err.Error())
+	}
+
+	log.Infof("Waiting for load tester %s service url to be available...", loadTesterName)
+	if err := client.waitUntilServiceUrlAvailable(deploymentId, loadTesterName, log); err != nil {
+		return "", fmt.Errorf("Unable to waiting for %s url to be available: %s", loadTesterName, err)
+	}
+
+	return deploymentId, nil
+}
+
+func (client *DeployerClient) CreateDeploymentWithTemplate(
 	deploymentTemplate string,
 	deployment *deployer.Deployment,
 	loadTesterName string,
-	log *logging.Logger) (*string, error) {
+	log *logging.Logger) (string, error) {
+
 	if deploymentTemplate == "" {
-		return nil, errors.New("Empty deployment template found")
+		return "", errors.New("Empty deployment template found")
 	}
 
 	requestUrl := UrlBasePath(client.Url) + path.Join(
 		client.Url.Path, "v1", "templates", deploymentTemplate, "deployments")
 
 	response, err := resty.R().SetBody(deployment).Post(requestUrl)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
 
 	if response.StatusCode() != 202 {
-		return nil, fmt.Errorf("Invalid status code returned %d: %s", response.StatusCode(), response.String())
+		return "", fmt.Errorf("Invalid status code returned %d: %s", response.StatusCode(), response.String())
 	}
 
 	var createResponse struct {
@@ -387,30 +437,30 @@ func (client *DeployerClient) CreateDeployment(
 	}
 
 	if err := json.Unmarshal(response.Body(), &createResponse); err != nil {
-		return nil, errors.New("Unable to parse failed create deployment response: " + err.Error())
+		return "", errors.New("Unable to parse failed create deployment response: " + err.Error())
 	}
 
 	log.Debugf("Received deployer response: %+v", createResponse)
 	if createResponse.Error {
-		return nil, errors.New("Unable to create deployment: " + createResponse.Data)
+		return "", errors.New("Unable to create deployment: " + createResponse.Data)
 	}
 
 	deploymentId := createResponse.DeploymentId
 	if deploymentId == "" {
-		return nil, errors.New("Unable to get deployment id")
+		return "", errors.New("Unable to get deployment id")
 	}
 
 	log.Infof("Waiting for deployment %s to be available...", deploymentId)
 	if err := client.waitUntilDeploymentStateAvailable(deploymentId, log); err != nil {
-		return nil, errors.New("Unable to waiting for deployment state to be available: " + err.Error())
+		return "", errors.New("Unable to waiting for deployment state to be available: " + err.Error())
 	}
 
 	log.Infof("Waiting for load tester %s service url to be available...", loadTesterName)
 	if err := client.waitUntilServiceUrlAvailable(deploymentId, loadTesterName, log); err != nil {
-		return nil, fmt.Errorf("Unable to waiting for %s url to be available: %s", loadTesterName, err)
+		return "", fmt.Errorf("Unable to waiting for %s url to be available: %s", loadTesterName, err)
 	}
 
-	return &deploymentId, nil
+	return deploymentId, nil
 }
 
 func (client *DeployerClient) waitUntilServiceUrlAvailable(

clients/influx_client.go

@@ -1,7 +1,6 @@
 package clients
 
 import (
-	"bytes"
 	"fmt"
 	"os/exec"
 )

db/db.go

@@ -8,6 +8,7 @@ import (
 	"gopkg.in/mgo.v2/bson"
 
 	"github.com/golang/glog"
+	deployer "github.com/hyperpilotio/deployer/apis"
 	"github.com/hyperpilotio/workload-profiler/models"
 	"github.com/spf13/viper"
 )
@@ -19,6 +20,7 @@ type ConfigDB struct {
 	Database                     string
 	ApplicationsCollection       string
 	BenchmarksCollection         string
+	DeploymentCollection         string
 	NodeTypeCollection           string
 	PreviousGenerationCollection string
 }
@@ -44,6 +46,7 @@ func NewConfigDB(config *viper.Viper) *ConfigDB {
 		BenchmarksCollection:         config.GetString("database.benchmarkCollection"),
 		NodeTypeCollection:           config.GetString("database.nodeTypeCollection"),
 		PreviousGenerationCollection: config.GetString("database.previousGenerationCollection"),
+		DeploymentCollection:         config.GetString("database.deploymentCollection"),
 	}
 }
 
@@ -79,6 +82,23 @@ func (configDb *ConfigDB) GetApplicationConfig(name string) (*models.Application
 	return &appConfig, nil
 }
 
+func (configDb *ConfigDB) GetDeploymentConfig(name string) (*deployer.Deployment, error) {
+	session, sessionErr := connectMongo(configDb.Url, configDb.Database, configDb.User, configDb.Password)
+	if sessionErr != nil {
+		return nil, errors.New("Unable to create mongo session: " + sessionErr.Error())
+	}
+	glog.V(1).Infof("Successfully connected to the config DB for deployment %s", name)
+	defer session.Close()
+
+	collection := session.DB(configDb.Database).C(configDb.DeploymentCollection)
+	var deployment deployer.Deployment
+	if err := collection.Find(bson.M{"name": name}).One(&deployment); err != nil {
+		return nil, errors.New("Unable to find deployment config from db: " + err.Error())
+	}
+
+	return &deployment, nil
+}
+
 func (configDb *ConfigDB) GetNodeTypeConfig(region string) (*models.AWSRegionNodeTypeConfig, error) {
 	session, sessionErr := connectMongo(configDb.Url, configDb.Database, configDb.User, configDb.Password)
 	if sessionErr != nil {

documents/deployed.config

@@ -4,10 +4,12 @@
   "analyzerUrl": "http://analyzer:5000",
   "writeResults": true,
   "filesPath": "/tmp/profiler",
-  "userId": "hyperpilot",
+  "userId": "william",
   "workerCount": 5,
+  "awsId": "AKIAIMJUJ75EFI6SU2RA",
+  "awsSecret": "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",
   "database": {
-    "url": "mongo-serve:27017",
+    "url": "ds161262.mlab.com:61262",
     "user": "analyzer",
     "password": "hyperpilot",
     "configDatabase": "configdb",
@@ -19,7 +21,8 @@
     "calibrationCollection": "calibration",
     "profilingCollection": "profiling",
     "sizingCollection": "sizing",
-    "allInstanceCollection": "allinstance"
+    "allInstanceCollection": "allinstance",
+    "deploymentCollection": "deployments"
   },
   "store": {
     "type": "simpledb",

documents/template.config

@@ -11,6 +11,7 @@
     "benchmarkCollection": "benchmarks",
     "metricDatabase": "metricdb",
     "calibrationCollection": "calibration",
-    "profilingCollection": "profiling"
+    "profilingCollection": "profiling",
+    "deploymentCollection": "deployment"
   }
 }