@aj-shadow/z-abs-funclayer-engine-server 0.0.0-aj-beta.221

package/project/server/engine/data/content-base.js

@@ -0,0 +1,91 @@
+
+'use strict';
+
+
+class ContentBase {
+  constructor(buffers, readData) {
+    this.buffers = undefined === buffers ? [] : (Array.isArray(buffers) ? buffers : [buffers]);
+    this.readData = readData;
+    this.currentBuffer = -1;
+  }
+  
+  getBuffer() {
+    if(!this.readData) {
+      return null;
+    }
+    if(this.readData.allRead) {
+      if(++this.currentBuffer < this.buffers.length) {
+        return this.buffers[this.currentBuffer];
+      }
+      else {
+        this.currentBuffer = -1;
+        return null;
+      }
+    }
+  }
+  
+  addBuffer(buffer) {
+    this.buffers.push(buffer);
+  }
+  
+  getLength() {
+    if(!this.readData) {
+      return 0;
+    }
+    else if(this.readData.allRead) {
+      return this.buffers.reduce((acc, current) => {
+        return acc + current.length;
+      }, 0);
+    }
+    else {
+      return -1;
+    }
+  }
+  
+  indexOf(value, start = 0) {
+    let bufferIndex = -1;
+    let index = start;
+    let length = 0;
+    let found = false;
+    while(++bufferIndex < this.buffers.length) {
+      if(start >= length) {
+        index = start - length;
+       // length = start;
+        bufferIndex -= 1;
+        found = true;
+        break;
+      }
+      length += this.buffers[bufferIndex].length;
+    }
+    if(!found) {
+      return -1;
+    }
+    while(++bufferIndex < this.buffers.length) {
+      index = this.buffers[bufferIndex].indexOf(value, index);
+      if(-1 !== index) {
+        return length + index;
+      }
+      else {
+        index = 0;
+        length += this.buffers[bufferIndex].length;
+      }
+      // TODO: overlapp between two buffers.
+    }
+    return -1;
+  }
+  
+  slice(start = 0, end = -1) {
+    if(-1 === end) {
+      end = this.getLength();
+    }
+    // TODO: support more than one buffer.
+    return this.buffers[0].slice(start, end);
+  }
+  
+  normalize() {
+    this.currentBuffer = -1;
+  }
+}
+
+
+module.exports = ContentBase;

package/project/server/engine/data/content-binary.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+const ContentBase = require('./content-base');
+
+
+class ContentBinary extends ContentBase {
+  constructor() {
+    super(undefined, {
+      allRead: true
+    });
+  }
+}
+
+module.exports = ContentBinary;

package/project/server/engine/data/content-cache.js

@@ -0,0 +1,67 @@
+ 
+'use strict';
+
+const ContentText = require('./content-text');
+const ContentDocuments = require('./content-documents');
+const ContentVideo = require('./content-video');
+const ContentAudio = require('./content-audio');
+const ContentImage = require('./content-image');
+const ContentOther = require('./content-other');
+const ActorPathContent = require('z-abs-corelayer-server/server/path/actor-path-content');
+const Fs = require('fs');
+
+
+class ContentCache {
+  constructor(constantData) {
+    this.constantData = constantData;
+    this.contents = new Map();
+  }
+  
+  *get(name, hint, actor) {
+    const content = this.contents.get(name);
+    if(undefined !== content) {
+      return content;
+    }
+    return yield this._getContent(name, hint, actor);
+  }
+  
+  _getContent(name, hint, actor) {
+    const pendingId = actor.setPending();
+    const contentDataC = this.constantData.get(name, hint);
+    if(!contentDataC) {
+      return actor.handlePendingId(pendingId, new Error(`Content with name: '${name}' does not exist.`));
+    }
+    Fs.readFile(ActorPathContent.getContentFile(contentDataC._repoPath, contentDataC.path), (err, buffer) => {
+      if(err) {
+        return actor.handlePendingId(pendingId, err);
+      }
+      const type = contentDataC._type;
+      let content = null;
+      if('text' === type) {
+        content = new ContentText(contentDataC, buffer, {allRead: true});
+      }
+      else if('documents' === type) {
+        content = new ContentDocuments(contentDataC, buffer, {allRead: true});
+      }
+      else if('video' === type) {
+        content = new ContentVideo(contentDataC, buffer, {allRead: true});
+      }
+      else if('audio' === type) {
+        content = new ContentAudio(contentDataC, buffer, {allRead: true});
+      }
+      else if('image' === type) {
+        content = new ContentImage(contentDataC, buffer, {allRead: true});
+      }
+      else if('other' === type) {
+        content = new ContentOther(contentDataC, buffer, {allRead: true});
+      }
+      else {
+        return actor.handlePendingId(pendingId, new Error(`Content type: '${type}' does not exist.`));
+      }
+      this.contents.set(name, content);
+      actor.handlePendingId(pendingId, err, content);
+    });
+  }
+}
+
+module.exports = ContentCache;

