public async Task CreateNetworkAsync(string name, CancellationToken token = default)
{
var networksCreateParameters = new NetworksCreateParameters
{
Name = name
};
await client.Networks.CreateNetworkAsync(networksCreateParameters, token).ConfigureAwait(false);
}
public async Task <string> CreateNetworkAsync(string name, CancellationToken token = default(CancellationToken))
{
var networksCreateParameters = new NetworksCreateParameters
{
Name = name
};
var response = await client.Networks.CreateNetworkAsync(networksCreateParameters, token).ConfigureAwait(false);
return(response.ID);
}
public async Task <NetworksCreateResponse> CreateNetworkAsync(NetworksCreateParameters parameters, CancellationToken cancellationToken = default(CancellationToken))
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
var data = new JsonRequestContent <NetworksCreateParameters>(parameters, this._client.JsonSerializer);
var response = await this._client.MakeRequestAsync(this._client.NoErrorHandlers, HttpMethod.Post, "networks/create", null, data, null, cancellationToken).ConfigureAwait(false);
return(this._client.JsonSerializer.DeserializeObject <NetworksCreateResponse>(response.Body));
}
public async Task <NetworksCreateResponse> CreateNetworkAsync(NetworksCreateParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
var path = "networks/create";
var data = new JsonRequestContent <NetworksCreateParameters>(parameters, this.Client.JsonSerializer);
var response = await this.Client.MakeRequestAsync(this.Client.NoErrorHandlers, HttpMethod.Get, path, null, data).ConfigureAwait(false);
return(this.Client.JsonSerializer.DeserializeObject <NetworksCreateResponse>(response.Body));
}
public async Task <string> CreateAsync(ITestcontainersNetworkConfiguration configuration, CancellationToken ct = default)
{
var createParameters = new NetworksCreateParameters
{
Name = configuration.Name,
Driver = configuration.Driver.Value,
Labels = configuration.Labels.ToDictionary(item => item.Key, item => item.Value),
};
var id = (await this.Docker.Networks.CreateNetworkAsync(createParameters, ct)
.ConfigureAwait(false)).ID;
this.logger.DockerNetworkCreated(id);
return(id);
}
public async Task CreateNetwork()
{
NetworksCreateParameters ncp = new NetworksCreateParameters
(
new NetworkCreate()
{
Attachable = true,
CheckDuplicate = true,
}
)
{
Name = DENNETWORK_NAME
};
NetworksCreateResponse response = await this.DockerClient.Networks.CreateNetworkAsync(ncp);
this.NetworkId = response.ID;
}
/// <summary>
/// Creates a new Docker network with fixed name and gateway.
/// if named network exists with specified fixed gateway address, gets the existing one.
/// </summary>
/// <returns>Docker network ID</returns>
internal static string SetupIntegrationTestsNetwork()
{
var client = new DockerClientConfiguration().CreateClient();
var networks = client.Networks.ListNetworksAsync().Result;
var network = networks.FirstOrDefault(x => x.Name == IntegrationTestsNetworkName);
if (network != null)
{
if (network.IPAM.Config[0].Gateway == IntegrationTestsGateway)
{
return(network.ID);
}
else
{
client.Networks.DeleteNetworkAsync(network.ID).Wait();
}
}
var networkParams = new NetworksCreateParameters()
{
Name = IntegrationTestsNetworkName,
Driver = "nat",
IPAM = new IPAM()
{
Config = new List <IPAMConfig>()
}
};
networkParams.IPAM.Config.Add(new IPAMConfig()
{
Gateway = IntegrationTestsGateway,
Subnet = "10.1.1.0/24"
});
var result = client.Networks.CreateNetworkAsync(networkParams).Result;
if (string.IsNullOrWhiteSpace(result.ID))
{
throw new Exception("Could not create docker network");
}
return(result.ID);
}
public async Task <NetworksCreateResponse> CreateNetworkAsync(NetworksCreateParameters parameters)
{
using var connection = await _dockerClient.ConnectAsync();
var networks = connection.Networks;
try
{
var response = await networks.CreateNetworkAsync(parameters);
_logger.LogInformation("Successfully created network with id '{Id}'.", response.ID);
return(response);
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Could not create the requested network.");
return(null);
}
}
public async Task <NetworksCreateResponse> CreateNetwork(NetworksCreateParameters createPrm)
{
var result = await _client.Networks.CreateNetworkAsync(createPrm);
return(result);
}
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);
}
}
