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

package/project/server/plugin-component.js

@@ -0,0 +1,92 @@
+
+'use strict';
+
+const PluginFactory = require('./plugin-factory');
+
+
+class PluginComponent {
+  constructor(client) {
+    this.componentName = this.constructor.name;
+    this.pluginService = null;
+    this.state = PluginComponent.STATE_NONE;
+    this.cb = null;
+  }
+  
+  static STATE_NONE = 0;
+  static STATE_INITIALIZING = 1;
+  static STATE_RUNNING = 2;
+  static STATE_EXITING = 3;
+  static STATE_DONE = 4;
+  
+  initData(pluginService) {
+    this.pluginService = pluginService;
+  }
+  
+  init(cb) {
+    this.cb = cb;
+    this.state = PluginComponent.STATE_INITIALIZING;
+    try {
+      this.onInit();
+    }
+    catch(err) {
+      this._logError('initialize', err);
+      cb(err);
+    }
+  }
+  
+  exit(cb) {
+    this.cb = cb;
+    this.state = PluginComponent.STATE_EXITING;
+    try {
+      this.onExit();
+    }
+    catch(err) {
+      this._logError('exit', err);
+      cb(err);
+    }
+  }
+  
+  done(err) {
+    const cb = this.cb;
+    this.cb = null;
+    process.nextTick(() => {
+      if(PluginComponent.STATE_INITIALIZING === this.state) {
+        if(err) {
+          this._logError('initialize', err);
+        }
+        else {
+          this._logSuccess('initialized');
+        }
+        this.state = PluginComponent.STATE_RUNNING;
+      }
+      else if(PluginComponent.STATE_EXITING === this.state) {
+        if(err) {
+          this._logError('exit', err);
+        }
+        else {
+          this._logSuccess('exited');
+        }
+        this.state = PluginComponent.STATE_DONE;
+      }
+      else {
+        ddb.error('WRONG STATE:');
+      }
+      cb();
+    });
+  }
+  
+  getService() {
+    return this.pluginService;
+  }
+  
+  _logSuccess(phase) {
+    ddb.writelnTime(ddb.green('Component: '), this.componentName, ddb.green(' ' + phase + '.'));
+  }
+  
+  _logError(phase, err) {
+    ddb.writelnTime(ddb.red('Component: ') + this.componentName, 'Could not', ddb.red(' ' + phase + '.'), err);
+  }
+}
+
+
+module.exports = PluginComponent;

package/project/server/plugin-data/client/plugin_data_ClientGet.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const PluginBaseMulti = require('../../plugin-base-multi');
+
+
+class ClientStore extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    return this.expectAsynchResponseSuccess('Hejsan hoppsan.');
+  }
+}
+
+
+module.exports = PluginsStore.export(ClientStore);

package/project/server/plugin-data/dialog-file/plugin_data_DialogFileGet.js

