public async Task <String> createExperimentServiceAsync(String taskName, String dockerImage,
String experimenterPath, String jsonExperiment)
{
ServiceCreateParameters parameters = new ServiceCreateParameters();
parameters.Service = new ServiceSpec();
parameters.Service.Name = taskName;
parameters.Service.TaskTemplate = new TaskSpec();
parameters.Service.TaskTemplate.RestartPolicy = new SwarmRestartPolicy();
parameters.Service.TaskTemplate.RestartPolicy.Condition = "none";
parameters.Service.Mode = new ServiceMode();
parameters.Service.Mode.Replicated = new ReplicatedService();
parameters.Service.Mode.Replicated.Replicas = 1;
NetworkAttachmentConfig networkAttach1 = new NetworkAttachmentConfig();
networkAttach1.Target = "host";
IList <NetworkAttachmentConfig> networks = new List <NetworkAttachmentConfig>();
networks.Add(networkAttach1);
parameters.Service.TaskTemplate.Networks = networks;
parameters.Service.TaskTemplate.ContainerSpec = new ContainerSpec();
parameters.Service.TaskTemplate.ContainerSpec.Image = dockerImage;
IList <String> containerCommand = new List <String>();
containerCommand.Add(experimenterPath);
containerCommand.Add("--experiment-data '" + jsonExperiment + "'");
parameters.Service.TaskTemplate.ContainerSpec.Command = containerCommand;
ServiceCreateResponse response = await this.client.Swarm.CreateServiceAsync(parameters);
return(response.ID);
}
public async Task <bool> Reinitialize(ReinitServiceHttpParams reinitParams, SwarmService swarmService)
{
try
{
Logger.Log("Start server reinitializing");
this.DockerServiceId = swarmService.ID;
Id = reinitParams.Id;
UserId = reinitParams.UserId;
Base64File = reinitParams.FileBase64;
CountOfReplicas = reinitParams.CountOfReplicas;
DockerServiceId = swarmService.ID;
Dependencies = reinitParams.Dependencies;
FilePath = FileWorker.makeDirectoryName(Id, UserId);
Port = reinitParams.Port;
Logger.Log($"{reinitParams.UserId}-{reinitParams.Id} ({DockerServiceId}): Main parameters filled successfull");
NetworkAttachmentConfig networkAttachmentConfig = swarmService.Spec.Networks.FirstOrDefault();
Network = await Client.Docker.Networks.InspectNetworkAsync(networkAttachmentConfig.Target);
Logger.Log($"{reinitParams.UserId}-{reinitParams.Id}: Network created successfull");
return(true);
}
catch (Exception e)
{
Logger.Fail($"{reinitParams.UserId}-{reinitParams.Id}: {e.Message}");
return(false);
}
}
public async Task <bool> Update(string FileBase64)
{
try
{
Logger.Log($"updating service id : {Id} with DockerId {DockerServiceId}");
this.FilePath = CombineProgram(Id, UserId, FileBase64);
var serviceInfo = await Client.Docker.Swarm.InspectServiceAsync(DockerServiceId);
var Image = this.Image();
Logger.Log($"Service info gotten! Name is : {Name}, Version is: {serviceInfo.Version.Index}, Network ID is {Network.ID}, Image Id : {Image.ID}, Port: {Port}, this.FilePath: {this.FilePath}");
NetworkAttachmentConfig networkConfig = new NetworkAttachmentConfig()
{
Target = Network.ID
};
EndpointSpec endpointSpec = new EndpointSpec()
{
Ports = new List <PortConfig>()
{
new PortConfig()
{
Protocol = "tcp",
PublishedPort = uint.Parse(Port),
TargetPort = uint.Parse(Port)
}
}
};
Logger.Log("Endpoint created");
IList <Mount> mounts = new List <Mount>
{
new Mount()
{
Target = "/home/node/",
Source = this.FilePath,
}
};
Logger.Log("Mounts created");
TaskSpec taskSpec = new TaskSpec()
{
ForceUpdate = 1,
RestartPolicy = new SwarmRestartPolicy()
{
Condition = "any",
MaxAttempts = 0
},
ContainerSpec = new ContainerSpec()
{
Image = Image.ID,
Env = new List <string>()
{
$"PORT={Port}"
},
Hosts = new List <string>()
{
$"{Port}:{Port}"
},
Mounts = mounts,
Dir = "/home/node/",
Command = new List <string>()
{
"/bin/bash", "build.sh"
},
},
};
Logger.Log("Task spec created!");
ServiceSpec serviceSpec = new ServiceSpec()
{
Name = Name,
Networks = new List <NetworkAttachmentConfig>()
{
networkConfig
},
EndpointSpec = endpointSpec,
TaskTemplate = taskSpec,
};
Logger.Log("Service spec created!");
var serviceParams = new ServiceUpdateParameters()
{
Version = Convert.ToInt64(serviceInfo.Version.Index),
Service = serviceSpec
};
Logger.Log("Configuration is ready, updating...");
await Client.Docker.Swarm.UpdateServiceAsync(DockerServiceId, serviceParams);
Logger.Success($"Updated successful!");
return(true);
}
catch (Exception e)
{
Logger.Fail($"Cant update service {DockerServiceId} : {e.Message}");
return(false);
}
}
public async Task <bool> Create()
{
var networkParams = new NetworksCreateParameters()
{
Name = Name,
Driver = "overlay"
};
var networkList = await Client.Docker.Networks.ListNetworksAsync();
var existingNetwork = networkList.Where(el => el.Name == Name).ToList();
NetworkResponse network = null;
if (existingNetwork.Count == 0)
{
Logger.Log($"Network for service {Name} is existing!");
var createdNetwork = await Client.Docker.Networks.CreateNetworkAsync(networkParams);
network = await Client.Docker.Networks.InspectNetworkAsync(createdNetwork.ID);
}
else
{
network = existingNetwork.First();
}
Network = network;
Logger.Success($"Use network with Name : {network.Name}, count of replicas {CountOfReplicas}");
NetworkAttachmentConfig networkConfig = new NetworkAttachmentConfig()
{
Target = network.ID
};
Port = (3000 + ServiceLogic.Services.Count).ToString();
Logger.Success($"Predicted port is {Port}");
var serviceParams = new ServiceCreateParameters()
{
Service = new ServiceSpec()
{
Name = Name,
Networks = new List <NetworkAttachmentConfig>()
{
networkConfig
},
EndpointSpec = new EndpointSpec()
{
Ports = new List <PortConfig>()
{
new PortConfig()
{
Protocol = "tcp",
PublishedPort = uint.Parse(Port),
TargetPort = uint.Parse(Port)
}
}
},
Mode = new ServiceMode()
{
Replicated = new ReplicatedService()
{
Replicas = (ulong)(CountOfReplicas)
}
},
TaskTemplate = new TaskSpec()
{
ContainerSpec = new ContainerSpec()
{
Image = Image().ID,
Env = new List <string>()
{
$"PORT={Port}"
},
Hosts = new List <string>()
{
$"{Port}:${Port}"
},
Mounts = new List <Mount>
{
new Mount()
{
Target = "/home/node/",
Source = $"{this.FilePath}",
}
},
Dir = "/home/node/",
Command = new List <string>()
{
"/bin/bash", "build.sh"
},
},
}
}
};
try
{
var service = await Client.Docker.Swarm.CreateServiceAsync(serviceParams);
DockerServiceId = service.ID;
Logger.Success($"Service {service.ID} is Up!");
return(true);
}
catch (Exception e)
{
Logger.Fail($"Cant create the container: {e.Message}");
return(false);
}
}
