Merge branch 'main' of https://github.com/apocas/dockerode-compose

Author: apocas

lib/networks.js

@@ -3,6 +3,19 @@ module.exports = async function (docker, projectName, recipe, output) {
   var networkNames = Object.keys(recipe.networks || []);
   for (var networkName of networkNames) {
     var network = recipe.networks[networkName];
+    if (network === null) {
+      try {
+        networks.push({ "name": projectName + '_' + networkName, "network": await docker.createNetwork({ 'Name': projectName + '_' + networkName, 'CheckDuplicate': true }) });
+      } catch (err) {
+        if (err.statusCode == 409 && err.json.message.includes("already exists")) {
+          let returnedNetwork = await docker.listNetworks({ "filters": { "name": [projectName + '_' + networkName] } })
+          networks.push({ "name": projectName + '_' + networkName, "network": await docker.getNetwork(returnedNetwork[0].Id) })
+        } else {
+          throw err;
+        }
+      }
+      continue
+    }
     if (network.external === true) continue;
     var opts = {
       'Name': projectName + '_' + networkName,
@@ -32,17 +45,23 @@ module.exports = async function (docker, projectName, recipe, output) {
       }
     }
     try {
-      networks.push(await docker.createNetwork(opts));
+      networks.push({ "name": projectName + '_' + networkName, "network": await docker.createNetwork(opts) });
     } catch (err) {
+      //if exists we have to compare with the existing network
       throw err;
     }
   }
 
   if (networks.length === 0) {
     try {
-      await docker.createNetwork({ 'Name': projectName + '_default', 'CheckDuplicate': true });
+      networks.push({ "name": projectName + '_' + networkName, "network": await docker.createNetwork({ 'Name': projectName + '_default', 'CheckDuplicate': true }) });
     } catch (err) {
-      throw err;
+      if (err.statusCode == 409 && err.json.message.includes("already exists")) {
+        let returnedNetwork = await docker.listNetworks({ "filters": { "name": [projectName + '_default'] } })
+        networks.push({ "name": projectName + '_' + networkName, "network": await docker.getNetwork(returnedNetwork[0].Id) })
+      } else {
+        throw err;
+      }
     }
   }
 

lib/services.js

@@ -4,6 +4,7 @@ module.exports = async function (docker, projectName, recipe, output) {
   var services = [];
   var serviceNames = tools.sortServices(recipe);
   for (var serviceName of serviceNames) {
+    var networksToAttach = [];
     var service = recipe.services[serviceName];
 
     var opts = {
@@ -17,13 +18,67 @@ module.exports = async function (docker, projectName, recipe, output) {
       }
     };
 
-    opts.NetworkingConfig.EndpointsConfig[projectName + '_default'] = {
-      'IPAMConfig': {},
-      'Links': [],
-      'Aliases': [
-        serviceName,
-      ]
-    };
+    if (service.networks !== undefined) {
+      if (Array.isArray(service.networks)) {
+        for (let index = 0; index < service.networks.length; index++) {
+          let networkName = projectName + '_' + service.networks[index]
+          let networkTemplate = {
+            'NetworkingConfig': {
+              'EndpointsConfig': {
+              }
+            }
+          }
+          networkTemplate.NetworkingConfig.EndpointsConfig[networkName] = {};
+          networkTemplate.NetworkingConfig.EndpointsConfig[networkName]['Aliases'] = [serviceName]
+          if (index === 0)
+            opts.NetworkingConfig.EndpointsConfig = networkTemplate.NetworkingConfig.EndpointsConfig
+
+          networksToAttach.push(networkTemplate.NetworkingConfig.EndpointsConfig)
+        }
+      } else {
+        let networkNames = Object.keys(service.networks);
+        for (let index = 0; index < networkNames.length; index++) {
+          let network = service.networks[networkNames[index]] || {};
+          let networkName = projectName + '_' + networkNames[index]
+          let networkTemplate = {
+            'NetworkingConfig': {
+              'EndpointsConfig': {
+              }
+            }
+          }
+          networkTemplate.NetworkingConfig.EndpointsConfig[networkName] = {}
+          networkTemplate.NetworkingConfig.EndpointsConfig[networkName]['IPAMConfig'] = {}
+          if (network.aliases !== undefined) {
+            networkTemplate.NetworkingConfig.EndpointsConfig[networkName]['Aliases'] = network.aliases
+          }
+          if (network.ipv4_address !== undefined) {
+            networkTemplate.NetworkingConfig.EndpointsConfig[networkName].IPAMConfig['IPv4Address'] = network.ipv4_address
+          }
+          if (network.ipv6_address !== undefined) {
+            networkTemplate.NetworkingConfig.EndpointsConfig[networkName].IPAMConfig['IPv6Address'] = network.ipv6_address
+          }
+          if (network.link_local_ips !== undefined) {
+            networkTemplate.NetworkingConfig.EndpointsConfig[networkName].IPAMConfig['LinkLocalIPs'] = network.link_local_ips
+          }
+          if (network.priority !== undefined) {
+            networkTemplate.NetworkingConfig.EndpointsConfig[networkName].priority = network.priority
+          } else {
+            networkTemplate.NetworkingConfig.EndpointsConfig[networkName].priority = 0
+          }
+          if (index === 0)
+            opts.NetworkingConfig.EndpointsConfig = networkTemplate.NetworkingConfig.EndpointsConfig
+          networksToAttach.push(networkTemplate.NetworkingConfig.EndpointsConfig)
+        }
+      }
+    } else {
+      opts.NetworkingConfig.EndpointsConfig[projectName + '_default'] = {
+        'IPAMConfig': {},
+        'Links': [],
+        'Aliases': [
+          serviceName,
+        ]
+      };
+    }
 
     if (service.volumes) {
       opts['Volumes'] = {};
@@ -44,6 +99,19 @@ module.exports = async function (docker, projectName, recipe, output) {
     }
     try {
       var container = await docker.createContainer(opts);
+
+      if (networksToAttach.length > 1) {
+        let networkNames = Object.keys(networksToAttach[0]);
+        let network = findNetwork(output, networkNames[0])
+        await network.disconnect({ 'Container': container.id })
+        let networksToAttachSorted = tools.sortNetworksToAttach(networksToAttach)
+        for (var networkToAttach of networksToAttachSorted) {
+          let networkName = Object.keys(networkToAttach);
+          let network = findNetwork(output, networkName)
+          await network.connect({ 'Container': container.id, 'EndpointConfig': networkToAttach[networkName] })
+        }
+
+      }
       await container.start();
       services.push(container);
     } catch (err) {
@@ -105,4 +173,12 @@ var buildEnvVars = function (service) {
     output.push(envName + '=' + service.environment[envName])
   }
   return output;
+}
+
+
+var findNetwork = function (output, name) {
+  for (var network of output.networks) {
+    if (network.name == name)
+      return network.network
+  }
 }

lib/tools.js

@@ -5,12 +5,36 @@ module.exports = {
 
     while (order.length !== serviceNames.length) {
       for (var serviceName of serviceNames) {
-        if(order.indexOf(serviceName) === -1) {
+        if (order.indexOf(serviceName) === -1) {
           insertService(serviceName, recipe.services[serviceName].depends_on || [], order)
         }
       }
     }
     return order;
+  },
+  'sortNetworksToAttach': function (networksToAttach) {
+    var networksToAttachSorted = [];
+    for (let i = 0; i < networksToAttach.length; i++) {
+      let networkName = Object.keys(networksToAttach[i]);
+      if (i === 0) {
+        networksToAttachSorted.push(networksToAttach[i])
+      } else {
+        let aux = 0;
+        for (let j = 0; j < networksToAttachSorted.length; j++) {
+          let networkNameSorted = Object.keys(networksToAttachSorted[j]);
+          if (networksToAttachSorted[j][networkNameSorted].priority > networksToAttach[i][networkName].priority) {
+            aux += j + 1;
+          } else if (networksToAttachSorted[j][networkNameSorted].priority < networksToAttach[i][networkName].priority) {
+            aux += j - 1;
+          } else {
+            aux += j + 1;
+          }
+        }
+        if (aux < 0) aux = 0;
+        networksToAttachSorted.splice(aux, 0, networksToAttach[i]);
+      }
+    }
+    return networksToAttachSorted
   }
 }