@@ -0,0 +1,197 @@
+
+'use strict';
+
+const ActorPath = require('../../path/actor-path');
+const ActorPathProject = require('../../path/actor-path-project');
+const ActorPathData = require('../../path/actor-path-data');
+const PluginBaseMulti = require('../../plugin-base-multi');
+const Project = require('z-abs-corelayer-cs/clientServer/project');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class DialogFileGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+    this.project = new Project();
+    this.pathFilters = [''];
+    this.existingFilters = [''];
+    this.rootName = '';
+    this.hasOrganization = !!Reflect.get(global, 'release-data@actorjs_global')?.organization;
+  }
+  
+  onRequest(rootName, pathFilters, existingFilters, type, projectType, plugin, workspaceName) {
+    if('workspace' === type) {
+      this.getWorkspaceFolders(ActorPath.getActorParentPath(), (workspaces) => {
+        this.responsePartSuccess(workspaces);
+      });
+    }
+    else {
+      this.rootName = rootName;
+      const isExternalPlugin = this.hasOrganization && !!plugin;
+      const external = this.isExternal(this.rootName);
+      this.pathFilters = this._adjustFilters(pathFilters, projectType, external, isExternalPlugin);
+      this.existingFilters = this._adjustFilters(existingFilters, projectType, external, isExternalPlugin);
+      const rootPath = this.getRootPath(this.rootName, projectType, isExternalPlugin, workspaceName);
+      const relativeName = this.rootName.substring(2);
+      const node = this.project.addRootFolder(!external ? Path.parse(rootPath).base : relativeName, []);
+      this.project.type = projectType;
+      this.getFilesTree(rootPath, relativeName, type, node, external, workspaceName, (err) => {
+        if(!err) {
+          this.responsePartSuccess(this.project);
+        }
+        else {
+          this.responsePartError(`Could not get Dialog File: '${rootPath}'`);
+        }
+      });
+    }
+  } 
+  
+  getWorkspaceFolders(dir, done) {
+    Fs.readdir(dir, (err, files) => {
+      if(err) {
+        return done(err);
+      }
+      let pendings = files.length;
+      if(0 == pendings) {
+        done([]);
+        return;
+      }
+      const workspaces = [];
+      files.forEach((file) => {
+        const newDir = Path.resolve(dir, file);
+        Fs.stat(newDir, (err, stat) => {
+          if(stat && stat.isDirectory()) {
+            if(file.startsWith('actor') || file.startsWith('node-') || file.startsWith('persistant-node-') || file.startsWith('web-node-')) {
+              workspaces.push(file);
+            }
+          }
+          if(0 === --pendings) {
+            done(workspaces);
+          }
+        });
+      });
+    });
+  }
+  
+  getFilesTree(dir, relativeName, type, node, external, workspaceName, done) {
+    Fs.readdir(dir, (err, files) => {
+      if(err) {
+        return done(err);
+      }
+      let pendings = files.length;
+      if(0 == pendings) {
+        done();
+        return;
+      }
+      files.forEach((file) => {
+        const newDir = Path.resolve(dir, file);
+        const relativeDir = Path.relative(Path.resolve(this.getRelativePath(this.rootName, workspaceName)), dir).replace(new RegExp('[\\\\]', 'g'), '/');
+        const relativeStart = `${relativeDir}/${file}`;
+        Fs.stat(newDir, (err, stat) => {
+          if(stat && stat.isDirectory()) {
+            let found = false;
+            this.pathFilters.forEach((folder) => {
+              if(folder === relativeDir) {
+                const foundFolderInFilter = this.existingFilters.find((fileFromExistingFilter) => {
+                  return fileFromExistingFilter === relativeStart;
+                });
+                if(!foundFolderInFilter && 'folder' === type) {
+                  this.project.addFolderToNode(file, `./${relativeName}`, [], node);
+                }
+              }
+              else if(folder.startsWith(relativeStart) && (folder === relativeStart || '/' === folder[relativeStart.length])) {
+                found = true;
+                const newNode = this.project.addFolderToNode(file, `./${relativeName}`, [], node);
+                this.getFilesTree(newDir, `${relativeName}/${file}`, type, newNode, external, workspaceName, (err) => {
+                  if(0 === --pendings) {
+                    done();
+                  }
+                });
+              }
+            });
+            if(!found) {
+              if(0 === --pendings) {
+                done();
+              }
+            }
+          }
+          else if(stat && stat.isFile()) {
+            const foundFolder = this.pathFilters.find((folderFromPathFilter) => {
+              return folderFromPathFilter === relativeDir;
+            });
+            if(foundFolder) {
+              const foundFileInFilter = this.existingFilters.find((fileFromExistingFilter) => {
+                return fileFromExistingFilter === relativeStart;
+              });
+              if(!foundFileInFilter && 'file' === type) {
+                this.project.addFileToNode(file, `./${relativeName}`, file.substr(file.lastIndexOf('.') + 1, file.length), node);
+              }
+            }
+            if(0 === --pendings) {
+              done();
+            }
+          }
+        });
+      });
+    });
+  }
+  
+  isExternal(pathName) {
+    switch(pathName) {
+      case './project':
+      case './Actors-global':
+      case './Actors-local':
+      case './Stacks-global':
+      case './Stacks-local':
+        return false;
+      default:
+        return true;
+    }
+  }
+  
+  _adjustFilters(filters, projectType, external, isExternalPlugin) {
+    const adjustedFilters = [];
+    filters.forEach((filter) => {
+        adjustedFilters.push(ActorPathProject.getRelativePath(filter, projectType, isExternalPlugin).replace(new RegExp('[\\\\]', 'g'), '/'));
+    });
+    return adjustedFilters;
+  }
+  
+  getRootPath(pathName, projectType, isExternalPlugin, workspaceName) {
+    switch(pathName) {
+      case './project':
+        return ActorPathProject.getCodeProjectFolder(null, null, workspaceName);
+      case './Actors-global':
+        return ActorPathData.getActorsGlobalFolder();
+      case './Actors-local':
+        return ActorPathData.getActorsLocalFolder();
+      case './Stacks-global':
+        return ActorPathData.getStacksGlobalFolder();
+      case './Stacks-local':
+        return ActorPathData.getStacksLocalFolder();
+      default:
+        return `${ActorPathProject.getRawPath(projectType, isExternalPlugin)}${pathName.substring(2)}${Path.sep}project`;
+    }
+  }
+  
+  getRelativePath(pathName, workspaceName) {
+    switch(pathName) {
+      case './project':
+        return Path.normalize(`${ActorPathProject.getCodeProjectFolder(null, null, workspaceName)}/..`);
+      case './Actors-global':
+        return  Path.normalize(`${ActorPathData.getActorsGlobalFolder()}/..`);
+      case './Actors-local':
+        return Path.normalize(`${ActorPathData.getActorsLocalFolder()}/..`);
+      case './Stacks-global':
+        return Path.normalize(`${ActorPathData.getStacksGlobalFolder()}/..`);
+      case './Stacks-local':
+        return Path.normalize(`${ActorPathData.getStacksLocalFolder()}/..`);
+      default:
+        return '';
+    }
+  }
+}
+
+
+module.exports = DialogFileGet;

