@aj-shadow/actorjs-app 0.0.0-aj-beta.221

package/project/server/plugin-data/login/plugin_data_LoginUpdate.js

@@ -0,0 +1,44 @@
+
+'use strict';
+
+const AddressCalculator = require('z-abs-funclayer-engine-server/server/address/address-calculator');
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class LoginUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(labId, userId, repo, systemUnderTest, systemUnderTestInstance, nodes, forceLocalhost) {
+    new AddressCalculator().calculateAndSave(labId, userId, systemUnderTest, systemUnderTestInstance, forceLocalhost, (loginReport, chosenAddresses) => {
+      this.asynchWriteFileResponse(ActorPathGenerated.getStagingFile(), {
+        labId,
+        userId,
+        repo,
+        systemUnderTest,
+        systemUnderTestInstance,
+        nodes,
+        forcedLocalhost: forceLocalhost
+      }, true);
+      this.asynchReadFileResponse(ActorPathGenerated.getNetworksFile());
+      this.asynchWriteFileResponse(ActorPathGenerated.getStagingReport(), loginReport, true);
+      this.asynchWriteFileResponse(ActorPathGenerated.getChosenAddresses(), chosenAddresses, true);
+    });
+  }
+  
+  _getOsNetworks() {
+    const index = this.expectAsynchResponse();
+    LoginHelper.getOsNetworks((command, cb) => {
+      this.asynchChildProcess(command, (err, stdout) => {
+        cb(err, stdout);
+      });
+    }, (osNetworks) => {
+      return this.asynchResponseSuccess(index, osNetworks);    
+    });
+  }
+}
+
+
+module.exports = LoginUpdate;

package/project/server/plugin-data/login/plugin_data_LoginWsGet.js

@@ -0,0 +1,39 @@
+
+'use strict';
+
+const DataResponse = require('z-abs-corelayer-server/server/data-response');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class LoginWsGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+    
+  onRequest() {
+    const versioningApp = this.getService('versioning-app-fs');
+    const wsServers = versioningApp?.getWsServers();
+    const config = versioningApp?.getConfig();
+    if(wsServers) {
+      this.expectAsynchResponseSuccess(wsServers);
+      this.expectAsynchResponseSuccess(config);
+    }
+    else {
+      const serverDatas = DataResponse._.serverDatas.wsWebServers;
+      const resultingServerDatas = [];
+      serverDatas.forEach((serverData) => {
+        resultingServerDatas.push({
+          name: serverData.name,
+          type: serverData.type,
+          host: serverData.host,
+          port: serverData.port
+        });
+      });
+      this.expectAsynchResponseSuccess(resultingServerDatas);
+      this.expectAsynchResponseSuccess({verbose: null});
+    }
+  }
+}
+
+
+module.exports = LoginWsGet;

package/project/server/plugin-data/plugins/plugin_data_PluginsBundleGet.js

@@ -0,0 +1,34 @@
+
+'use strict';
+
+const ActorPathDist = require('z-abs-corelayer-server/server/path/actor-path-dist');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Path = require('path');
+
+
+class PluginsBundleGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+    this.production = 'production' === process.env.NODE_ENV;
+  }
+  
+  onRequest(bundle, type) {
+    const file = 'js' === type ? `${ActorPathDist.getScriptsPath()}${Path.sep}${bundle}${this.production ? '.gzip' : ''}` : `${ActorPathDist.getCssPath()}${Path.sep}${bundle}${this.production ? '.gzip' : ''}`;
+    const indexProduction = this.expectAsynchResponse();
+    const indexfile = this.expectAsynchResponse();
+    const readFile = this.production ? this.asynchReadBinFile.bind(this) : this.asynchReadTextFile.bind(this);
+    readFile(file, (err, data) => {
+      if(!err) {
+        this.asynchResponseSuccess(indexProduction, this.production);
+        this.asynchResponseSuccess(indexfile, data);
+      }
+      else {
+        this.asynchResponseSuccess(indexProduction, this.production);
+        this.asynchResponseError(err.message, indexfile);
+      }
+    });
+  }
+}
+
+
+module.exports = PluginsBundleGet;

package/project/server/plugin-data/plugins/plugin_data_PluginsGet.js

