cyberia 2.8.885

package/bin/build.js

@@ -0,0 +1,209 @@
+import fs from 'fs-extra';
+import { loggerFactory } from '../src/server/logger.js';
+import { shellExec } from '../src/server/process.js';
+import dotenv from 'dotenv';
+import { getCapVariableName } from '../src/client/components/core/CommonJs.js';
+import { getPathsSSR } from '../src/server/conf.js';
+
+const baseConfPath = './engine-private/conf/dd-cron/.env.production';
+if (fs.existsSync(baseConfPath)) dotenv.config({ path: baseConfPath, override: true });
+
+const logger = loggerFactory(import.meta);
+
+// (async () => {
+//   return;
+//   const files = await fs.readdir(`./src`);
+//   for (const relativePath of files) {
+//   }
+// })();
+
+const confName = process.argv[2];
+const basePath = '../pwa-microservices-template';
+const repoName = `engine-${confName.split('dd-')[1]}`;
+const deployList = (confName === 'dd' ? fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8') : confName).split(
+  ',',
+);
+
+logger.info('', {
+  confName,
+  repoName,
+  basePath,
+  deployList,
+});
+
+if (process.argv.includes('clean')) {
+  if (fs.existsSync(`${basePath}/images`)) fs.copySync(`${basePath}/images`, `./images`);
+  shellExec(`cd ${basePath} && git checkout .`);
+  shellExec(`cd ${basePath} && git clean -f -d`);
+  process.exit(0);
+}
+
+if (process.argv.includes('conf')) {
+  for (const _confName of deployList) {
+    const _repoName = `engine-${_confName.split('dd-')[1]}`;
+    const privateRepoName = `${_repoName}-private`;
+    const privateGitUri = `${process.env.GITHUB_USERNAME}/${privateRepoName}`;
+
+    if (!fs.existsSync(`../${privateRepoName}`)) {
+      shellExec(`cd .. && underpost clone ${privateGitUri}`, { silent: true });
+    } else {
+      shellExec(`cd ../${privateRepoName} && git checkout . && git clean -f -d && underpost pull . ${privateGitUri}`);
+    }
+    const toPath = `../${privateRepoName}/conf/${_confName}`;
+    fs.removeSync(toPath);
+    fs.mkdirSync(toPath, { recursive: true });
+    fs.copySync(`./engine-private/conf/${_confName}`, toPath);
+    if (process.argv.includes('remove-replica') && fs.existsSync(`../${privateRepoName}/replica`)) {
+      fs.removeSync(`../${privateRepoName}/replica`);
+    } else if (fs.existsSync(`./engine-private/replica`)) {
+      const replicas = await fs.readdir(`./engine-private/replica`);
+      for (const replica of replicas)
+        if (replica.match(_confName))
+          fs.copySync(`./engine-private/replica/${replica}`, `../${privateRepoName}/replica/${replica}`);
+    }
+    if (fs.existsSync(`./engine-private/itc-scripts`)) {
+      const itcScripts = await fs.readdir(`./engine-private/itc-scripts`);
+      for (const itcScript of itcScripts)
+        if (itcScript.match(_confName))
+          fs.copySync(`./engine-private/itc-scripts/${itcScript}`, `../${privateRepoName}/itc-scripts/${itcScript}`);
+    }
+    shellExec(
+      `cd ../${privateRepoName}` +
+        ` && git add .` +
+        ` && underpost cmt . ci engine-core-conf 'Update ${_confName} conf'` +
+        ` && underpost push . ${privateGitUri}`,
+    );
+  }
+  process.exit(0);
+}
+
+if (confName === 'dd') {
+  for (const _confName of deployList) {
+    shellExec(`node bin/build ${_confName}`);
+  }
+  process.exit(0);
+}
+
+const { DefaultConf } = await import(`../conf.${confName}.js`);
+
+{
+  for (const host of Object.keys(DefaultConf.server)) {
+    for (const path of Object.keys(DefaultConf.server[host])) {
+      const { apis, ws } = DefaultConf.server[host][path];
+      if (apis)
+        for (const api of apis) {
+          {
+            const originPath = `./src/api/${api}`;
+            logger.info(`Build`, originPath);
+            fs.copySync(originPath, `${basePath}/src/api/${api}`);
+          }
+          {
+            const originPath = `./src/client/services/${api}`;
+            logger.info(`Build`, originPath);
+            fs.copySync(originPath, `${basePath}/src/client/services/${api}`);
+          }
+        }
+
+      if (ws && ws !== 'core' && ws !== 'default') {
+        fs.copySync(`./src/ws/${ws}`, `${basePath}/src/ws/${ws}`);
+      }
+    }
+  }
+}
+
+{
+  for (const client of Object.keys(DefaultConf.client)) {
+    const capName = getCapVariableName(client);
+    for (const component of Object.keys(DefaultConf.client[client].components)) {
+      const originPath = `./src/client/components/${component}`;
+      if (fs.existsSync(originPath)) {
+        logger.info(`Build`, originPath);
+        fs.copySync(originPath, `${basePath}/src/client/components/${component}`);
+      }
+    }
+    {
+      const originPath = `./src/client/${capName}.index.js`;
+      if (fs.existsSync(originPath)) {
+        logger.info(`Build`, originPath);
+        fs.copyFileSync(originPath, `${basePath}/src/client/${capName}.index.js`);
+      }
+    }
+    {
+      const originPath = `./src/client/public/${client}`;
+      if (fs.existsSync(originPath)) {
+        logger.info(`Build`, originPath);
+        fs.copySync(originPath, `${basePath}/src/client/public/${client}`);
+      }
+    }
+  }
+}
+
+{
+  for (const client of Object.keys(DefaultConf.ssr)) {
+    const ssrPaths = getPathsSSR(DefaultConf.ssr[client]);
+    for (const originPath of ssrPaths) {
+      if (fs.existsSync(originPath)) {
+        logger.info(`Build`, originPath);
+        fs.copySync(originPath, `${basePath}/${originPath}`);
+      }
+    }
+  }
+
+  shellExec(`node bin/deploy update-default-conf ${confName}`);
+
+  fs.copyFileSync(`./conf.${confName}.js`, `${basePath}/conf.js`);
+
+  if (!fs.existsSync(`${basePath}/.github/workflows`))
+    fs.mkdirSync(`${basePath}/.github/workflows`, {
+      recursive: true,
+    });
+
+  const packageJson = JSON.parse(fs.readFileSync(`${basePath}/package.json`, 'utf8'));
+  packageJson.name = repoName.replace('engine-', '');
+
+  switch (confName) {
+    case 'dd-cyberia':
+      fs.copyFileSync(`./bin/cyberia.js`, `${basePath}/bin/cyberia.js`);
+      fs.copyFileSync(
+        `./.github/workflows/publish.cyberia.ci.yml`,
+        `${basePath}/.github/workflows/publish.cyberia.ci.yml`,
+      );
+      delete packageJson.bin.underpost;
+      packageJson.bin.cyberia = 'bin/index.js';
+
+      fs.writeFileSync(`${basePath}/bin/index.js`, fs.readFileSync(`./bin/cyberia.js`, 'utf8'), 'utf8');
+      fs.copyFileSync(`./src/api/object-layer/README.md`, `${basePath}/README.md`);
+
+    default:
+      break;
+  }
+
+  fs.writeFileSync(
+    `${basePath}/package.json`,
+    JSON.stringify(packageJson, null, 4).replaceAll('pwa-microservices-template', repoName),
+    'utf8',
+  );
+
+  fs.copySync(`./src/cli`, `${basePath}/src/cli`);
+  if (!fs.existsSync(`${basePath}/images`)) fs.mkdirSync(`${basePath}/images`);
+
+  const env = process.argv.includes('development') ? 'development' : 'production';
+  const deploymentsFiles = ['proxy.yaml', 'deployment.yaml', 'secret.yaml'];
+  // remove engine-private of .dockerignore for local testing
+  for (const file of deploymentsFiles) {
+    if (fs.existsSync(`./manifests/deployment/${confName}-${env}/${file}`)) {
+      fs.copyFileSync(`./manifests/deployment/${confName}-${env}/${file}`, `${basePath}/${file}`);
+    }
+  }
+
+  fs.copyFileSync(`./.github/workflows/${repoName}.ci.yml`, `${basePath}/.github/workflows/${repoName}.ci.yml`);
+  fs.copyFileSync(`./.github/workflows/${repoName}.cd.yml`, `${basePath}/.github/workflows/${repoName}.cd.yml`);
+
+  fs.copyFileSync(`./conf.${confName}.js`, `${basePath}/conf.js`);
+  fs.copyFileSync(`./manifests/deployment/${confName}-development/proxy.yaml`, `${basePath}/proxy.yaml`);
+  fs.copyFileSync(`./manifests/deployment/${confName}-development/deployment.yaml`, `${basePath}/deployment.yaml`);
+
+  if (fs.existsSync(`./src/ws/${confName.split('-')[1]}`)) {
+    fs.copySync(`./src/ws/${confName.split('-')[1]}`, `${basePath}/src/ws/${confName.split('-')[1]}`);
+  }
+}

