1.0.78

.gitlab-ci.yml

@@ -38,13 +38,11 @@ snyk:
 # test stage
 # ====================
 
-testLTS:
+testStable:
-  services:
-    - docker:18-dind
   stage: test
   script:
   - npmci npm prepare
-  - npmci node install lts
+  - npmci node install stable
   - npmci npm install
   - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
@@ -56,7 +54,7 @@ testBuild:
   stage: test
   script:
   - npmci npm prepare
-  - npmci node install lts
+  - npmci node install stable
   - npmci npm install
   - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
@@ -67,7 +65,7 @@ testBuild:
 release:
   stage: release
   script:
-  - npmci node install lts
+  - npmci node install stable
   - npmci npm publish
   only:
   - tags
@@ -102,7 +100,7 @@ trigger:
 pages:
   image: hosttoday/ht-docker-dbase:npmci
   services:
-   - docker:18-dind
+   - docker:stable-dind
   stage: metadata
   script:
     - npmci command npm install -g @gitzone/tsdoc

package-lock.json

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

package.json

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

scripts/testauth.ts

@@ -0,0 +1,11 @@
+import * as docker from '../ts';
+import * as smartstring from '@pushrocks/smartstring';
+
+const run  = async () => {
+  const dockerHost = new docker.DockerHost();
+  await docker.DockerImage.createFromRegistry(dockerHost, {
+    imageUrl: 'registry.gitlab.com/servezone/private/cloudly:latest'
+  });
+};
+
+run();

test/test.ts

@@ -72,7 +72,6 @@ tap.test('should remove a secret by name', async () => {
   await mySecret.remove();
 });
 
