1.0.80

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojoio/docker",
-  "version": "1.0.65",
+  "version": "1.0.80",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojoio/docker",
-  "version": "1.0.65",
+  "version": "1.0.80",
   "description": "easy communication with docker remote api from node, TypeScript ready",
   "private": false,
   "main": "dist/index.js",

test/test.ts

@@ -87,28 +87,24 @@ tap.test('should create a service', async () => {
     Name: 'testNetwork'
   });
   const testSecret = await docker.DockerSecret.createSecret(testDockerHost, {
-    name: 'serviceSecret',
+    name: 'testSecret',
     version: '0.0.1',
     labels: {},
     contentArg: '{"hi": "wow"}'
   });
   const testImage = await docker.DockerImage.createFromRegistry(testDockerHost, {
-    imageUrl: 'nginx:latest'
+    imageUrl: 'registry.gitlab.com/hosttoday/ht-docker-static'
   });
   const testService = await docker.DockerService.createService(testDockerHost, {
     image: testImage,
-    labels: {
+    labels: {},
-      testlabel: 'hi'
-    },
     name: 'testService',
     networks: [testNetwork],
     networkAlias: 'testService',
-    secrets: [testSecret]
+    secrets: [testSecret],
+    ports: ['3000:80']
   });
 
-  await testSecret.update(`{"updated": "socool"}`);
-  await testService.update();
-
   await testService.remove();
   await testNetwork.remove();
   await testSecret.remove();

ts/docker.classes.host.ts