@@ -0,0 +1,26 @@
+
+'use strict';
+
+const ActorPath = require('z-abs-corelayer-server/server/path/actor-path');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class PluginsGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.asynchReadFile(ActorPath.getSettingsFile(), (err, data) => {
+      if(!err) {
+        this.expectAsynchResponseSuccess(data.plugins);
+      }
+      else {
+        this.expectAsynchResponseError(`Could not settings.json`);
+      }
+    });
+  }
+}
+
+
+module.exports = PluginsGet;

package/project/server/plugin-data/plus-services/plugin_data_PlusServicesBundleGet.js

@@ -0,0 +1,34 @@
+
+'use strict';
+
+const ActorPathDist = require('z-abs-corelayer-server/server/path/actor-path-dist');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Path = require('path');
+
+
+class PlusServicesBundleGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+    this.production = 'production' === process.env.NODE_ENV;
+  }
+  
+  onRequest(bundle, type) {
+    const file = 'js' === type ? `${ActorPathDist.getScriptsPath()}${Path.sep}${bundle}${this.production ? '.gzip' : ''}` : `${ActorPathDist.getCssPath()}${Path.sep}${bundle}${this.production ? '.gzip' : ''}`;
+    const indexProduction = this.expectAsynchResponse();
+    const indexfile = this.expectAsynchResponse();
+    const readFile = this.production ? this.asynchReadBinFile.bind(this) : this.asynchReadTextFile.bind(this);
+    readFile(file, (err, data) => {
+      if(!err) {
+        this.asynchResponseSuccess(indexProduction, this.production);
+        this.asynchResponseSuccess(indexfile, data);
+      }
+      else {
+        this.asynchResponseSuccess(indexProduction, this.production);
+        this.asynchResponseError(err.message, indexfile);
+      }
+    });
+  }
+}
+
+
+module.exports = PlusServicesBundleGet;

package/project/server/plugin-data/plus-services/plugin_data_PlusServicesGet.js

@@ -0,0 +1,78 @@
+
+'use strict';
+
+
+const ActorPath = require('z-abs-corelayer-server/server/path/actor-path');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class PlusServicesGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+  // this.asynchReadFile(ActorPath.getSettingsFile(), (err, data) => {
+   //   if(!err) {
+   //     this.expectAsynchResponseSuccess(data.plugins);
+   //   }
+   //   else {
+   //     this.expectAsynchResponseError(`Could not settings.json`);
+   //   }
+   // });
+    this.expectAsynchResponseSuccess([
+      {
+        name: 'docs',
+        path: '/docs',
+        bundle: 'PlusServicesLayer-Docs-client.js',
+        plusService: 'z-abs-plus-service-docs',
+        cssBundle: 'bundle-PlusServices-Docs.css',
+        dependencies: [
+          {
+            name: "z-abs-complayer-documentation-client",
+            bundle: "CompLayer-Documentation-client.js"
+          }
+        ],
+        cssDependencies: []
+      },
+      {
+        name: 'team',
+        path: '/team',
+        bundle: 'PlusServicesLayer-Team-client.js',
+        plusService: 'z-abs-plus-services-team',
+        cssBundle: 'bundle-PlusServices-Team.css',
+        dependencies: [
+          {
+            name: "z-abs-corelayer-cs",
+            bundle: "CoreLayer-cs.js"
+          },
+          {
+            name: "z-abs-corelayer-client",
+            bundle: "CoreLayer-client.js"
+          },
+          {
+            name: "z-abs-complayer-router-client",
+            bundle: "CompLayer-Router-client.js"
+          },
+          {
+            name: "z-abs-complayer-bootstrap-client",
+            bundle: "CompLayer-Bootstrap-client.js"
+          },
+          {
+            name: "z-abs-complayer-stream-client",
+            bundle: "CompLayer-Stream-client.js",
+            cssBundle: "bundle-CompLayer-Stream.css"
+          },
+          {
+            name: "z-abs-servicelayer-team-client",
+            bundle: "ServiceLayer-Team-client.js",
+            cssBundle: "bundle-ServiceLayer-Team.css"
+          }
+        ]
+      }
+    ]);
+  }
+}
+
+
+module.exports = PlusServicesGet;

package/project/server/plugin-data/repos/plugin_data_ReposAnalyzeLocalReposGet.js

