func main() {
fmt.Println("at top of testswarm main")
var err error
//var infoResponse swarmapi.DockerInfoResponse
_, err = swarmapi.DockerInfo()
os.Exit(0)
inspectReq := swarmapi.DockerInspectRequest{}
inspectReq.ContainerName = "cpm"
var inspectResp swarmapi.DockerInspectResponse
inspectResp, err = swarmapi.DockerInspect(&inspectReq)
if err != nil {
fmt.Println(err.Error())
}
fmt.Println(inspectResp.IPAddress)
runReq := swarmapi.DockerRunRequest{}
runReq.PGDataPath = "/var/cpm/data/pgsql/swarmtest"
runReq.ContainerType = "cpm-node"
runReq.ContainerName = "swarmtest"
runReq.EnvVars = make(map[string]string)
runReq.EnvVars["one"] = "value of one"
runReq.EnvVars["two"] = "value of two"
runReq.CPU = "0"
runReq.MEM = "0"
var runResp swarmapi.DockerRunResponse
runResp, err = swarmapi.DockerRun(&runReq)
if err != nil {
fmt.Println(err.Error())
}
fmt.Println(runResp.ID)
}
// ProvisionRestoreJob creates a docker container to orchestrate a restore job
func ProvisionRestoreJob(dbConn *sql.DB, args *TaskRequest) error {
logit.Info.Println("task.ProvisionRestoreJob called")
logit.Info.Println("with scheduleid=" + args.ScheduleID)
logit.Info.Println("with containername=" + args.ContainerName)
logit.Info.Println("with profilename=" + args.ProfileName)
logit.Info.Println("with statusid=" + args.StatusID)
restorecontainername := args.ContainerName + "-restore-job"
//remove any existing container with the same name
inspectReq := &swarmapi.DockerInspectRequest{}
inspectReq.ContainerName = restorecontainername
inspectResponse, err := swarmapi.DockerInspect(inspectReq)
if err != nil {
logit.Error.Println(err.Error())
return err
}
if inspectResponse.RunningState != "not-found" {
rreq := &swarmapi.DockerRemoveRequest{}
rreq.ContainerName = restorecontainername
_, err = swarmapi.DockerRemove(rreq)
if err != nil {
logit.Error.Println(err.Error())
return err
}
}
//create the new container
params := &swarmapi.DockerRunRequest{}
params.Image = "cpm-restore-job"
params.ContainerName = restorecontainername
params.Standalone = "false"
params.Profile = "SM"
schedule, err := GetSchedule(dbConn, args.ScheduleID)
if err != nil {
logit.Error.Println(err.Error())
return err
}
logit.Info.Println("schedule serverip is " + schedule.Serverip)
var taskstatus TaskStatus
taskstatus, err = GetStatus(dbConn, args.StatusID)
if err != nil {
logit.Error.Println(err.Error())
return err
}
//params.PGDataPath = server.PGDataPath + "/" + restorecontainername + "/" + getFormattedDate()
//get the docker profile settings
var setting types.Setting
setting, err = admindb.GetSetting(dbConn, "S-DOCKER-PROFILE-CPU")
params.CPU = setting.Value
setting, err = admindb.GetSetting(dbConn, "S-DOCKER-PROFILE-MEM")
params.MEM = setting.Value
setting, err = admindb.GetSetting(dbConn, "PG-DATA-PATH")
var datapath string
datapath = setting.Value
//this gets mounted under /pgdata and allows us to access
//both the backup files and the restored containers files
params.PGDataPath = datapath
params.EnvVars = make(map[string]string)
params.EnvVars["RestoreServerip"] = schedule.Serverip
params.EnvVars["RestoreBackupPath"] = taskstatus.Path
params.EnvVars["RestorePath"] = args.ContainerName
params.EnvVars["RestoreContainerName"] = args.ContainerName
params.EnvVars["RestoreScheduleID"] = args.ScheduleID
params.EnvVars["RestoreProfileName"] = args.ProfileName
params.EnvVars["RestoreStatusID"] = args.StatusID
//run the container
//params.CommandPath = "docker-run-restore.sh"
var response swarmapi.DockerRunResponse
//var url = "http://" + server.IPAddress + ":10001"
response, err = swarmapi.DockerRun(params)
if err != nil {
logit.Error.Println(response.ID)
return err
}
logit.Info.Println("docker run output=" + response.ID)
return nil
}
// ProvisionRestoreJob creates a docker container to orchestrate a pg_backrest restore job
func ProvisionBackrestRestoreJob(dbConn *sql.DB, args *TaskRequest) error {
logit.Info.Println("task.ProvisionBackrestRestoreJob called")
logit.Info.Println("with scheduleid=" + args.ScheduleID)
logit.Info.Println("with containername=" + args.ContainerName)
logit.Info.Println("with profilename=" + args.ProfileName)
params := &swarmapi.DockerRunRequest{}
params.Image = "cpm-backrest-restore-job"
restorecontainername := args.ContainerName + "-backrest-restore-job"
params.ContainerName = restorecontainername
params.Standalone = "false"
params.Profile = "SM"
schedule, err := GetSchedule(dbConn, args.ScheduleID)
if err != nil {
logit.Error.Println(err.Error())
return err
}
//params.PGDataPath = server.PGDataPath + "/" + restorecontainername + "/" + getFormattedDate()
//get the docker profile settings
var setting types.Setting
setting, err = admindb.GetSetting(dbConn, "S-DOCKER-PROFILE-CPU")
params.CPU = setting.Value
setting, err = admindb.GetSetting(dbConn, "S-DOCKER-PROFILE-MEM")
params.MEM = setting.Value
params.EnvVars = make(map[string]string)
params.EnvVars["RestoreRemotePath"] = schedule.RestoreRemotePath
params.EnvVars["RestoreRemoteHost"] = schedule.RestoreRemoteHost
params.EnvVars["RestoreRemoteUser"] = schedule.RestoreRemoteUser
params.EnvVars["RestoreDbUser"] = schedule.RestoreDbUser
params.EnvVars["RestoreDbPass"] = schedule.RestoreDbPass
params.EnvVars["RestoreSet"] = schedule.RestoreSet
params.EnvVars["RestoreContainerName"] = args.ContainerName
params.EnvVars["RestoreScheduleID"] = args.ScheduleID
params.EnvVars["RestoreProfileName"] = args.ProfileName
setting, err = admindb.GetSetting(dbConn, "PG-PORT")
if err != nil {
logit.Error.Println(err.Error())
return err
}
params.EnvVars["RestorePGPort"] = setting.Value
//run the container
//params.CommandPath = "docker-run-restore.sh"
var response swarmapi.DockerRunResponse
//var url = "http://" + server.IPAddress + ":10001"
response, err = swarmapi.DockerRun(params)
if err != nil {
logit.Error.Println(response.ID)
return err
}
logit.Info.Println("docker-run-restore.sh output=" + response.ID)
return nil
}
func provisionImpl(dbConn *sql.DB, params *swarmapi.DockerRunRequest, standby bool) (string, error) {
logit.Info.Println("PROFILE: provisionImpl starts 1")
var errorStr string
//make sure the container name is not already taken
_, err := admindb.GetContainerByName(dbConn, params.ContainerName)
if err != nil {
if err != sql.ErrNoRows {
return "", err
}
} else {
errorStr = "container name " + params.ContainerName + " already used can't provision"
logit.Error.Println(errorStr)
return "", errors.New(errorStr)
}
//get the pg data path
var pgdatapath types.Setting
pgdatapath, err = admindb.GetSetting(dbConn, "PG-DATA-PATH")
if err != nil {
logit.Error.Println(err.Error())
return "", err
}
var infoResponse swarmapi.DockerInfoResponse
infoResponse, err = swarmapi.DockerInfo()
servers := make([]types.Server, len(infoResponse.Output))
i := 0
for i = range infoResponse.Output {
servers[i].ID = infoResponse.Output[i]
servers[i].Name = infoResponse.Output[i]
servers[i].IPAddress = infoResponse.Output[i]
i++
}
//for database nodes, on the target server, we need to allocate
//a disk volume on all CPM servers for the /pgdata container volume to work with
//this causes a volume to be created with the directory
//named the same as the container name
params.PGDataPath = pgdatapath.Value + "/" + params.ContainerName
logit.Info.Println("PROFILE provisionImpl 2 about to provision volume " + params.PGDataPath)
if params.Image != "cpm-pgpool" {
preq := &cpmserverapi.DiskProvisionRequest{}
preq.Path = params.PGDataPath
var response cpmserverapi.DiskProvisionResponse
for _, each := range servers {
logit.Info.Println("Provision: provisionvolume on server " + each.Name)
response, err = cpmserverapi.DiskProvisionClient(each.Name, preq)
if err != nil {
logit.Info.Println("Provision: provisionvolume error" + err.Error())
logit.Error.Println(err.Error())
return "", err
}
logit.Info.Println("Provision: provisionvolume call response=" + response.Status)
}
}
logit.Info.Println("PROFILE provisionImpl 3 provision volume completed")
//run docker run to create the container
params.CPU, params.MEM, err = getDockerResourceSettings(dbConn, params.Profile)
if err != nil {
logit.Error.Println(err.Error())
return "", err
}
//inspect and remove any existing container
logit.Info.Println("PROFILE provisionImpl inspect 4")
inspectReq := &swarmapi.DockerInspectRequest{}
inspectReq.ContainerName = params.ContainerName
var inspectResponse swarmapi.DockerInspectResponse
inspectResponse, err = swarmapi.DockerInspect(inspectReq)
if err != nil {
logit.Error.Println(err.Error())
return "", err
}
if inspectResponse.RunningState != "not-found" {
logit.Info.Println("PROFILE provisionImpl remove existing container 4a")
rreq := &swarmapi.DockerRemoveRequest{}
rreq.ContainerName = params.ContainerName
_, err = swarmapi.DockerRemove(rreq)
if err != nil {
logit.Error.Println(err.Error())
return "", err
}
}
//pass any restore env vars to the new container
if params.RestoreJob != "" {
if params.EnvVars == nil {
//logit.Info.Println("making envvars map")
params.EnvVars = make(map[string]string)
}
params.EnvVars["RestoreJob"] = params.RestoreJob
params.EnvVars["RestoreRemotePath"] = params.RestoreRemotePath
params.EnvVars["RestoreRemoteHost"] = params.RestoreRemoteHost
params.EnvVars["RestoreRemoteUser"] = params.RestoreRemoteUser
params.EnvVars["RestoreDbUser"] = params.RestoreDbUser
params.EnvVars["RestoreDbPass"] = params.RestoreDbPass
params.EnvVars["RestoreSet"] = params.RestoreSet
}
//
runReq := swarmapi.DockerRunRequest{}
runReq.PGDataPath = params.PGDataPath
runReq.Profile = params.Profile
runReq.Image = params.Image
runReq.ContainerName = params.ContainerName
runReq.EnvVars = params.EnvVars
//logit.Info.Println("CPU=" + params.CPU)
//logit.Info.Println("MEM=" + params.MEM)
runReq.CPU = "0"
runReq.MEM = "0"
var runResp swarmapi.DockerRunResponse
runResp, err = swarmapi.DockerRun(&runReq)
if err != nil {
logit.Error.Println(err.Error())
return "", err
}
logit.Info.Println("PROFILE provisionImpl created container 5 " + runResp.ID)
dbnode := types.Container{}
dbnode.ID = ""
dbnode.Name = params.ContainerName
dbnode.Image = params.Image
dbnode.ClusterID = "-1"
dbnode.ProjectID = params.ProjectID
if params.Standalone == "true" {
dbnode.Role = "standalone"
} else {
dbnode.Role = "unassigned"
}
var strid int
strid, err = admindb.InsertContainer(dbConn, dbnode)
newid := strconv.Itoa(strid)
if err != nil {
logit.Error.Println(err.Error())
return "", err
}
dbnode.ID = newid
if params.Image != "cpm-node-proxy" {
//register default db users on the new node
err = createDBUsers(dbConn, dbnode)
}
return newid, err
}