@@ -62,7 +62,7 @@ export class DockerHost {
       username: gitlabAuthArray[0],
       password: gitlabAuthArray[1],
       serveraddress: 'registry.gitlab.com'
-    })
+    });
   }
 
   /**

ts/docker.classes.image.ts

@@ -137,6 +137,10 @@ export class DockerImage {
 
   // get stuff
   public async getVersion() {
-    return this.Labels.version;
+    if (this.Labels && this.Labels.version) {
+      return this.Labels.version;
+    } else {
+      return 'x.x.x';
+    }
   }
 }

ts/docker.classes.network.ts

@@ -2,6 +2,7 @@ import * as plugins from './docker.plugins';
 import * as interfaces from './interfaces';
 
 import { DockerHost } from './docker.classes.host';
+import { DockerService } from './docker.classes.service';
 
 export class DockerNetwork {
   public static async getNetworks(dockerHost: DockerHost): Promise<DockerNetwork[]> {
@@ -29,16 +30,6 @@ export class DockerNetwork {
       CheckDuplicate: true,
       Driver: 'overlay',
       EnableIPv6: false,
-      IPAM: {
-        Driver: 'default',
-        Config: [
-          {
-            Subnet: '172.20.10.0/16',
-            IPRange: '172.20.10.0/24',
-            Gateway: '172.20.10.11'
-          }
-        ]
-      },
       Internal: true,
       Attachable: true,
       Ingress: false
@@ -90,4 +81,29 @@ export class DockerNetwork {
   public async remove() {
     const response = await this.dockerHost.request('DELETE', `/networks/${this.Id}`);
   }
+
+  public async getContainersOnNetwork(): Promise<Array<{
+      Name: string;
+      EndpointID: string;
+      MacAddress: string;
+      IPv4Address: string;
+      IPv6Address: string;
+    }>> {
+    const returnArray = [];
+    const response = await this.dockerHost.request('GET', `/networks/${this.Id}`);
+    for (const key of Object.keys(response.body.Containers)) {
+      returnArray.push(response.body.Containers[key]);
+    }
+
+    return returnArray;
+
+  }
+
+  public async getContainersOnNetworkForService(serviceArg: DockerService) {
+    const containersOnNetwork = await this.getContainersOnNetwork();
+    const containersOfService = containersOnNetwork.filter(container => {
+      return container.Name.startsWith(serviceArg.Spec.Name);
+    });
+    return containersOfService;
+  }
 }

ts/docker.classes.service.ts

@@ -50,7 +50,34 @@ export class DockerService {
       version: serviceVersion
     };
 
-    const networkArray: any[] = [];
+    const mounts: Array<{
+      /**
+       * the target inside the container
+       */
+      Target: string;
+      /**
+       * The Source from which to mount the data (Volume or host path)
+       */
+      Source: string;
+      Type: 'bind' | 'volume' | 'tmpfs' | 'npipe';
+      ReadOnly: boolean;
+      Consistency: 'default' | 'consistent' | 'cached' | 'delegated';
+    }> = [];
+    if (serviceCreationDescriptor.accessHostDockerSock) {
+      mounts.push({
+        Target: '/var/run/docker.sock',
+        Source: '/var/run/docker.sock',
+        Consistency: 'default',
+        ReadOnly: false,
+        Type: 'bind'
+      });
+    }
+
+    const networkArray: Array<{
+      Target: string;
+      Aliases: string[];
+    }> = [];
+
     for (const network of serviceCreationDescriptor.networks) {
       networkArray.push({
         Target: network.Name,
@@ -58,11 +85,24 @@ export class DockerService {
       });
     }
 
+    const ports = [];
+    for (const port of serviceCreationDescriptor.ports) {
+      const portArray = port.split(':');
+      const hostPort = portArray[0];
+      const containerPort = portArray[1];
+      ports.push({
+        Protocol: 'tcp',
+        PublishedPort: parseInt(hostPort, 10),
+        TargetPort: parseInt(containerPort, 10)
+      });
+    }
+
+    // lets configure secrets
     const secretArray: any[] = [];
     for (const secret of serviceCreationDescriptor.secrets) {
       secretArray.push({
         File: {
-          Name: 'secret.json',
+          Name: 'secret.json', // TODO: make sure that works with multiple secrets
           UID: '33',
           GID: '33',
           Mode: 384
@@ -72,13 +112,26 @@ export class DockerService {
       });
     }
 
+    // lets configure limits
+    const limits = {
+      MemoryBytes: 1000 * 1000000
+    };
+
+    if (serviceCreationDescriptor.resources) {
+      limits.MemoryBytes = serviceCreationDescriptor.resources.memorySizeMB * 1000000;
+    }
+
     const response = await dockerHost.request('POST', '/services/create', {
       Name: serviceCreationDescriptor.name,
       TaskTemplate: {
         ContainerSpec: {
           Image: serviceCreationDescriptor.image.RepoTags[0],
           Labels: labels,
-          Secrets: secretArray
+          Secrets: secretArray,
+          Mounts: mounts,
+          DNSConfig: {
+            Nameservers: ['1.1.1.1']
+          }
         },
         UpdateConfig: {
           Parallelism: 0,
@@ -87,10 +140,16 @@ export class DockerService {
           Monitor: 15000000000,
           MaxFailureRatio: 0.15
         },
-        ForceUpdate: 1
+        ForceUpdate: 1,
+        Resources: {
+          Limits: limits
+        }
       },
-      Labels: serviceCreationDescriptor.labels,
+      Labels: labels,
-      Networks: networkArray
+      Networks: networkArray,
+      EndpointSpec: {
+        Ports: ports
+      }
     });
 
     const createdService = await DockerService.getServiceByName(
@@ -136,32 +195,13 @@ export class DockerService {
     this.dockerHostRef = dockerHostArg;
   }
 
-  public async update() {
-    const labels: interfaces.TLabels = {
-      ...this.Spec.Labels,
-      version: 'x.x.x'
-    };
-
-    const dockerData = await this.dockerHostRef.request(
-      'POST',
-      `/services/${this.ID}/update?version=${this.Version.Index}`,
-      {
-        Name: this.Spec.Name,
-        TaskTemplate: this.Spec.TaskTemplate,
-        Labels: labels,
-        Networks: this.Spec.Networks
-      }
-    );
-    Object.assign(this, dockerData);
-  }
-
   public async remove() {
     await this.dockerHostRef.request('DELETE', `/services/${this.ID}`);
   }
 
   public async reReadFromDockerEngine() {
     const dockerData = await this.dockerHostRef.request('GET', `/services/${this.ID}`);
-    Object.assign(this, dockerData);
+    // TODO: Better assign: Object.assign(this, dockerData);
   }
 
   public async needsUpdate(): Promise<boolean> {
@@ -181,10 +221,4 @@ export class DockerService {
       console.log(`service ${this.Spec.Name} is up to date.`);
     }
   }
-
-  public async updateFromRegistry() {
-    if (await this.needsUpdate()) {
-      this.update();
-    }
-  }
 }

ts/interfaces/service.ts

@@ -10,4 +10,9 @@ export interface IServiceCreationDescriptor {
   networks: DockerNetwork[];
   networkAlias: string;
   secrets: DockerSecret[];
+  ports: string[];
+  accessHostDockerSock?: boolean;
+  resources?: {
+    memorySizeMB: number
+  };
 }