@@ -0,0 +1,142 @@
+
+'use strict';
+
+const Repos = require('./repos');
+const ActorPathContent = require('z-abs-corelayer-server/server/path/actor-path-content');
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const GitSimple = require('simple-git');
+const Fs = require('fs');
+
+
+class ReposAnalyzeLocalReposGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    const index1 = this.expectAsynchResponse();
+    const index2 = this.expectAsynchResponse();
+    const index3 = this.expectAsynchResponse();
+    let pendings = 3;
+    let content = null;
+    let data = null;
+    let repos = null;
+    this._analyzeRepo(ActorPathContent.getContentLocalFolder(), false, (err, isRepo, remote) => {
+      if(!err) {
+        content = {
+          isRepo: isRepo,
+          url: remote
+        };
+        if(0 === --pendings) {
+          this._writeRepos(content, data, repos, index3);
+        }
+        this.asynchResponseSuccess(index1, content);
+      }
+      else {
+        this.asynchResponseError(`Could not find out if ${ActorPathContent.getContentLocalFolder()} is a repo.`, index1);
+      }
+    });
+    this._analyzeRepo(ActorPathData.getActorDataLocalFolder(), true, (err, isRepo, remote) => {
+      if(!err) {
+        data = {
+          isRepo: isRepo,
+          url: remote
+        };
+        if(0 === --pendings) {
+          this._writeRepos(content, data, repos, index3);
+        }
+        this.asynchResponseSuccess(index2, data);
+      }
+      else {
+        this.asynchResponseError(`Could not find out if ${ActorPathData.getActorDataLocalFolder()} is a repo.`, index2);
+      }
+    });
+    Repos.getReposFile(this.asynchReadFile.bind(this), (err, data) => {
+      if(!err) {
+        repos = data;
+        if(!data) {
+          if(0 === --pendings) {
+            this._writeRepos(content, data, repos, index3);
+          }
+        }
+        else {
+          this.asynchResponseSuccess(index3, data);
+        }
+      }
+      else {
+        this.asynchResponseError('Could not get repos.json.', index3);
+      }
+    });
+  }
+  
+  _analyzeRepo(dir, dataRepo, done) {
+    Fs.lstat(dir, (err, stat) => {
+      if(err) {
+        if('ENOENT' === err.code) {
+          done(null, false);
+        }
+        else {
+          done(err);
+        }
+      }
+      else {
+        if(!stat.isDirectory()) {
+          return done(new Error('Is file.'));
+        }
+        GitSimple(dir).checkIsRepo((err, result) => {
+          if(err) {
+            done(err);
+          }
+          else {
+            if(result) {
+              GitSimple(dir).remote(['--verbose'], (err, resultRemote) => {
+                if(!err) {
+                  const results = resultRemote.split(/[\s\n]+/);
+                  done(null, true, results[1]);
+                }
+                else {
+                  done(err);
+                }
+              });
+            }
+            else {
+              done(null, false);
+            }
+          }
+        });
+      }
+    });
+  }
+  
+  _writeRepos(content, data, repos, index3) {
+    if(!repos) {
+      if(data && data.isRepo) {
+        Repos.writeNew(content.url, data.url, this.asynchWriteFile.bind(this), (err, data) => {
+          if(!err) {
+            this.asynchResponseSuccess(index3, data);
+          }
+          else {
+            this.asynchResponseError(`Could not create repos.json file.`, index3);
+          }
+        });
+      }
+      else {
+        this.asynchResponseSuccess(index3);
+      }
+    }
+    else {
+      Repos.update(content.url, data.url, repos, this.asynchWriteFile.bind(this), (err, data) => {
+        if(!err) {
+          this.asynchResponseSuccess(index3, data);
+        }
+        else {
+          this.asynchResponseError(`Could not create repos.json file.`, index3);
+        }
+      });
+    }
+  }
+}
+
+
+module.exports = ReposAnalyzeLocalReposGet;

package/project/server/plugin-data/repos/plugin_data_ReposClone.js