-
 // SERVICES
 tap.test('should activate swarm mode', async () => {
   await testDockerHost.activateSwarm();
@@ -88,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

@@ -3,6 +3,12 @@ import { DockerContainer } from './docker.classes.container';
 import { DockerNetwork } from './docker.classes.network';
 import { DockerService } from './docker.classes.service';
 
+export interface IAuthData {
+  serveraddress: string;
+  username: string;
+  password: string;
+}
+
 export class DockerHost {
   /**
    * the path where the docker sock can be found
@@ -31,26 +37,16 @@ export class DockerHost {
    * @param userArg
    * @param passArg
    */
-  public async auth(registryUrl: string, userArg: string, passArg: string) {
+  public async auth(authData: IAuthData) {
-    const response = await this.request('POST', '/auth', {
+    const response = await this.request('POST', '/auth', authData);
-      serveraddress: registryUrl,
-      username: userArg,
-      password: passArg
-    });
     if (response.body.Status !== 'Login Succeeded') {
       console.log(`Login failed with ${response.body.Status}`);
       throw new Error(response.body.Status);
     }
     console.log(response.body.Status);
-    this.registryToken = plugins.smartstring.base64.encode(response.body.IdentityToken);
+    this.registryToken = plugins.smartstring.base64.encode(
-  }
+      plugins.smartjson.Smartjson.stringify(authData, {})
-
+    );
-  /**
-   * sets an auth token
-   * @param authToken 
-   */
-  public setAuthToken(authToken: string) {
-    this.registryToken = authToken;
   }
 
   /**
@@ -59,7 +55,14 @@ export class DockerHost {
   public async getGitlabComTokenFromDockerConfig() {
     const dockerConfigPath = plugins.smartpath.get.home('~/.docker/config.json');
     const configObject = plugins.smartfile.fs.toObjectSync(dockerConfigPath);
-    this.registryToken = configObject.auths['registry.gitlab.com'].auth;
+    const gitlabAuthBase64 = configObject.auths['registry.gitlab.com'].auth;
+    const gitlabAuth: string = plugins.smartstring.base64.decode(gitlabAuthBase64);
+    const gitlabAuthArray = gitlabAuth.split(':');
+    await this.auth({
+      username: gitlabAuthArray[0],
+      password: gitlabAuthArray[1],
+      serveraddress: 'registry.gitlab.com'
+    });
   }
 
   /**
@@ -70,10 +73,9 @@ export class DockerHost {
   }
 
   /**
-   * 
+   *
    */
 
-
   /**
    * gets all containers
    */
@@ -171,6 +173,7 @@ export class DockerHost {
         method: methodArg,
         headers: {
           'Content-Type': 'application/json',
+          'X-Registry-Auth': this.registryToken,
           Host: 'docker.sock'
         },
         requestBody: null,

ts/docker.classes.image.ts

@@ -21,7 +21,6 @@ export class DockerImage {
       } else {
         return false;
       }
-      
     });
     return result;
   }
@@ -30,7 +29,6 @@ export class DockerImage {
     dockerHostArg: DockerHost,
     creationObject: interfaces.IImageCreationDescriptor
   ): Promise<DockerImage> {
-
     // lets create a sanatized imageUrlObject
     const imageUrlObject: {
       imageUrl: string;
@@ -46,9 +44,7 @@ export class DockerImage {
       const imageTag = imageUrlObject.imageUrl.split(':')[1];
       if (imageUrlObject.imageTag) {
         throw new Error(
-          `imageUrl ${imageUrlObject.imageUrl} can't be tagged with ${
+          `imageUrl ${imageUrlObject.imageUrl} can't be tagged with ${imageUrlObject.imageTag} because it is already tagged with ${imageTag}`
-            imageUrlObject.imageTag
-          } because it is already tagged with ${imageTag}`
         );
       } else {
         imageUrlObject.imageUrl = imageUrl;
@@ -141,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[]> {
@@ -90,4 +91,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.secret.ts

@@ -17,17 +17,20 @@ export class DockerSecret {
     return secrets;
   }
 
-  public static async getSecretByID (dockerHostArg: DockerHost, idArg: string) {
+  public static async getSecretByID(dockerHostArg: DockerHost, idArg: string) {
     const secrets = await this.getSecrets(dockerHostArg);
     return secrets.find(secret => secret.ID === idArg);
   }
 
-  public static async getSecretByName (dockerHostArg: DockerHost, nameArg: string) {
+  public static async getSecretByName(dockerHostArg: DockerHost, nameArg: string) {
     const secrets = await this.getSecrets(dockerHostArg);
     return secrets.find(secret => secret.Spec.Name === nameArg);
   }
 
-  public static async createSecret(dockerHostArg: DockerHost, secretDescriptor: interfaces.ISecretCreationDescriptor) {
+  public static async createSecret(
+    dockerHostArg: DockerHost,
+    secretDescriptor: interfaces.ISecretCreationDescriptor
+  ) {
     const labels: interfaces.TLabels = {
       ...secretDescriptor.labels,
       version: secretDescriptor.version
@@ -37,10 +40,13 @@ export class DockerSecret {
       Labels: labels,
       Data: plugins.smartstring.base64.encode(secretDescriptor.contentArg)
     });
-    
+
     const newSecretInstance = new DockerSecret(dockerHostArg);
     Object.assign(newSecretInstance, response.body);
-    Object.assign (newSecretInstance, await DockerSecret.getSecretByID(dockerHostArg, newSecretInstance.ID));
+    Object.assign(
+      newSecretInstance,
+      await DockerSecret.getSecretByID(dockerHostArg, newSecretInstance.ID)
+    );
     return newSecretInstance;
   }
 
@@ -51,7 +57,7 @@ export class DockerSecret {
     Labels: interfaces.TLabels;
   };
   public Version: {
-    Index:string;
+    Index: string;
   };
 
   public dockerHost: DockerHost;
@@ -62,22 +68,25 @@ export class DockerSecret {
   /**
    * updates a secret
    */
-  public async update (contentArg: string) {
+  public async update(contentArg: string) {
     const route = `/secrets/${this.ID}/update?=version=${this.Version.Index}`;
-    const response = await this.dockerHost.request('POST', `/secrets/${this.ID}/update?version=${this.Version.Index}`, {
+    const response = await this.dockerHost.request(
-      Name: this.Spec.Name,
+      'POST',
-      Labels: this.Spec.Labels,
+      `/secrets/${this.ID}/update?version=${this.Version.Index}`,
-      Data: plugins.smartstring.base64.encode(contentArg)
+      {
-    });
+        Name: this.Spec.Name,
+        Labels: this.Spec.Labels,
+        Data: plugins.smartstring.base64.encode(contentArg)
+      }
+    );
   }
 
-  public async remove () {
+  public async remove() {
     await this.dockerHost.request('DELETE', `/secrets/${this.ID}`);
   }
 
-
   // get things
   public async getVersion() {
     return this.Spec.Labels.version;
   }
-}
+}

ts/docker.classes.service.ts

@@ -41,7 +41,7 @@ export class DockerService {
       'info',
       `now creating service ${serviceCreationDescriptor.name}`
     );
-    
+
     // await serviceCreationDescriptor.image.pullLatestImageFromRegistry();
     const serviceVersion = await serviceCreationDescriptor.image.getVersion();
 
@@ -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,23 @@ 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
         },
         UpdateConfig: {
           Parallelism: 0,
@@ -87,10 +137,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 +192,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 +218,4 @@ export class DockerService {
       console.log(`service ${this.Spec.Name} is up to date.`);
     }
   }
-
-  public async updateFromRegistry() {
-    if (await this.needsUpdate()) {
-      this.update();
-    }
-  }
 }

ts/docker.plugins.ts

@@ -1,9 +1,7 @@
 // node native path
 import * as path from 'path';
 
-export {
+export { path };
-  path
-};
 
 // @pushrocks scope
 import * as lik from '@pushrocks/lik';
@@ -19,7 +17,18 @@ import * as smartversion from '@pushrocks/smartversion';
 
 smartlog.defaultLogger.enableConsole();
 
-export { lik, smartfile, smartjson, smartlog, smartnetwork, smartpath, smartpromise, smartrequest, smartstring, smartversion };
+export {
+  lik,
+  smartfile,
+  smartjson,
+  smartlog,
+  smartnetwork,
+  smartpath,
+  smartpromise,
+  smartrequest,
+  smartstring,
+  smartversion
+};
 
 // third party
 import * as rxjs from 'rxjs';

ts/interfaces/secret.ts

@@ -5,4 +5,4 @@ export interface ISecretCreationDescriptor {
   version: string;
   contentArg: any;
   labels: interfaces.TLabels;
-}
+}

ts/interfaces/service.ts

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