package/bin/cron.js

@@ -0,0 +1,47 @@
+import { BackUpManagement } from '../src/server/backup.js';
+import { Cmd } from '../src/server/conf.js';
+import { Dns } from '../src/server/dns.js';
+import { loggerFactory } from '../src/server/logger.js';
+import { netWorkCron, saveRuntimeCron } from '../src/server/network.js';
+import { shellExec } from '../src/server/process.js';
+import fs from 'fs-extra';
+
+const logger = loggerFactory(import.meta);
+
+await logger.setUpInfo();
+
+switch (process.argv[2]) {
+  case 'backups':
+    {
+      await BackUpManagement.Init({ deployId: process.argv[3] });
+    }
+    break;
+  case 'dns':
+    {
+      await Dns.InitIpDaemon({ deployId: process.argv[3] });
+    }
+    break;
+
+  case 'run': {
+    const confCronConfig = JSON.parse(fs.readFileSync(`./engine-private/conf/${process.argv[3]}/conf.cron.json`));
+    if (confCronConfig.jobs && Object.keys(confCronConfig.jobs).length > 0) {
+      shellExec(`node bin/deploy conf ${process.argv[3]} production`);
+      for (const job of Object.keys(confCronConfig.jobs)) {
+        if (confCronConfig.jobs[job].enabled) {
+          shellExec(Cmd.cron(process.argv[3], job, confCronConfig.jobs[job].expression));
+          netWorkCron.push({
+            deployId: process.argv[3],
+            jobId: job,
+            expression: confCronConfig.jobs[job].expression,
+          });
+        }
+      }
+    }
+    await saveRuntimeCron();
+    if (fs.existsSync(`./tmp/await-deploy`)) fs.remove(`./tmp/await-deploy`);
+    break;
+  }
+
+  default:
+    break;
+}