@@ -0,0 +1,154 @@
+
+'use strict';
+
+const Repos = require('./repos');
+const ActorPathContent = require('z-abs-corelayer-server/server/path/actor-path-content');
+const ActorContentPaths = require('z-abs-corelayer-server/server/path/paths/actor-content-paths');
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const ActorDataPaths = require('z-abs-corelayer-server/server/path/paths/actor-data-paths');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const GitSimple = require('simple-git');
+const Fs = require('fs');
+const Os = require('os');
+
+
+class ReposClone  extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(type, url, newRepo) {
+    const actorDataLocal = 'actorjs-data-local' === type;
+    const dir = actorDataLocal ? ActorPathData.getActorDataLocalFolder() : ActorPathContent.getContentLocalFolder();
+    if(!newRepo) {
+      const dirParent = actorDataLocal ? ActorPathData.getReposLocalFolder() : ActorPathContent.getContentFolder();
+      Fs.rm(dir, {recursive:true, force: true}, (err) => {
+        if(err) {
+          ddb.error('rm', dir, err);
+          return this.expectAsynchResponseError(`Could not remove folder: '${dir}'.`);
+        }
+        const cloneOptions = 'win32' === Os.platform() ? ['--config','core.autocrlf=true'] : ['--config','core.autocrlf=input'];
+        GitSimple(dirParent).clone(url, type, cloneOptions, (err, result) => {
+          if(err) {
+            ddb.error('git clone', err);
+            this.expectAsynchResponseError(`Could not clone repo: '${url}'.`);
+          }
+          else {
+            if(actorDataLocal) {
+              const platformService = this.getService('platform');
+              if(platformService) {
+                platformService.verifyOrCreateFiles(() => {
+                  this._updateReposFile(url, type);
+                }, ['Server:ActorLayer/server-local', 'Server:StackLayer/server-local']);
+              }
+              else {
+                this._updateReposFile(url, type);
+              }
+            }
+            else {
+              this._updateReposFile(url, type);
+            }
+          }
+        });
+      });
+    }
+    else {
+      this._verifyOrCreateRepoFolder(dir, actorDataLocal, (err) => {
+        if(err) {
+          return this.expectAsynchResponseError(`'${dir}' must be a folder or none existing.`);
+        }
+        GitSimple(dir).init(['--initial-branch', 'main'], (err, result) => {
+          if(err) {
+            ddb.error('git init', err);
+            return this.expectAsynchResponseError(`Could not git initialize folder: '${dir}'.`);
+          }
+          GitSimple(dir).addRemote('origin', url, (err, result) => {
+            if(err) {
+              ddb.error('git remote', err);
+              return this.expectAsynchResponseError(`Could not set git remote folder: '${dir}'.`);
+            }
+            GitSimple(dir).add('.', (err) => {
+              if(err) {
+                ddb.error('git add', err);
+                return this.expectAsynchResponseError(`Could not add pull folder: '${dir}'.`);
+              }
+              GitSimple(dir).commit('Initial Commit', (err) => {
+                if(err) {
+                  ddb.error('git commit', err);
+                  this.expectAsynchResponseError(`Could not git commit folder: '${dir}'.`);
+                }
+                GitSimple(dir).push(['--set-upstream', 'origin', 'main'], (err) => {
+                  if(err) {
+                    ddb.error('git push', err);
+                    this.expectAsynchResponseError(`Could not git push folder: '${dir}'.`);
+                  }
+                  else {
+                    if(actorDataLocal) {
+                      const platformService = this.getService('platform');
+                      if(platformService) {
+                        platformService.verifyOrCreateFiles(() => {
+                          this._updateReposFile(url, type);
+                        }, ['Server:ActorLayer/server-local', 'Server:StackLayer/server-local']);
+                      }
+                      else {
+                        this._updateReposFile(url, type);
+                      }
+                    }
+                    else {
+                      this._updateReposFile(url, type);
+                    }
+                  }
+                });
+              });
+            });
+          });
+        });
+      });
+    }
+  }
+  
+  _updateReposFile(url, type) {
+    const index = this.expectAsynchResponse();
+    Repos.getReposFile(this.asynchReadFile.bind(this), (err, data) => {
+      if(!err) {
+        Repos.update('actorjs-content-local' === type ? url : null, 'actorjs-data-local' === type ? url : null, data, this.asynchWriteFile.bind(this), (err, data) => {
+          if(err) {
+            ddb.error('repos update', err);
+            this.asynchResponseError(`Could not update repos.json file.`, index);
+          }
+          else {
+            this.asynchResponseSuccess(index, data);
+          }
+        });
+      }
+      else {
+        if('ENOENT' === err.code) {
+          Repos.writeNew(null, url, this.asynchWriteFile.bind(this), (err, data) => {
+            if(!err) {
+              this.asynchResponseSuccess(index, data);
+            }
+            else {
+              ddb.error('repos write', err);
+              this.asynchResponseError(`Could not create repos.json file.`, index);
+            }
+          });
+        }
+        else {
+          ddb.error('repos write', err);
+          this.asynchResponseError(`Could not read repos.json file.`, index);
+        }
+      }
+    });
+  }
+  
+  _verifyOrCreateRepoFolder(dir, actorDataLocal, done) {
+    if(actorDataLocal) {
+      new ActorDataPaths().verifyOrCreate(done);
+    }
+    else {
+      new ActorContentPaths().verifyOrCreate(done);
+    }
+  }
+}
+
+module.exports = ReposClone;