package/project/server/engine/data/content-data.js

@@ -0,0 +1,254 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const ActorPathContent = require('z-abs-corelayer-server/server/path/actor-path-content');
+const Fs = require('fs');
+
+
+class ContentData {
+  constructor() {
+    this.pendings = 0;
+    this.textContent = new Map();
+    this.documentsContent = new Map();
+    this.imageContent = new Map();
+    this.audioContent = new Map();
+    this.videoContent = new Map();
+    this.otherContent = new Map();
+  }
+  
+  // TODO: Handle multiple errors
+  
+ 
+  load(done) {
+    this.pendings = 0;
+    const repoPathGlobal = ActorPathContent.getContentGlobalFolder();
+    const repoPathLocal = ActorPathContent.getContentLocalFolder();
+    this._loadContent([
+      {
+        path: ActorPathData.getContentTextGlobalFile(),
+        repoPath: repoPathGlobal,
+        datas: this.textContent,
+        type: 'text'
+      },
+      {
+        path: ActorPathData.getContentDocumentsGlobalFile(),
+        repoPath: repoPathGlobal,
+        datas: this.documentsContent,
+        type: 'documents'
+      },
+      {
+        path: ActorPathData.getContentImageGlobalFile(),
+        repoPath: repoPathGlobal,
+        datas: this.imageContent,
+        type: 'image'
+      },
+      {
+        path: ActorPathData.getContentAudioGlobalFile(),
+        repoPath: repoPathGlobal,
+        datas: this.audioContent,
+        type: 'audio'
+      },
+      {
+        path: ActorPathData.getContentVideoGlobalFile(),
+        repoPath: repoPathGlobal,
+        datas: this.videoContent,
+        type: 'video'
+      },
+      {
+        path: ActorPathData.getContentOtherGlobalFile(),
+        repoPath: repoPathGlobal,
+        datas: this.otherContent,
+        type: 'other'
+      }
+    ], (err) => {
+      if(err) {
+        return done(err);
+      }
+      this._loadContent([
+        {
+          path: ActorPathData.getContentTextLocalFile(),
+          repoPath: repoPathLocal,
+          datas: this.textContent,
+          type: 'text'
+        },
+        {
+          path: ActorPathData.getContentDocumentsLocalFile(),
+          repoPath: repoPathLocal,
+          datas: this.documentsContent,
+          type: 'documents'
+        },
+        {
+          path: ActorPathData.getContentImageLocalFile(),
+          repoPath: repoPathLocal,
+          datas: this.imageContent,
+          type: 'image'
+        },
+        {
+          path: ActorPathData.getContentAudioLocalFile(),
+          repoPath: repoPathLocal,
+          datas: this.audioContent,
+          type: 'audio'
+        },
+        {
+          path: ActorPathData.getContentVideoLocalFile(),
+          repoPath: repoPathLocal,
+          datas: this.videoContent,
+          type: 'video'
+        },
+        {
+          path: ActorPathData.getContentOtherLocalFile(),
+          repoPath: repoPathLocal,
+          datas: this.otherContent,
+          type: 'other'
+        }
+      ], done);
+    });
+  }
+  
+  get(name, hint) {
+    switch(hint) {
+      case 'image': {
+        const contentData = this.imageContent.get(name);
+        if(undefined !== contentData) {
+          return contentData;
+        }
+      }
+      case 'audio': {
+        const contentData = this.audioContent.get(name);
+        if(undefined !== contentData) {
+          return contentData;
+        }
+      }
+    }
+    let contentData = this.otherContent.get(name);
+    if(undefined !== contentData) {
+      return contentData;
+    }
+    contentData = this.imageContent.get(name);
+    if(undefined !== contentData) {
+      return contentData;
+    }
+    contentData = this.audioContent.get(name);
+    if(undefined !== contentData) {
+      return contentData;
+    }
+  }
+  
+  _loadContent(contentsToLoad, done) {
+    let errorResponse = false;
+    for(let i = 0; i < contentsToLoad.length; ++i) {
+      ++this.pendings;
+      Fs.readFile(contentsToLoad[i].path, (err, data) => {
+        if(!errorResponse) {
+          if(err) {
+            errorResponse = true;
+            done(err);
+          }
+          else {
+            const contentDatas = JSON.parse(data);
+            const type = contentsToLoad[i].type;
+            const repoPath = contentsToLoad[i].repoPath;
+            switch(type) {
+              case 'text': {
+                contentDatas.forEach((contentData) => {
+                  contentsToLoad[i].datas.set(contentData.name, {
+                    _repoPath: repoPath,
+                    _type: type,
+                    name: contentData.name,
+                    path: contentData.path,
+                    mime: contentData.mime,
+                    encoding: contentData.encoding,
+                    size: Number.parseInt(contentData.size),
+                    description: contentData.description
+                  });
+                });
+                break;
+              }
+              case 'documents': {
+                contentDatas.forEach((contentData) => {
+                  contentsToLoad[i].datas.set(contentData.name, {
+                    _repoPath: repoPath,
+                    _type: type,
+                    name: contentData.name,
+                    path: contentData.path,
+                    mime: contentData.mime,
+                    size: Number.parseInt(contentData.size),
+                    description: contentData.description
+                  });
+                });
+                break;
+              }
+              case 'image': {
+                contentDatas.forEach((contentData) => {
+                  contentsToLoad[i].datas.set(contentData.name, {
+                    _repoPath: repoPath,
+                    _type: type,
+                    name: contentData.name,
+                    path: contentData.path,
+                    mime: contentData.mime,
+                    size: Number.parseInt(contentData.size),
+                    width: Number.parseInt(contentData.width),
+                    height: Number.parseInt(contentData.height),
+                    description: contentData.description
+                  });
+                });
+                break;
+              }
+              case 'audio': {
+                contentDatas.forEach((contentData) => {
+                  contentsToLoad[i].datas.set(contentData.name, {
+                    _repoPath: repoPath,
+                    _type: type,
+                    name: contentData.name,
+                    path: contentData.path,
+                    mime: contentData.mime,
+                    size: Number.parseInt(contentData.size),
+                    description: contentData.description
+                  });
+                });
+                break;
+              }
+              case 'video': {
+                contentDatas.forEach((contentData) => {
+                  contentsToLoad[i].datas.set(contentData.name, {
+                    _repoPath: repoPath,
+                    _type: type,
+                    name: contentData.name,
+                    path: contentData.path,
+                    mime: contentData.mime,
+                    size: Number.parseInt(contentData.size),
+                    width: Number.parseInt(contentData.width),
+                    height: Number.parseInt(contentData.height),
+                    description: contentData.description
+                  });
+                });
+                break;
+              }
+              case 'other': {
+                contentDatas.forEach((contentData) => {
+                  contentsToLoad[i].datas.set(contentData.name, {
+                    _repoPath: repoPath,
+                    _type: type,
+                    name: contentData.name,
+                    path: contentData.path,
+                    mime: contentData.mime,
+                    size: Number.parseInt(contentData.size),
+                    properties: contentData.properties,
+                    description: contentData.description
+                  });
+                });
+                break;
+              }
+            }
+            if(0 === --this.pendings) {
+              return done();
+            }
+          }
+        }
+      });
+    }
+  }
+}
+
+module.exports = ContentData;