package/bin/cyberia.js

@@ -0,0 +1,145 @@
+#! /usr/bin/env node
+
+import dotenv from 'dotenv';
+import { Command } from 'commander';
+import fs from 'fs-extra';
+import { shellExec, shellCd } from '../src/server/process.js';
+import { loggerFactory } from '../src/server/logger.js';
+import { DataBaseProvider } from '../src/db/DataBaseProvider.js';
+import {
+  pngDirectoryIteratorByObjectLayerType,
+  frameFactory,
+  getKeyFramesDirectionsFromNumberFolderDirection,
+  buildImgFromTile,
+  generateRandomStats,
+  itemTypes,
+} from '../src/server/object-layer.js';
+
+import crypto from 'crypto';
+
+shellCd(`/home/dd/engine`);
+
+const logger = loggerFactory(import.meta);
+
+const deployId = process.env.DEFAULT_DEPLOY_ID;
+const host = process.env.DEFAULT_DEPLOY_HOST;
+const path = process.env.DEFAULT_DEPLOY_PATH;
+
+const confServerPath = `./engine-private/conf/${deployId}/conf.server.json`;
+const confServer = JSON.parse(fs.readFileSync(confServerPath, 'utf8'));
+const { db } = confServer[host][path];
+
+db.host = db.host.replace('127.0.0.1', 'mongodb-0.mongodb-service');
+
+logger.info('env', {
+  deployId,
+  host,
+  path,
+  db,
+});
+
+await DataBaseProvider.load({
+  apis: ['object-layer'],
+  host,
+  path,
+  db,
+});
+
+const ObjectLayer = DataBaseProvider.instance[`${host}${path}`].mongoose.models.ObjectLayer;
+
+await ObjectLayer.deleteMany();
+
+const program = new Command();
+
+const version = JSON.parse(fs.readFileSync('./package.json', 'utf8')).version;
+
+program
+  .name('cyberia')
+  .description(
+    `    cyberia online network object layer management ${version}
+    https://www.cyberiaonline.com/object-layer-engine`,
+  )
+  .version(version);
+
+program
+  .command('ol')
+  .option('--import [object-layer-type]', 'Commas separated object layer types e.g. skin,floors')
+  .option('--show-frame <show-frame-input>', 'View object layer frame e.g. anon_08_0')
+  .option('--env-path <env-path>', 'Env path e.g. ./engine-private/conf/dd-cyberia/.env.development')
+  .action(async (options = { import: false, showFrame: '', envPath: '' }) => {
+    if (!options.envPath) options.envPath = `./engine-private/conf/dd-cyberia/.env.production`;
+
+    dotenv.config({ path: options.envPath, override: true });
+
+    const objectLayers = {};
+
+    if (options.import || options.showFrame) {
+      const argItemTypes = options.import === 'all' ? Object.keys(itemTypes) : options.import.split(',');
+      for (const argItemType of argItemTypes) {
+        await pngDirectoryIteratorByObjectLayerType(
+          argItemType,
+          async ({ path, objectLayerType, objectLayerId, direction, frame }) => {
+            if (options.showFrame && !`${objectLayerId}_${direction}_${frame}`.match(options.showFrame)) return;
+            console.log(path, { objectLayerType, objectLayerId, direction, frame });
+            if (!objectLayers[objectLayerId]) {
+              const metadataPath = `./src/client/public/cyberia/assets/${objectLayerType}/${objectLayerId}/metadata.json`;
+              const metadata = fs.existsSync(metadataPath) ? JSON.parse(fs.readFileSync(metadataPath, 'utf8')) : null;
+              objectLayers[objectLayerId] = metadata
+                ? metadata
+                : {
+                    data: {
+                      render: {
+                        frame_duration: 250,
+                        is_stateless: false,
+                      },
+                      item: {
+                        id: objectLayerId,
+                        type: objectLayerType,
+                        description: '',
+                        activable: true,
+                      },
+                      stats: generateRandomStats(),
+                    },
+                  };
+              objectLayers[objectLayerId].data.render.colors = [];
+              objectLayers[objectLayerId].data.render.frames = {};
+            }
+            const frameFactoryResult = await frameFactory(path, objectLayers[objectLayerId].data.render.colors);
+            objectLayers[objectLayerId].data.render.colors = frameFactoryResult.colors;
+            for (const objectLayerFrameDirection of getKeyFramesDirectionsFromNumberFolderDirection(direction)) {
+              if (!objectLayers[objectLayerId].data.render.frames[objectLayerFrameDirection])
+                objectLayers[objectLayerId].data.render.frames[objectLayerFrameDirection] = [];
+              objectLayers[objectLayerId].data.render.frames[objectLayerFrameDirection].push(frameFactoryResult.frame);
+            }
+          },
+        );
+      }
+      for (const objectLayerId of Object.keys(objectLayers)) {
+        objectLayers[objectLayerId].sha256 = crypto
+          .createHash('sha256')
+          .update(JSON.stringify(objectLayers[objectLayerId].data))
+          .digest('hex');
+        console.log(await ObjectLayer.create(objectLayers[objectLayerId]));
+      }
+    }
+    if (options.showFrame) {
+      const [objectLayerId, direction, frame] = options.showFrame.split('_');
+      const objectLayerFrameDirection = getKeyFramesDirectionsFromNumberFolderDirection(direction)[0];
+
+      await buildImgFromTile({
+        tile: {
+          map_color: objectLayers[objectLayerId].data.render.colors,
+          frame_matrix: objectLayers[objectLayerId].data.render.frames[objectLayerFrameDirection][0],
+        },
+        cellPixelDim: 20,
+        opacityFilter: (x, y, color) => 255,
+        imagePath: `./${options.showFrame}.png`,
+      });
+
+      shellExec(`firefox ./${options.showFrame}.png`);
+    }
+    await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
+  })
+  .description('Object layer management');
+
+program.parse();

