// ProvisionProxy creates a Docker image for a proxy node definition
func ProvisionProxy(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
proxyrequest := ProxyRequest{}
err = r.DecodeJsonPayload(&proxyrequest)
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
logit.Info.Println("ProvisionProxy: Token=[" + proxyrequest.Token + "]")
err = secimpl.Authorize(dbConn, proxyrequest.Token, "perm-container")
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
errorStr := ""
if proxyrequest.ProjectID == "" {
logit.Error.Println("ProvisionProxy error ProjectID required")
errorStr = "ProjectID required"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
if proxyrequest.ContainerName == "" {
logit.Error.Println("ProvisionProxy error containername required")
errorStr = "ContainerName required"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
if proxyrequest.Image == "" {
logit.Error.Println("ProvisionProxy error image required")
errorStr = "Image required"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
if proxyrequest.Host == "" {
logit.Error.Println("ProvisionProxy error DatabaseHost required")
errorStr = "DatabaseHost required"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
if proxyrequest.Host == "127.0.0.1" || proxyrequest.Host == "localhost" {
logit.Error.Println("ProvisionProxy error DatabaseHost can not be localhost")
errorStr = "DatabaseHost can not be localhost"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
if proxyrequest.Database == "" {
logit.Error.Println("ProvisionProxy error Database required")
errorStr = "Database required"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
if proxyrequest.Usename == "" {
logit.Error.Println("ProvisionProxy error Usename required")
errorStr = "Usename required"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
if proxyrequest.Passwd == "" {
logit.Error.Println("ProvisionProxy error Passwd required")
errorStr = "Passwd required"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
//logit.Info.Println("Image=" + proxyrequest.Image)
//logit.Info.Println("Profile=" + proxyrequest.Profile)
//logit.Info.Println("ProjectID=" + proxyrequest.ProjectID)
//logit.Info.Println("ContainerName=" + proxyrequest.ContainerName)
//logit.Info.Println("Standalone=" + proxyrequest.Standalone)
params := &swarmapi.DockerRunRequest{}
params.Image = proxyrequest.Image
params.ProjectID = proxyrequest.ProjectID
params.ContainerName = util.CleanName(proxyrequest.ContainerName)
params.Standalone = proxyrequest.Standalone
params.Profile = proxyrequest.Profile
_, err = provisionImpl(dbConn, params, false)
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
err = insertProxy(&proxyrequest)
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.WriteHeader(http.StatusOK)
status := types.SimpleStatus{}
status.Status = "OK"
w.WriteJson(&status)
}
// AutoCluster creates a new cluster
func AutoCluster(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
logit.Info.Println("AUTO CLUSTER PROFILE starts")
params := AutoClusterInfo{}
err = r.DecodeJsonPayload(¶ms)
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = secimpl.Authorize(dbConn, params.Token, "perm-cluster")
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
if params.Name == "" {
logit.Error.Println("AutoCluster: error in Name")
rest.Error(w, "cluster name required", http.StatusBadRequest)
return
}
if params.ClusterType == "" {
logit.Error.Println("AutoCluster: error in ClusterType")
rest.Error(w, "ClusterType name required", http.StatusBadRequest)
return
}
if params.ProjectID == "" {
logit.Error.Println("AutoCluster: error in ProjectID")
rest.Error(w, "ProjectID name required", http.StatusBadRequest)
return
}
if params.ClusterProfile == "" {
logit.Error.Println("AutoCluster: error in ClusterProfile")
rest.Error(w, "ClusterProfile name required", http.StatusBadRequest)
return
}
logit.Info.Println("AutoCluster: Name=" + params.Name + " ClusterType=" + params.ClusterType + " Profile=" + params.ClusterProfile + " ProjectID=" + params.ProjectID)
//create cluster definition
dbcluster := types.Cluster{}
dbcluster.ID = ""
dbcluster.ProjectID = params.ProjectID
dbcluster.Name = util.CleanName(params.Name)
dbcluster.ClusterType = params.ClusterType
dbcluster.Status = "uninitialized"
dbcluster.Containers = make(map[string]string)
var ival int
ival, err = admindb.InsertCluster(dbConn, dbcluster)
clusterID := strconv.Itoa(ival)
dbcluster.ID = clusterID
//logit.Info.Println(clusterID)
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, "Insert Cluster error:"+err.Error(), http.StatusBadRequest)
return
}
//lookup profile
profile, err2 := getClusterProfileInfo(dbConn, params.ClusterProfile)
if err2 != nil {
logit.Error.Println(err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
//var masterServer types.Server
//var chosenServers []types.Server
if profile.Algo == "round-robin" {
//masterServer, chosenServers, err2 = roundRobin(dbConn, profile)
} else {
logit.Error.Println("AutoCluster: error-unsupported algorithm request")
rest.Error(w, "AutoCluster error: unsupported algorithm", http.StatusBadRequest)
return
}
//create master container
dockermaster := swarmapi.DockerRunRequest{}
dockermaster.Image = "cpm-node"
dockermaster.ContainerName = params.Name + "-master"
dockermaster.ProjectID = params.ProjectID
dockermaster.Standalone = "false"
dockermaster.Profile = profile.MasterProfile
if err != nil {
logit.Error.Println("AutoCluster: error-create master node " + err.Error())
rest.Error(w, "AutoCluster error"+err.Error(), http.StatusBadRequest)
return
}
// provision the master
logit.Info.Println("dockermaster profile is " + dockermaster.Profile)
_, err2 = provisionImpl(dbConn, &dockermaster, false)
if err2 != nil {
logit.Error.Println("AutoCluster: error-provision master " + err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
logit.Info.Println("AUTO CLUSTER PROFILE master container created")
var node types.Container
//update node with cluster iD
node, err2 = admindb.GetContainerByName(dbConn, dockermaster.ContainerName)
if err2 != nil {
logit.Error.Println("AutoCluster: error-get node by name " + err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
node.ClusterID = clusterID
node.Role = "master"
err2 = admindb.UpdateContainer(dbConn, node)
if err2 != nil {
logit.Error.Println("AutoCluster: error-update standby node " + err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
var sleepSetting types.Setting
sleepSetting, err2 = admindb.GetSetting(dbConn, "SLEEP-PROV")
if err2 != nil {
logit.Error.Println("SLEEP-PROV setting error " + err2.Error())
rest.Error(w, err2.Error(), http.StatusInternalServerError)
return
}
var sleepTime time.Duration
sleepTime, err2 = time.ParseDuration(sleepSetting.Value)
if err2 != nil {
logit.Error.Println(err2.Error())
rest.Error(w, err2.Error(), http.StatusInternalServerError)
return
}
//create standby containers
var count int
count, err2 = strconv.Atoi(profile.Count)
if err2 != nil {
logit.Error.Println(err2.Error())
rest.Error(w, err2.Error(), http.StatusBadRequest)
return
}
dockerstandby := make([]swarmapi.DockerRunRequest, count)
for i := 0; i < count; i++ {
logit.Info.Println("working on standby ....")
// loop - provision standby
dockerstandby[i].ProjectID = params.ProjectID
dockerstandby[i].Image = "cpm-node"
dockerstandby[i].ContainerName = params.Name + "-" + STANDBY + "-" + strconv.Itoa(i)
dockerstandby[i].Standalone = "false"
dockerstandby[i].Profile = profile.StandbyProfile
_, err2 = provisionImpl(dbConn, &dockerstandby[i], true)
if err2 != nil {
logit.Error.Println("AutoCluster: error-provision master " + err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
//update node with cluster iD
node, err2 = admindb.GetContainerByName(dbConn, dockerstandby[i].ContainerName)
if err2 != nil {
logit.Error.Println("AutoCluster: error-get node by name " + err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
node.ClusterID = clusterID
node.Role = STANDBY
err2 = admindb.UpdateContainer(dbConn, node)
if err2 != nil {
logit.Error.Println("AutoCluster: error-update standby node " + err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
}
logit.Info.Println("AUTO CLUSTER PROFILE standbys created")
//create pgpool container
// provision
dockerpgpool := swarmapi.DockerRunRequest{}
dockerpgpool.ContainerName = params.Name + "-pgpool"
dockerpgpool.Image = "cpm-pgpool"
dockerpgpool.ProjectID = params.ProjectID
dockerpgpool.Standalone = "false"
dockerpgpool.Profile = profile.StandbyProfile
_, err2 = provisionImpl(dbConn, &dockerpgpool, true)
if err2 != nil {
logit.Error.Println("AutoCluster: error-provision pgpool " + err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
logit.Info.Println("AUTO CLUSTER PROFILE pgpool created")
//update node with cluster ID
node, err2 = admindb.GetContainerByName(dbConn, dockerpgpool.ContainerName)
if err2 != nil {
logit.Error.Println("AutoCluster: error-get pgpool node by name " + err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
node.ClusterID = clusterID
node.Role = "pgpool"
err2 = admindb.UpdateContainer(dbConn, node)
if err2 != nil {
logit.Error.Println("AutoCluster: error-update pgpool node " + err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
//init the master DB
// provision the master
dockermaster.Profile = profile.MasterProfile
err2 = provisionImplInit(dbConn, &dockermaster, false)
if err2 != nil {
logit.Error.Println("AutoCluster: error-provisionInit master " + err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
//make sure every node is ready
err2 = waitTillAllReady(dockermaster, dockerpgpool, dockerstandby, sleepTime)
if err2 != nil {
logit.Error.Println("cluster members not responding in time")
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
//configure cluster
// ConfigureCluster
logit.Info.Println("AUTO CLUSTER PROFILE configure cluster ")
err2 = configureCluster(profile.MasterProfile, dbConn, dbcluster, true)
if err2 != nil {
logit.Error.Println("AutoCluster: error-configure cluster " + err2.Error())
rest.Error(w, "AutoCluster error"+err2.Error(), http.StatusBadRequest)
return
}
logit.Info.Println("AUTO CLUSTER PROFILE done")
w.WriteHeader(http.StatusOK)
status := types.SimpleStatus{}
status.Status = "OK"
w.WriteJson(&status)
}
// Provision creates a Docker container image
func Provision(w rest.ResponseWriter, r *rest.Request) {
dbConn, err := util.GetConnection(CLUSTERADMIN_DB)
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), 400)
return
}
defer dbConn.Close()
params := swarmapi.DockerRunRequest{}
err = r.DecodeJsonPayload(¶ms)
if err != nil {
logit.Error.Println("error in decode" + err.Error())
rest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
err = secimpl.Authorize(dbConn, params.Token, "perm-container")
if err != nil {
logit.Error.Println(err.Error())
rest.Error(w, err.Error(), http.StatusUnauthorized)
return
}
errorStr := ""
if params.Profile == "" {
logit.Error.Println("Provision error profile required")
errorStr = "Profile required"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
if params.ProjectID == "" {
logit.Error.Println("Provision error ProjectID required")
errorStr = "ProjectID required"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
if params.ContainerName == "" {
logit.Error.Println("Provision error containername required")
errorStr = "ContainerName required"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
if params.Image == "" {
logit.Error.Println("Provision error image required")
errorStr = "Image required"
rest.Error(w, errorStr, http.StatusBadRequest)
return
}
//logit.Info.Println("params.Image=" + params.Image)
//logit.Info.Println("params.Profile=" + params.Profile)
//logit.Info.Println("params.ServerID=" + params.ServerID)
//logit.Info.Println("params.ProjectID=" + params.ProjectID)
params.ContainerName = util.CleanName(params.ContainerName)
//logit.Info.Println("params.ContainerName=" + params.ContainerName)
var newid string
newid, err = provisionImpl(dbConn, ¶ms, false)
if err != nil {
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
err = provisionImplInit(dbConn, ¶ms, false)
if err != nil {
rest.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.WriteHeader(http.StatusOK)
status := types.ProvisionStatus{}
status.Status = "OK"
status.ID = newid
w.WriteJson(&status)
}