/*
* Delete command kills the container by talking to swarm cluster and giving
* the container ID.
*
*/
func (i *Docker) Delete(assembly *global.AssemblyWithComponents, id string) (string, error) {
pair_endpoint, perrscm := global.ParseKeyValuePair(assembly.Inputs, "endpoint")
if perrscm != nil {
log.Error("Failed to get the endpoint value : %s", perrscm)
}
pair_id, iderr := global.ParseKeyValuePair(assembly.Components[0].Outputs, "id")
if iderr != nil {
log.Error("Failed to get the endpoint value : %s", iderr)
}
var endpoint string
if pair_endpoint.Value == BAREMETAL {
api_host, _ := config.GetString("swarm:host")
endpoint = api_host
} else {
endpoint = pair_endpoint.Value
}
client, _ := docker.NewClient(endpoint)
kerr := client.KillContainer(docker.KillContainerOptions{ID: pair_id.Value})
if kerr != nil {
log.Error("Failed to kill the container : %s", kerr)
return "", kerr
}
log.Info("Container is killed")
return "", nil
}
func dockerStateHandler(chann []byte) {
Msg := &Message{}
parse_err := json.Unmarshal(chann, &Msg)
log.Info(parse_err)
if parse_err != nil {
log.Error("Error: Message parsing error:\n%s.", parse_err)
return
}
apprequest := global.AppRequest{Id: Msg.Id}
req, err := apprequest.Get(Msg.Id)
log.Info(req)
if err != nil {
log.Error("Error: Riak didn't cooperate:\n%s.", err)
return
}
assembly := global.Assembly{Id: req.AppId}
asm, err := assembly.GetAssemblyWithComponents(req.AppId)
if err != nil {
log.Error("Error: Riak didn't cooperate:\n%s.", err)
return
}
cont_id, perrscm := global.ParseKeyValuePair(asm.Components[0].Outputs, "id")
if perrscm != nil {
log.Error("Failed to get the container id : %s", perrscm)
}
endpoint, perrscm := global.ParseKeyValuePair(asm.Components[0].Outputs, "endpoint")
if perrscm != nil {
log.Error("Failed to get the container id : %s", perrscm)
}
pair_cpu, perrscm := global.ParseKeyValuePair(asm.Inputs, "cpu")
if perrscm != nil {
log.Error("Failed to get the cpu value : %s", perrscm)
}
pair_memory, iderr := global.ParseKeyValuePair(asm.Inputs, "ram")
if iderr != nil {
log.Error("Failed to get the memory value : %s", iderr)
}
switch req.Action {
case "start":
log.Info("Starting Container")
go docker.StartContainer(&global.Container{ContainerID: cont_id.Value, Cpu: pair_cpu.Value, Ram: pair_memory.Value}, endpoint.Value)
break
case "stop":
log.Info("Stopping Container")
go docker.StopContainer(&global.Container{ContainerID: cont_id.Value}, endpoint.Value)
break
case "restart":
log.Info("Restarting container")
go docker.RestartContainer(&global.Container{ContainerID: cont_id.Value}, endpoint.Value)
break
}
}
/*
* delete the machine from megam server using knife opennebula plugin
*/
func (i *MegamIaaS) DeleteMachine(pdc *global.PredefClouds, assembly *global.AssemblyWithComponents) (string, error) {
accesskey, err_accesskey := config.GetString("opennebula:access_key")
if err_accesskey != nil {
return "", err_accesskey
}
secretkey, err_secretkey := config.GetString("opennebula:secret_key")
if err_secretkey != nil {
return "", err_secretkey
}
str, err := buildDelCommand(iaas.GetPlugins("opennebula"), pdc, "delete")
if err != nil {
return "", err
}
//str = str + " -P " + " -y "
pair, perr := global.ParseKeyValuePair(assembly.Inputs, "domain")
if perr != nil {
log.Error("Failed to get the domain value : %s", perr)
}
str = str + " -N " + assembly.Name + "." + pair.Value
str = str + " -A " + accesskey
str = str + " -K " + secretkey
knifePath, kerr := config.GetString("knife:path")
if kerr != nil {
return "", kerr
}
str = strings.Replace(str, " -c ", " -c "+knifePath+" ", -1)
str = strings.Replace(str, "<node_name>", assembly.Name+"."+pair.Value, -1)
return str, nil
}
func CommandExecutor(app *global.AssemblyWithComponents) (action.Result, error) {
var e exec.OsExecutor
var commandWords []string
appName := ""
commandWords = strings.Fields(app.Command)
log.Debug("Command Executor entry: %s\n", app)
megam_home, ckberr := config.GetString("megam_home")
if ckberr != nil {
return nil, ckberr
}
pair, perr := global.ParseKeyValuePair(app.Inputs, "domain")
if perr != nil {
log.Error("Failed to get the domain value : %s", perr)
}
appName = app.Name + "." + pair.Value
basePath := megam_home + "logs"
dir := path.Join(basePath, appName)
fileOutPath := path.Join(dir, appName+"_out")
fileErrPath := path.Join(dir, appName+"_err")
if _, err := os.Stat(dir); os.IsNotExist(err) {
log.Info("Creating directory: %s\n", dir)
if errm := os.MkdirAll(dir, 0777); errm != nil {
return nil, errm
}
}
// open output file
fout, outerr := os.OpenFile(fileOutPath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if outerr != nil {
return nil, outerr
}
defer fout.Close()
// open Error file
ferr, errerr := os.OpenFile(fileErrPath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if errerr != nil {
return nil, errerr
}
defer ferr.Close()
foutwriter := bufio.NewWriterSize(fout, 1)
ferrwriter := bufio.NewWriterSize(ferr, 1)
log.Debug(commandWords)
log.Debug("Length: %s", len(commandWords))
defer ferrwriter.Flush()
defer foutwriter.Flush()
if len(commandWords) > 0 {
if err := e.Execute(commandWords[0], commandWords[1:], nil, foutwriter, ferrwriter); err != nil {
return nil, err
}
}
return &app, nil
}
func LauncherHelper(asm *global.AssemblyWithComponents, id string, instance bool, act_id string) error {
pair_host, perrscm := global.ParseKeyValuePair(asm.Inputs, "provider")
if perrscm != nil {
log.Error("Failed to get the host value : %s", perrscm)
}
if pair_host.Value == "docker" {
log.Debug("Docker provisioner entry")
// Provisioner
p, err := provisioner.GetProvisioner("docker")
if err != nil {
return err
}
log.Info("Provisioner: %v", p)
_, perr := p.Create(asm, id, instance, act_id)
if perr != nil {
return perr
}
}
if pair_host.Value == "chef" {
p, err := provisioner.GetProvisioner("chef")
if err != nil {
return err
}
str, perr := p.Create(asm, id, instance, act_id)
if perr != nil {
return perr
}
asm.Command = str
actions := []*action.Action{&launchedApp}
pipeline := action.NewPipeline(actions...)
aerr := pipeline.Execute(asm)
if aerr != nil {
return aerr
}
}
return nil
}
func cioperation(asm *global.AssemblyWithComponents, ci *global.Operations, com *global.Component) error {
pair_scm, perrscm := global.ParseKeyValuePair(ci.OperationRequirements, "ci-scm")
if perrscm != nil {
log.Error("Failed to get the domain value : %s", perrscm)
}
pair_enable, perrenable := global.ParseKeyValuePair(ci.OperationRequirements, "ci-enable")
if perrenable != nil {
log.Error("Failed to get the domain value : %s", perrenable)
}
if pair_scm.Value == GITHUB && pair_enable.Value == ENABLE {
log.Info("Github is working")
pair_token, perrtoken := global.ParseKeyValuePair(ci.OperationRequirements, "ci-token")
if perrtoken != nil {
log.Error("Failed to get the domain value : %s", perrtoken)
}
t := &oauth.Transport{
Token: &oauth.Token{AccessToken: pair_token.Value},
}
client := git.NewClient(t.Client())
api_host, apierr := config.GetString("api:host")
if apierr != nil {
return apierr
}
api_version, apiverr := config.GetString("api:version")
if apiverr != nil {
return apiverr
}
trigger_url := "http://" + api_host + "/" + api_version + "/assembly/build/" + asm.Id + "/" + com.Id
byt12 := []byte(`{"url": "","content_type": "json"}`)
var postData map[string]interface{}
if perr := json.Unmarshal(byt12, &postData); perr != nil {
return perr
}
postData["url"] = trigger_url
byt1 := []byte(`{"name": "web", "active": true, "events": [ "push" ]}`)
postHook := git.Hook{Config: postData}
if perr := json.Unmarshal(byt1, &postHook); perr != nil {
log.Info(perr)
}
pair_source, perrsource := global.ParseKeyValuePair(com.Inputs, "source")
if perrsource != nil {
log.Error("Failed to get the domain value : %s", perrsource)
}
pair_owner, perrowner := global.ParseKeyValuePair(ci.OperationRequirements, "ci-owner")
if perrowner != nil {
log.Error("Failed to get the domain value : %s", perrowner)
}
source := strings.Split(pair_source.Value, "/")
_, _, err := client.Repositories.CreateHook(pair_owner.Value, strings.TrimRight(source[len(source)-1], ".git"), &postHook)
if err != nil {
return err
}
} else {
log.Info("Github is skipped")
}
return nil
}
/*
* create the machine into megam server using knife opennebula plugin
*/
func (i *MegamIaaS) CreateMachine(pdc *global.PredefClouds, assembly *global.AssemblyWithComponents, act_id string) (string, error) {
log.Info("Megam provider create entry")
accesskey, err_accesskey := config.GetString("opennebula:access_key")
if err_accesskey != nil {
return "", err_accesskey
}
secretkey, err_secretkey := config.GetString("opennebula:secret_key")
if err_secretkey != nil {
return "", err_secretkey
}
str, err := buildCommand(assembly)
if err != nil {
return "", err
}
pair, perr := global.ParseKeyValuePair(assembly.Inputs, "domain")
if perr != nil {
log.Error("Failed to get the domain value : %s", perr)
}
knifePath, kerr := config.GetString("knife:path")
if kerr != nil {
return "", kerr
}
str = str + " -c " + knifePath
str = str + " -N " + assembly.Name + "." + pair.Value
str = str + " -A " + accesskey
str = str + " -K " + secretkey
recipe, err_recipe := config.GetString("knife:recipe")
if err_recipe != nil {
return "", err_recipe
}
riakHost, err_riakHost := config.GetString("launch:riak")
if err_riakHost != nil {
return "", err_riakHost
}
rabbitmqHost, err_rabbitmq := config.GetString("launch:rabbitmq")
if err_rabbitmq != nil {
return "", err_rabbitmq
}
monitor, err_monitor := config.GetString("launch:monitor")
if err_monitor != nil {
return "", err_monitor
}
kibana, err_kibana := config.GetString("launch:kibana")
if err_kibana != nil {
return "", err_kibana
}
etcdHost, err_etcd := config.GetString("launch:etcd")
if err_etcd != nil {
return "", err_etcd
}
str = str + " --run-list recipe[" + recipe + "]"
attributes := &iaas.Attributes{RiakHost: riakHost, AccountID: act_id, AssemblyID: assembly.Id, RabbitMQ: rabbitmqHost, MonitorHost: monitor, KibanaHost: kibana, EtcdHost: etcdHost}
b, aerr := json.Marshal(attributes)
if aerr != nil {
return "", aerr
}
str = str + " --json-attributes " + string(b)
return str, nil
}
/*
* Build the knife opennebula server create command
*/
func buildCommand(assembly *global.AssemblyWithComponents) (string, error) {
var buffer bytes.Buffer
buffer.WriteString("knife ")
buffer.WriteString("opennebula ")
buffer.WriteString("server ")
buffer.WriteString("create")
templatekey := ""
if len(assembly.Components) > 0 {
megamtemplatekey, err_templatekey := config.GetString("opennebula:default_template_name")
if err_templatekey != nil {
return "", err_templatekey
}
templatekey = megamtemplatekey
} else {
atype := make([]string, 3)
atype = strings.Split(assembly.ToscaType, ".")
pair, perr := global.ParseKeyValuePair(assembly.Inputs, "version")
if perr != nil {
log.Error("Failed to get the version : %s", perr)
}
templatekey = "megam_" + atype[2] + "_" + pair.Value
}
if len(templatekey) > 0 {
buffer.WriteString(" --template-name " + templatekey)
} else {
return "", fmt.Errorf("Template doesn't loaded")
}
sshuserkey, err_sshuserkey := config.GetString("opennebula:ssh_user")
if err_sshuserkey != nil {
return "", err_sshuserkey
}
if len(sshuserkey) > 0 {
buffer.WriteString(" -x " + sshuserkey)
} else {
return "", fmt.Errorf("Ssh user value doesn't loaded")
}
identityfilekey, err_identityfilekey := config.GetString("opennebula:identity_file")
if err_identityfilekey != nil {
return "", err_identityfilekey
}
if len(identityfilekey) > 0 {
buffer.WriteString(" --identity-file " + identityfilekey)
} else {
return "", fmt.Errorf("Identity file doesn't loaded")
}
zonekey, err_zonekey := config.GetString("opennebula:zone")
if err_zonekey != nil {
return "", err_zonekey
}
if len(zonekey) > 0 {
buffer.WriteString(" --endpoint " + zonekey)
} else {
return "", fmt.Errorf("Zone doesn't loaded")
}
return buffer.String(), nil
}
func (i *Docker) Create(assembly *global.AssemblyWithComponents, id string, instance bool, act_id string) (string, error) {
log.Info("%q", assembly)
pair_endpoint, perrscm := global.ParseKeyValuePair(assembly.Inputs, "endpoint")
if perrscm != nil {
log.Error("Failed to get the endpoint value : %s", perrscm)
return "", perrscm
}
pair_img, perrscm := global.ParseKeyValuePair(assembly.Components[0].Inputs, "source")
if perrscm != nil {
log.Error("Failed to get the image value : %s", perrscm)
return "", perrscm
}
pair_domain, perrdomain := global.ParseKeyValuePair(assembly.Components[0].Inputs, "domain")
if perrdomain != nil {
log.Error("Failed to get the image value : %s", perrdomain)
return "", perrdomain
}
var endpoint string
if pair_endpoint.Value == BAREMETAL {
/*
* swarm host is obtained from conf file. Swarm host is considered
* only when the 'endpoint' is baremetal in the Component JSON
*/
api_host, _ := config.GetString("swarm:host")
endpoint = api_host
} else {
endpoint = pair_endpoint.Value
}
/*
* Docker API client to connect to swarm. Swarm supports all docker API endpoints
*/
client, _ := docker.NewClient(endpoint)
opts := docker.PullImageOptions{
Repository: pair_img.Value,
}
pullerr := client.PullImage(opts, docker.AuthConfiguration{})
if pullerr != nil {
log.Error(pullerr)
}
/*
* Inspect image to get the default internal port to ExposedPorts
* the running internal port to external port
*
*/
img, err := client.InspectImage(pair_img.Value)
if err != nil {
log.Error("Inspect image failed : %s", err)
}
InspectImg := &docker.Image{}
mapFP, _ := json.Marshal(img)
json.Unmarshal([]byte(string(mapFP)), InspectImg)
conf := InspectImg.Config
var Iport string
for k, _ := range conf.ExposedPorts {
port := strings.Split(string(k), "/")
Iport = port[0]
}
/* var exposedPorts map[docker.Port]struct{}
exposedPorts = map[docker.Port]struct{}{
docker.Port(Iport + "/tcp"): {},
} */
config := docker.Config{Image: pair_img.Value}
copts := docker.CreateContainerOptions{Name: fmt.Sprint(assembly.Components[0].Name, ".", pair_domain.Value), Config: &config}
/*
* Creation of the container with copts.
*/
container, conerr := client.CreateContainer(copts)
if conerr != nil {
log.Error("Container creation failed : %s", conerr)
return "", conerr
}
cont := &docker.Container{}
mapP, _ := json.Marshal(container)
json.Unmarshal([]byte(string(mapP)), cont)
/*
* hostConfig{} stuct for portbindings - to expose visible ports
* Also for specfying the container configurations (memory, cpuquota etc)
*/
hostConfig := docker.HostConfig{
//Memory: GetMemory(),
//MemorySwap: GetMemory() + GetSwap(),
//CPUQuota: GetCpuQuota(),
//CPUPeriod: GetCpuPeriod(),
}
hostConfig.PortBindings = map[docker.Port][]docker.PortBinding{
docker.Port(Iport + "/tcp"): {{HostIP: "", HostPort: ""}},
}
/*
* Starting container once the container is created - container ID &
* hostConfig is proivided to start the container.
*
*/
serr := client.StartContainer(cont.ID, &hostConfig)
if serr != nil {
log.Error("Start container was failed : %s", serr)
return "", serr
}
/*
* Inspect API is called to fetch the data about the launched container
*
*/
inscontainer, _ := client.InspectContainer(cont.ID)
contain := &docker.Container{}
mapC, _ := json.Marshal(inscontainer)
json.Unmarshal([]byte(string(mapC)), contain)
container_network := &docker.NetworkSettings{}
mapN, _ := json.Marshal(contain.NetworkSettings)
json.Unmarshal([]byte(string(mapN)), container_network)
configs := &docker.Config{}
mapPort, _ := json.Marshal(contain.Config)
json.Unmarshal([]byte(string(mapPort)), configs)
var port string
for k, _ := range container_network.Ports {
porti := strings.Split(string(k), "/")
port = porti[0]
}
fmt.Println(port)
updatecomponent(assembly, container_network.IPAddress, cont.ID, port)
herr := setHostName(fmt.Sprint(assembly.Components[0].Name, ".", pair_domain.Value), container_network.IPAddress)
if herr != nil {
log.Error("Failed to set the host name : %s", herr)
return "", herr
}
return "", nil
}
func cioperation(asm *global.AssemblyWithComponents, ci *global.Operations, com *global.Component) error {
pair_scm, perrscm := global.ParseKeyValuePair(ci.OperationRequirements, "ci-scm")
if perrscm != nil {
log.Error("Failed to get the domain value : %s", perrscm)
}
pair_enable, perrenable := global.ParseKeyValuePair(ci.OperationRequirements, "ci-enable")
if perrenable != nil {
log.Error("Failed to get the domain value : %s", perrenable)
}
if pair_scm.Value == GOGS && pair_enable.Value == ENABLE {
log.Info("gogs process started...")
api_host, apierr := config.GetString("api:host")
if apierr != nil {
return apierr
}
api_version, apiverr := config.GetString("api:version")
if apiverr != nil {
return apiverr
}
trigger_url := "http://" + api_host + "/" + api_version + "/assembly/build/" + asm.Id + "/" + com.Id
url, herr := config.GetString("scm:gogs:url")
if herr != nil {
return herr
}
pair_token, perrtoken := global.ParseKeyValuePair(ci.OperationRequirements, "ci-token")
if perrtoken != nil {
log.Error("Failed to get the domain value : %s", perrtoken)
}
client := gogs.NewClient(url, pair_token.Value)
log.Info("Gogs api client created")
var postData = make(map[string]string)
postData["url"] = trigger_url
postData["content_type"] = "json"
postHook := gogs.CreateHookOption{Type: "gogs", Config: postData, Active: true}
pair_source, perrsource := global.ParseKeyValuePair(com.Inputs, "source")
if perrsource != nil {
log.Error("Failed to get the domain value : %s", perrsource)
}
source := strings.Split(pair_source.Value, "/")
log.Info(strings.Replace(source[len(source)-1], ".git", "", -1))
pair_owner, perrowner := global.ParseKeyValuePair(ci.OperationRequirements, "ci-owner")
if perrowner != nil {
log.Error("Failed to get the domain value : %s", perrowner)
}
s, hook_err := client.CreateRepoHook(pair_owner.Value, strings.Replace(source[len(source)-1], ".git", "", -1), postHook)
if hook_err != nil {
return hook_err
}
//s, _ := client.ListRepoHooks(ci.Owner, strings.Replace(source[len(source)-1], ".git", "", -1))
log.Info("Hook created")
log.Info(s)
} else {
log.Info("gogs is skipped")
}
return nil
}
func cioperation(asm *global.AssemblyWithComponents, ci *global.Operations, com *global.Component) error {
pair_scm, perrscm := global.ParseKeyValuePair(ci.OperationRequirements, "ci-scm")
if perrscm != nil {
log.Error("Failed to get the domain value : %s", perrscm)
}
pair_enable, perrenable := global.ParseKeyValuePair(ci.OperationRequirements, "ci-enable")
if perrenable != nil {
log.Error("Failed to get the domain value : %s", perrenable)
}
if pair_scm.Value == GITLAB && pair_enable.Value == ENABLE {
log.Info("GitLab is working..")
pair_token, perrtoken := global.ParseKeyValuePair(ci.OperationRequirements, "ci-token")
if perrtoken != nil {
log.Error("Failed to get the ci-token value : %s", perrtoken)
}
pair_url, perrtoken := global.ParseKeyValuePair(ci.OperationRequirements, "ci-url")
if perrtoken != nil {
log.Error("Failed to get the ci-url value : %s", perrtoken)
}
pair_apiversion, perrtoken := global.ParseKeyValuePair(ci.OperationRequirements, "ci-apiversion")
if perrtoken != nil {
log.Error("Failed to get the ci-apiversion value : %s", perrtoken)
}
pair_owner, perrowner := global.ParseKeyValuePair(ci.OperationRequirements, "ci-owner")
if perrowner != nil {
log.Error("Failed to get the ci-owner value : %s", perrowner)
}
api_host, apierr := config.GetString("api:host")
if apierr != nil {
return apierr
}
api_version, apiverr := config.GetString("api:version")
if apiverr != nil {
return apiverr
}
trigger_url := "http://" + api_host + "/" + api_version + "/assembly/build/" + asm.Id + "/" + com.Id
client := gogitlab.NewGitlab(pair_url.Value, pair_apiversion.Value, pair_token.Value)
err := client.AddProjectHook(pair_owner.Value, trigger_url, false, false, false)
if err != nil {
return err
}
} else {
log.Info("GitLab is skipped")
}
return nil
}
func (i *Docker) Create(assembly *global.AssemblyWithComponents, id string, instance bool, act_id string) (string, error) {
log.Info("%q", assembly)
pair_endpoint, perrscm := global.ParseKeyValuePair(assembly.Inputs, "endpoint")
if perrscm != nil {
log.Error("Failed to get the endpoint value : %s", perrscm)
return "", perrscm
}
var endpoint string
if pair_endpoint.Value == BAREMETAL {
/*
* swarm host is obtained from conf file. Swarm host is considered
* only when the 'endpoint' is baremetal in the Component JSON
*/
api_host, _ := config.GetString("docker:swarm_host")
endpoint = api_host
container, cerr := create(assembly, endpoint)
if cerr != nil {
log.Error("container creation was failed : %s", cerr)
return "", cerr
}
pair_cpu, perrscm := global.ParseKeyValuePair(assembly.Inputs, "cpu")
if perrscm != nil {
log.Error("Failed to get the endpoint value : %s", perrscm)
}
pair_memory, iderr := global.ParseKeyValuePair(assembly.Inputs, "ram")
if iderr != nil {
log.Error("Failed to get the endpoint value : %s", iderr)
}
container.Cpu = pair_cpu.Value
container.Ram = pair_memory.Value
serr := StartContainer(container, endpoint)
if serr != nil {
log.Error("container starting error : %s", serr)
return "", serr
}
ipaddress, iperr := setContainerNAL(container)
if iperr != nil {
log.Error("set container network was failed : %s", iperr)
return "", iperr
}
container.IPAddress = ipaddress
herr := setHostName(container)
if herr != nil {
log.Error("set host name error : %s", herr)
}
updateContainerJSON(assembly, container, endpoint)
} else {
endpoint = pair_endpoint.Value
create(assembly, endpoint)
}
return "", nil
}
/*
* Docker API client to connect to swarm/docker VM.
* Swarm supports all docker API endpoints
*/
func create(assembly *global.AssemblyWithComponents, endpoint string) (*global.Container, error) {
pair_img, perrscm := global.ParseKeyValuePair(assembly.Components[0].Inputs, "source")
if perrscm != nil {
log.Error("Failed to get the image value : %s", perrscm)
return &global.Container{}, perrscm
}
pair_domain, perrdomain := global.ParseKeyValuePair(assembly.Components[0].Inputs, "domain")
if perrdomain != nil {
log.Error("Failed to get the image value : %s", perrdomain)
return &global.Container{}, perrdomain
}
client, _ := docker.NewClient(endpoint)
opts := docker.PullImageOptions{
Repository: pair_img.Value,
}
pullerr := client.PullImage(opts, docker.AuthConfiguration{})
if pullerr != nil {
log.Error("Image pulled failed : %s", pullerr)
return &global.Container{}, pullerr
}
dconfig := docker.Config{Image: pair_img.Value, NetworkDisabled: true}
copts := docker.CreateContainerOptions{Name: fmt.Sprint(assembly.Components[0].Name, ".", pair_domain.Value), Config: &dconfig}
/*
* Creation of the container with copts.
*/
container, conerr := client.CreateContainer(copts)
if conerr != nil {
log.Error("Container creation failed : %s", conerr)
return &global.Container{}, conerr
}
cont := &docker.Container{}
mapP, _ := json.Marshal(container)
json.Unmarshal([]byte(string(mapP)), cont)
inspect, _ := client.InspectContainer(cont.ID)
contI := &docker.Container{}
mapInsp, _ := json.Marshal(inspect)
json.Unmarshal([]byte(string(mapInsp)), contI)
ins, _ := client.InspectImage(pair_img.Value)
conti := &docker.Image{}
mapins, _ := json.Marshal(ins)
json.Unmarshal([]byte(string(mapins)), conti)
confi := &docker.Config{}
mapc, _ := json.Marshal(conti.ContainerConfig)
json.Unmarshal([]byte(string(mapc)), confi)
//ports := make([]string, len(confi.ExposedPorts))
var ports string
for k, _ := range confi.ExposedPorts {
//i := 0
porti := strings.Split(string(k), "/")
//ports[i] = porti[0]
ports = porti[0] + ", " + ports
//i++
}
swarmNode := &docker.SwarmNode{}
mapSwarm, _ := json.Marshal(contI.Node)
json.Unmarshal([]byte(string(mapSwarm)), swarmNode)
return &global.Container{ContainerID: cont.ID, ContainerName: cont.Name, SwarmNode: swarmNode.IP, Ports: ports}, nil
}