package/bin/db.js

@@ -0,0 +1,199 @@
+import fs from 'fs-extra';
+import { shellExec } from '../src/server/process.js';
+import { loggerFactory } from '../src/server/logger.js';
+import { MariaDB } from '../src/db/mariadb/MariaDB.js';
+import { Lampp } from '../src/runtime/lampp/Lampp.js';
+import { getCapVariableName, loadConf, splitFileFactory } from '../src/server/conf.js';
+import { DataBaseProvider } from '../src/db/DataBaseProvider.js';
+import { hashPassword } from '../src/server/auth.js';
+
+const logger = loggerFactory(import.meta);
+
+logger.info('argv', process.argv);
+
+const [exe, dir, hostPath = '', operator, deployId, arg0, arg1, arg2] = process.argv;
+const [host, _path = ''] = hostPath.split('/');
+const path = `/${_path}`;
+
+try {
+  let cmd;
+  if (deployId) loadConf(deployId);
+  const confServer = JSON.parse(fs.readFileSync(`./conf/conf.server.json`, 'utf8'));
+  const { runtime, db, git, client, directory } = confServer[host][path];
+  const { provider, name, user, password = '', backupPath = '' } = db;
+  // logger.info('database', confServer[host][`/${path}`].db);
+  switch (provider) {
+    case 'mariadb':
+      // Login:
+      // mysql -u root -h localhost -p
+
+      // Get Users:
+      // SELECT user,authentication_string,plugin,host FROM mysql.user;
+
+      // Get DB User:
+      // SELECT User, Db, Host from mysql.db;
+
+      // Change password:
+      // ALTER USER 'root'@'127.0.0.1' IDENTIFIED BY 'NEW_PASSWORD';
+      // ALTER USER 'root'@'localhost' IDENTIFIED BY 'NEW_PASSWORD';
+      // ALTER USER 'root'@'::1' IDENTIFIED BY 'NEW_PASSWORD';
+
+      // Get all user privileges:
+      // select * from information_schema.user_privileges;
+
+      // Expose public server:
+      // '/etc/mysql/my.cnf' Change lines:
+      // bind-address = 127.0.0.1 -> bind-address = 0.0.0.0
+      // skip-networking -> #skip-networking
+
+      // Create user:
+      // DROP USER 'username'@'%';
+      // CREATE USER 'username'@'%' IDENTIFIED BY 'password';
+
+      // Set DB user:
+      // FLUSH PRIVILEGES;
+      // ON databasename.*
+      // TO 'username'@'%'
+      // IDENTIFIED BY 'newpassword';
+      // FLUSH PRIVILEGES;
+
+      // Set admin:
+      // FLUSH PRIVILEGES;
+      // GRANT ALL PRIVILEGES ON *.* TO 'username'@'%' IDENTIFIED BY 'password' WITH GRANT OPTION;
+      // FLUSH PRIVILEGES;
+
+      switch (operator) {
+        case 'show-all':
+          await MariaDB.query({ user, password, query: `SHOW DATABASES` });
+          break;
+        case 'show':
+          await MariaDB.query({ user, password, query: `SHOW TABLES FROM ${name}` });
+          break;
+        case 'create':
+          await MariaDB.query({ user, password, query: `CREATE DATABASE ${name}` });
+          break;
+        case 'delete':
+          await MariaDB.query({ user, password, query: `DROP DATABASE IF EXISTS ${name}` });
+          break;
+        case 'select':
+          {
+            const pageSize = 10;
+            const pageNumber = 1;
+            await MariaDB.query({
+              user,
+              password,
+              query: `SELECT ${arg0} FROM ${name}.${arg1} LIMIT ${pageSize} OFFSET ${(pageNumber - 1) * pageSize}`,
+            });
+          }
+          break;
+        case 'count': {
+          await MariaDB.query({
+            user,
+            password,
+            query: `SELECT COUNT(*) AS total FROM ${name}.${arg0}`,
+          });
+        }
+        case 'export':
+          {
+            const cmdBackupPath = `${arg0 ? `${arg0}/${name}.sql` : backupPath}`;
+
+            cmd = `mysqldump -u ${user} -p${password} ${name} > ${cmdBackupPath}`;
+            shellExec(cmd);
+            await splitFileFactory(name, cmdBackupPath);
+          }
+          break;
+        case 'import':
+          break;
+
+        case 'init-lampp-service':
+          await Lampp.initService();
+          break;
+        case 'remote-client-access':
+          {
+            // https://docs.anaconda.com/miniconda/install/#quick-command-line-install
+            // https://mariadb.com/kb/en/configuring-mariadb-for-remote-client-access/
+            // conf: /opt/lampp/etc
+            // conf: /etc/mysql/my.cnf
+            // conf: /etc/mysql/mariadb.conf.d/50-server.cnf
+            // cli: /opt/lampp/bin/mysql
+            // cli: mysql -h 127.0.0.1
+            // select db: use db0;
+          }
+          break;
+        default:
+          break;
+      }
+
+      break;
+
+    case 'mongoose':
+      // MongoDB App Services CLI
+      switch (operator) {
+        case 'update':
+          {
+            await DataBaseProvider.load({ apis: [arg0], host, path, db });
+            const models = DataBaseProvider.instance[`${host}${path}`].mongoose.models[getCapVariableName(arg0)];
+
+            const select = JSON.parse(arg1.replaceAll("'", `"`));
+            const update = JSON.parse(arg2.replaceAll("'", `"`));
+
+            console.log({ models, select, update });
+
+            switch (arg0) {
+              case 'user':
+                if (update.password) update.password = hashPassword(update.password);
+
+              default:
+                break;
+            }
+            let doc = await models.findOne(select);
+            if (doc) {
+              doc = await models.findByIdAndUpdate(doc._id, update, {
+                runValidators: true,
+              });
+              logger.info(`successfully updated doc`, doc._doc);
+              await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
+            } else throw new Error(`no doc found`);
+          }
+          break;
+        case 'show-all':
+          // show dbs
+          break;
+        case 'show':
+          break;
+        case 'create':
+          break;
+        case 'delete':
+          {
+            await DataBaseProvider.load({ apis: [arg0], host, path, db });
+            const models = DataBaseProvider.instance[`${host}${path}`].mongoose.models[getCapVariableName(arg0)];
+            await models.collection.drop();
+            logger.info(`successfully drop collection`, arg0);
+            await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
+          }
+          break;
+        case 'export':
+          // mongodump -d <database_name> -o <directory_backup>
+          shellExec(`mongodump -d ${name} -o ${arg0 ? arg0 : `./engine-private/mongodb-backup/`}`);
+          break;
+        case 'import':
+          // mongorestore -d <database_name> <directory_backup>
+          break;
+        case 'init-service':
+          break;
+        default:
+          break;
+      }
+      break;
+
+    default:
+      break;
+  }
+
+  // logger.info(`Run the following command`, cmd);
+  // await ncp.copy(cmd);
+  // await read({ prompt: 'Command copy to clipboard, press enter to continue.\n' });
+  // throw new Error(``);
+} catch (error) {
+  logger.error(error, error.stack);
+}