package/project/server/plugin-data/platform/plugin_data_PlatformPing.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const PluginBase = require('../../plugin-base');
+
+
+class PlatformPing extends PluginBase {
+  constructor() {
+    super(PluginBase.GET);
+  }
+  
+  onRequest() {
+    return this.responsePartSuccess('ping');
+  }
+}
+
+
+module.exports = PlatformPing;
+ 

package/project/server/plugin-factor-protocol.js

@@ -0,0 +1,35 @@
+
+'use strict';
+
+const PluginFactory = require('./plugin-factory');
+
+
+class PluginFactorProtocol {
+  constructor() {
+    this.pluginProtocolParams = [];
+    this.pluginProtocolFactory = new PluginFactory('protocol', this.pluginProtocolParams, 'clientServer');
+    this.protocols = [];
+  }
+  
+  load(protocols, done) {
+    this.pluginProtocolFactory.setPaths(protocols);
+    this.pluginProtocolFactory.load(() => {
+      this.protocols = this.pluginProtocolFactory.createAll();
+      done();
+    });
+  }
+  
+  register(channelInput, channelOutput) {
+    this.protocols.forEach((protocol) => {
+      if(channelInput) {
+        protocol.plugin.registerDeserializer(channelInput);
+      }
+      if(channelOutput) {
+        protocol.plugin.registerSerializer(channelOutput);
+      }
+    });
+  }
+}
+
+
+module.exports = PluginFactorProtocol;

package/project/server/plugin-factory.js