package/project/server/plugin-data/repos/plugin_data_ReposGet.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class ReposGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.asynchReadFileResponse(ActorPathData.getLocalReposFile());
+  }
+}
+
+module.exports = ReposGet;

package/project/server/plugin-data/repos/plugin_data_ReposVerifyGit.js

@@ -0,0 +1,79 @@
+
+'use strict';
+
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Os = require('os');
+
+
+class ReposVerifyGit extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+    this.results = [];
+  }
+  
+  onRequest() {
+    const index = this.expectAsynchResponse();
+    this.asynchChildProcess('git config --list', (err, stdout) => {
+      if(!err) {
+        const configs = stdout.split('\n');
+        const userEmail = this._getConfig(configs, 'user.email');
+        userEmail.expected = userEmail.value.length >= 1;
+        userEmail.expectedValue = '! empty()';
+        this.results.push(userEmail);
+        const userName = this._getConfig(configs, 'user.name');
+        userName.expected = userName.value.length >= 1;
+        userName.expectedValue = '! empty()';
+        this.results.push(userName);
+        if('win32' === Os.platform()) {
+          const coreAutocrlf = this._getConfig(configs, 'core.autocrlf');
+          coreAutocrlf.expected = coreAutocrlf.value === 'true';
+          coreAutocrlf.expectedValue = 'true';
+          this.results.push(coreAutocrlf);
+          const coreLongpaths = this._getConfig(configs, 'core.longpaths');
+          coreLongpaths.expected = coreLongpaths.value === 'true';
+          coreLongpaths.expectedValue = 'true';
+          this.results.push(coreLongpaths);
+        }
+        else if('linux' === Os.platform()) {
+          const coreAutocrlf = this._getConfig(configs, 'core.autocrlf');
+          coreAutocrlf.expected = coreAutocrlf.value === 'input';
+          coreAutocrlf.expectedValue = 'input';
+          this.results.push(coreAutocrlf);
+          const credentialHelper = this._getConfig(configs, 'credential.helper');
+          credentialHelper.expected = credentialHelper.value.length >= 1;
+          credentialHelper.expectedValue = '! empty(), only for https git repos.';
+          this.results.push(credentialHelper);
+        }
+        else if('darwin' === Os.platform()) {
+          const coreAutocrlf = this._getConfig(configs, 'core.autocrlf');
+          coreAutocrlf.expected = coreAutocrlf.value === 'input';
+          coreAutocrlf.expectedValue = 'input';
+          this.results.push(coreAutocrlf);
+          const credentialHelper = this._getConfig(configs, 'credential.helper');
+          credentialHelper.expected = credentialHelper.value.length >= 1;
+          credentialHelper.expectedValue = '! empty(), only for https git repos.';
+          this.results.push(credentialHelper);
+        }
+        return this.asynchResponseSuccess(index, this.results);
+      }
+      else {
+        this.asynchResponseError(stdout, index);
+      }
+    });
+  }
+  
+  _getConfig(configs, findConfig) {
+    const foundConfig = configs.find((config) => {
+      return config.startsWith(findConfig);
+    });
+    return {
+      name: findConfig,
+      value: foundConfig ? foundConfig.substring(findConfig.length + 1) : '-',
+      found: !!foundConfig,
+      expected: false,
+      expectedValue: ''
+    };
+  }
+}
+
+module.exports = ReposVerifyGit;