package/project/server/engine/data/content-documents.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const ContentBase = require('./content-base');
+
+
+class ContentDocuments extends ContentBase {
+  constructor(contentData, buffers, readData) {
+    super(buffers, readData);
+    this.name = contentData.name;
+    this.path = contentData.path;
+    this.mime = contentData.mime;
+    this.size = contentData.size;
+    this.description = contentData.description;
+  }
+}
+
+module.exports = ContentDocuments;

package/project/server/engine/data/content-image.js

@@ -0,0 +1,20 @@
+
+'use strict';
+
+const ContentBase = require('./content-base');
+
+
+class ContentImage extends ContentBase {
+  constructor(contentData, buffers, readData) {
+    super(buffers, readData);
+    this.name = contentData.name;
+    this.path = contentData.path;
+    this.mime = contentData.mime;
+    this.size = contentData.size;
+    this.width = contentData.width;
+    this.height = contentData.height;
+    this.description = contentData.description;
+  }
+}
+
+module.exports = ContentImage;

package/project/server/engine/data/content-other.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const ContentBase = require('./content-base');
+
+
+class ContentOther extends ContentBase {
+  constructor(contentData, buffers, readData) {
+    super(buffers, readData);
+    this.name = contentData.name;
+    this.path = contentData.path;
+    this.mime = contentData.mime;
+    this.size = contentData.size;
+    this.properties = contentData.properties;
+    this.description = contentData.description;
+  }
+}
+
+module.exports = ContentOther;

package/project/server/engine/data/content-text.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const ContentBase = require('./content-base');
+
+
+class ContentText extends ContentBase {
+  constructor(contentData, buffers, readData) {
+    super(buffers, readData);
+    this.name = contentData.name;
+    this.path = contentData.path;
+    this.mime = contentData.mime;
+    this.encoding = contentData.encoding;
+    this.size = contentData.size;
+    this.description = contentData.description;
+  }
+}
+
+module.exports = ContentText;