@@ -0,0 +1,127 @@
+
+'use strict';
+
+const ActorPathDist = require('./path/actor-path-dist');
+const Logger = require('./log/logger');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class PluginFactory {
+  constructor(type, params, libType='server') {
+    this.libType = libType;
+    this.prefix = `plugin_${type}_`;
+    this.params = params;
+    this.prefix_length = this.prefix.length;
+    this.appSearchPath = `plugin-${type}`;
+    this.paths = [];
+    this.plugins = new Map();
+  }
+  
+  create(name) {
+    const foundFactoryPath = this.plugins.get(name);
+    if(foundFactoryPath) {
+      const Plugin = require(foundFactoryPath.factoryPath);
+      try {
+        const plugin = new Plugin();
+        if(plugin.initData) {
+          plugin.initData(...this.params);
+        }
+        return plugin;
+      }
+      catch(e) {
+        ddb.error('Could not create plugin:', name);
+        console.log(e);
+      }
+    }
+    ddb.error('FACTORY ERROR: ' + name);
+  }
+  
+  createAll() {
+    if(0 !== this.plugins.size) {
+      const all = [];
+      this.plugins.forEach((value, key) => {
+        const plugin = this.create(key);
+        all.push({libName: value.libName, plugin});
+      });
+      return all;
+    }
+    else {
+      return [];
+    }
+  }
+  
+  _setPaths(path) {
+    this.paths.push(Path.join(ActorPathDist.getLayersPath(), path + `${Path.sep}${this.libType}`, this.appSearchPath));
+  }
+  
+  setPaths(paths) {
+    if(Array.isArray(paths)) {
+      paths.forEach((path) => {
+        this._setPaths(path);
+      });
+    }
+    else {
+      this._setPaths(paths);
+    }
+  }
+  
+  load(done, path) {
+    const loadPath = path ? this.paths.concat(path) : this.paths;
+    let pendings = loadPath.length;
+    if(0 === pendings) {
+      return done(this.plugins.size);
+    }
+    loadPath.forEach((p) => {
+      this.loadPlugins(p, () => {
+        if(0 === --pendings) {
+          done(this.plugins.size);
+        }
+      }); 
+    });
+  }
+  
+  loadPlugins(path, done) {
+    Fs.lstat(path, (err, stat) => {
+      if(err) {
+        return done();
+      }
+      if(stat.isDirectory()) {
+        // We have a directory: do a tree walk
+        Fs.readdir(path, (err, files) => {
+          let file, length = files.length;
+          let pendings = length;
+          if(0 === pendings) {
+            done();
+          }
+          else {
+            for(let i = 0; i < length; ++i) {
+              file = Path.join(path, files[i]);
+              this.loadPlugins(file, () => {
+                if(0 === --pendings) {
+                  done();
+                }
+              });
+            }
+          }
+        });
+      }
+      else if(stat.isFile()) {
+        const splitFilePath = path.split(Path.sep);
+        const libName = splitFilePath[splitFilePath.length - 4];
+        const filePath = splitFilePath[splitFilePath.length - 2];
+        const fileName = splitFilePath[splitFilePath.length - 1];
+        const names = fileName.split('.');
+        if(names[0].startsWith(this.prefix)) {
+          const name = names[0].substring(this.prefix_length);
+          const factoryPath = path.substring(0, path.lastIndexOf(Path.sep)) + Path.sep + names[0];
+          this.plugins.set(name, {libName, factoryPath});
+        }
+        done();
+      }
+    });
+  }
+}
+
+
+module.exports = PluginFactory;

package/project/server/plugin-lock.js

@@ -0,0 +1,164 @@
+
+'use strict';
+
+
+class PluginLock {
+  constructor() {
+    this.lockedReads = new Map();
+    this.lockedWrites = new Map();
+    this.queuedReads = new Map();
+    this.queuedWrites = new Map();
+  }
+  
+  readLock(name, cb) {
+    if(!this._emptyLockedWrite(name)) {
+      this._addQueuedRead(name, cb);
+    }
+    else if(!this._emptyQueuedWrite(name)) {
+      this._addQueuedRead(name, cb);
+    }
+    else {
+      this._addLockedRead(name);
+      process.nextTick(() => {
+        cb(() => {
+          this._readLockDone(name);
+        });
+      });
+    }
+  }
+  
+  writeLock(name, cb) {
+    if(!this._emptyLockedWrite(name)) {
+      this._addQueuedWrite(name, cb);
+    }
+    else if(!this._emptyLockedRead(name)) {
+      this._addQueuedWrite(name, cb);
+    }
+    else {
+      this._addLockedWrite(name);
+      process.nextTick(() => {
+        cb(() => {
+          this._writeLockDone(name);
+        });
+      });
+    }
+  }
+  
+  _writeLockDone(name) {
+    this._removeLockedWrite(name);
+    if(!this._emptyQueuedWrite(name)) {
+      this.writeLock(name, this._removeQueuedWrite(name));
+    }
+    else {
+      while(!this._emptyQueuedRead(name)) {
+        this.readLock(name, this._removeQueuedRead(name));
+      }
+    }
+  }
+  
+  _readLockDone(name) {
+    this._removeLockedRead(name);
+    if(this._emptyLockedRead(name)) {
+      if(!this._emptyQueuedWrite(name)) {
+        this.writeLock(name, this._removeQueuedWrite(name));
+      }
+    }
+  }
+  
+  _addLocked(name, map) {
+    if(map.has(name)) {
+      const q = map.get(name);
+      ++q.size;
+    }
+    else {
+      map.set(name, {
+        size: 1
+      });
+    }
+  }
+  
+  _removeLocked(name, map) {
+    const q = map.get(name);
+    if(0 === --q.size) {
+      map.delete(name);
+    }
+  }
+  
+  _addQueued(name, cb, map) {
+    if(map.has(name)) {
+      const q = map.get(name);
+      q.cbs.push(cb);
+      ++q.size;
+    }
+    else {
+      map.set(name, {
+        cbs: [cb],
+        size: 1
+      });
+    }
+  }
+  
+  _removeQueued(name, map) {
+    const q = map.get(name);
+    if(0 === --q.size) {
+      map.delete(name);
+    }
+    return q.cbs.splice(0, 1)[0];
+  }
+  
+  _empty(name, map) {
+    const q = map.get(name);
+    return undefined === q;
+  }
+  
+  _addLockedRead(name) {
+    this._addLocked(name, this.lockedReads);
+  }
+  
+  _removeLockedRead(name) {
+    this._removeLocked(name, this.lockedReads);
+  }
+  
+  _emptyLockedRead(name) {
+    return this._empty(name, this.lockedReads);
+  }
+  
+  _addLockedWrite(name) {
+    this._addLocked(name, this.lockedWrites);
+  }
+  
+  _removeLockedWrite(name) {
+    this._removeLocked(name, this.lockedWrites);
+  }
+  
+  _emptyLockedWrite(name) {
+    return this._empty(name, this.lockedWrites);
+  }
+  
+  _addQueuedRead(name, cb) {
+    this._addQueued(name, cb, this.queuedReads);
+  }
+  
+  _removeQueuedRead(name) {
+    return this._removeQueued(name, this.queuedReads);
+  }
+  
+  _emptyQueuedRead(name) {
+    return this._empty(name, this.queuedReads);
+  }
+  
+  _addQueuedWrite(name, cb) {
+    this._addQueued(name, cb, this.queuedWrites);
+  }
+  
+  _removeQueuedWrite(name) {
+    return this._removeQueued(name, this.queuedWrites);
+  }
+  
+  _emptyQueuedWrite(name) {
+    return this._empty(name, this.queuedWrites);
+  }
+}
+
+
+module.exports = new PluginLock();

package/project/server/response-queue.js

@@ -0,0 +1,46 @@
+
+'use strict';
+
+const Responses = require('./responses');
+
+
+class ResponseQueue {
+  constructor(cb, externalCb, id) {
+    this.instanceId = ++ResponseQueue.id;
+    this.calls = 0;
+    this.cb = cb;
+    this.externalCb = externalCb;
+    this.id = id;
+    this.responses = new Responses(id);
+    this.token = null;
+  }
+  
+  static id = 0;
+  
+  add() {
+    ++this.calls;
+  }
+  
+  remove() {
+    if(0 == --this.calls) {
+      this.cb(this.responses, this.externalCb);
+    }
+  }
+  
+  setToken(token) {
+    this.token = token;
+  }
+  
+  done(response) {
+    this.responses.add(response);
+    if(0 === --this.calls) {
+      this.responses.responses.sort((a, b) => {
+        return a.index - b.index;
+      });
+      this.cb(this.responses, this.externalCb, this.token);
+    }
+  }
+}
+
+
+module.exports = ResponseQueue;