package/project/server/engine/data/content-undefined.js

@@ -0,0 +1,14 @@
+
+'use strict';
+
+const ContentBase = require('./content-base');
+
+
+class ContentUndefined extends ContentBase {
+  constructor() {
+    super();
+    this.size = 0;
+  }
+}
+
+module.exports = ContentUndefined;

package/project/server/engine/data/content-video.js

@@ -0,0 +1,20 @@
+
+'use strict';
+
+const ContentBase = require('./content-base');
+
+
+class ContentVideo extends ContentBase {
+  constructor(contentData, buffers, readData) {
+    super(buffers, readData);
+    this.name = contentData.name;
+    this.path = contentData.path;
+    this.mime = contentData.mime;
+    this.size = contentData.size;
+    this.width = contentData.width;
+    this.height = contentData.height;
+    this.description = contentData.description;
+  }
+}
+
+module.exports = ContentVideo;

package/project/server/engine/data/content.js

@@ -0,0 +1,60 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const ActorPathContent = require('z-abs-corelayer-server/server/path/actor-path-content');
+const Fs = require('fs');
+
+
+class Content {
+  constructor() {
+    this.pendings = 0;
+    this.imageContent = new Map();
+  }
+  
+  // TODO: Handle multiple errors
+  
+  load(done) {
+    this._loadGlobalContent([
+      {
+        path: ActorPathData.getContentImageGlobalFile(),
+        datas: this.imageContent
+      }
+    ], done);
+    this._loadGeneralContent(done);
+  }
+  
+  _loadGlobalContent(contentsToLoad, done) {
+    this.pendings = 0;
+    let errorResponse = false;
+    for(let i = 0; i < contentsToLoad.length; ++i) {
+      ++this.pendings;
+      Fs.readFile(contentsToLoad[i].path, (err, data) => {
+        if(!errorResponse) {
+          if(err) {
+            errorResponse = true;
+            done(err);
+          }
+          else {
+            let contentDatas = JSON.parse(data);
+            contentDatas.forEach((contentData) => {
+              contentsToLoad[i].datas.set(contentData.name, {
+                repoPath: ActorPathContent.getContentGlobalFolder(),
+                value: contentData
+              });
+            });
+            if(0 === --this.pendings) {
+              return done();
+            }
+          }
+        }
+      });
+    }
+  }
+  
+  _loadGeneralGlobalContent(done) {
+    
+  }
+}
+
+module.exports = Content;

package/project/server/engine/data/runtime-data-shared.js

@@ -0,0 +1,75 @@
+
+'use strict';
+
+
+class RuntimeDataShared {
+  constructor() {
+    this.sharedDatas = new Map();
+  }
+  
+  set(key, value) {
+    const sharedDataObject = this.sharedDatas.get(key);
+    if(sharedDataObject) {
+      sharedDataObject.value = value;
+      sharedDataObject.isSet = true;
+      return sharedDataObject;
+    }
+    else {
+      const newSharedDataObject = {
+        value: value,
+        isSet: true,
+        pendings: []
+      };
+      this.sharedDatas.set(key, newSharedDataObject);
+      return newSharedDataObject;
+    }
+  }
+  
+  wait(key, actor, expectedValue, cbGetPending) {
+    const sharedDataObject = this.sharedDatas.get(key);
+    if(sharedDataObject) {
+      if(sharedDataObject.isSet && (expectedValue === sharedDataObject.value || undefined === expectedValue)) {
+        return sharedDataObject.value;
+      }
+      else {
+        const pending = cbGetPending();
+        sharedDataObject.pendings.push({
+          actor: actor,
+          pendingId: pending.id,
+          cancelObject: pending.cancelObject,
+          expectedValue: expectedValue
+        });
+      }
+    }
+    else {
+      const pending = cbGetPending();
+      this.sharedDatas.set(key, {
+        value: undefined,
+        isSet: false,
+        pendings: [{
+          actor: actor,
+          pendingId: pending.id,
+          cancelObject: pending.cancelObject,
+          expectedValue: expectedValue
+        }]
+      });
+    }
+    return null;
+  }
+  
+  get(key) {
+    return this.sharedDatas.get(key);
+  }
+  
+  has(key) {
+    return this.sharedDatas.has(key);
+  }
+  
+  log() {
+    this.sharedDatas.forEach((sharedData, key) => {
+      ddb.info(`key: '${key}' - value: '${sharedData.value}' - pendings: ${shared.pendings.length}`);
+    });
+  }
+}
+
+module.exports = RuntimeDataShared;