@rpcbase/server 0.65.0 → 0.68.0

package/bin.js

@@ -13,22 +13,18 @@ const run_agent = require("./cli/run_agent")
 let is_command = false
 
 const args = yargs(hideBin(process.argv))
-  .command("start", "run server/infrastructure", () => {}, (argv) => {
+  .command("start", "run server/infrastructure", () => {}, (args) => {
     is_command = true
-    start_server()
+    start_server(args)
   })
-  .command("agent", "run the agent", () => {}, (argv) => {
+  .command("agent", "run the agent", () => {}, (args) => {
     is_command = true
     run_agent()
   })
-  .command("build", "build server", () => {}, (argv) => {
+  .command("build", "build server", () => {}, (args) => {
     is_command = true
     build_server()
   })
-  .command("ping", "ping", () => {}, (argv) => {
-    is_command = true
-    console.log("PING")
-  })
   .option("verbose", {
     alias: "v",
     type: "boolean",
@@ -38,5 +34,12 @@ const args = yargs(hideBin(process.argv))
   .parse()
 
 if (!is_command) {
-  console.log("default com22mand")
+  console.log("server default com22mand")
 }
+
+// // add helpers to ensure proper process termination
+// const exit_clean = () => {
+//   process.exit()
+// }
+// process.on("SIGINT", exit_clean) // ctrl-c
+// process.on("SIGTERM", exit_clean) // kill

package/cli/build_server.js

@@ -2,7 +2,6 @@
 const path = require("path")
 const fs = require("fs")
 
-const get_runtime = require("./get_runtime")
 const run_docker = require("./run_docker")
 const run_native = require("./run_native")
 
@@ -11,11 +10,10 @@ const build_server = async() => {
   // const build_schemas =
   // const infrastructure_dir = path.join(process.cwd(), "../infrastructure")
   //
-  // // prefix
+  // prefix
   // const proj_parent_dir = path.join(infrastructure_dir, "../../")
   // const proj_prefix = path.basename(proj_parent_dir)
   //
-  // const runtime = get_runtime()
   //
   // if (runtime === "native") {
   //   run_native(infrastructure_dir, proj_prefix)

package/cli/run_docker.js

@@ -1,61 +1,44 @@
 /* @flow */
-const {spawn} = require("child_process")
+const {execSync} = require("child_process")
 const path = require("path")
+const fs = require("fs")
 
 const chalk = require("chalk")
 
 const is_production = "yes" === process.env.INFRASTRUCTURE_IS_PRODUCTION
 
-const run_docker = async(infrastructure_dir, proj_prefix, is_native) => {
+const run_docker = async(infrastructure_dir, proj_prefix) => {
   // env
   const env_path = path.relative(infrastructure_dir, path.join(process.cwd(), "./.env"))
 
+  const exists = (f) => {
+    const target_path = path.join(infrastructure_dir, f)
+    return fs.existsSync(target_path)
+  }
+
   // compose files
   const compose_files = ["-f", "common.yml"]
-  if (!is_native) {
-    compose_files.push("-f", "native.yml")
-  }
-  if (is_production) {
+  // TODO: which files are loaded and when should be documented
+  // when running with native mode, do not load native infrastructure
+  if (is_production && exists("prod.yml")) {
     compose_files.push("-f", "prod.yml")
   }
-  else compose_files.push("-f", "dev.yml")
+  if (!is_production && exists("dev.yml")) {
+    compose_files.push("-f", "dev.yml")
+  }
 
   const opts = ["--build", "--remove-orphans"]
   if (!is_production) opts.push("--abort-on-container-exit")
 
   const cmd = "docker-compose"
-  // const cmd_args = `--env-file ${env_path} -p ${proj_prefix} ${compose_files.join(" ")} up ${opts.join(" ")}`
   const cmd_args = ["--env-file", env_path, "-p", proj_prefix, ...compose_files, "up", ...opts]
 
   console.log(cmd_args.join(" "))
 
-  const ps = spawn(cmd, cmd_args, {cwd: infrastructure_dir})
-  ps.stdout.on("data", (data) => {
-    const lines = data.toString().split("\n")
-    lines.forEach((line) => {
-      if (line.trim() === "") {
-        return
-      }
-      process.stdout.write(`${chalk.cyan("docker")}: ${line}\n`)
-    })
-  })
-
-  ps.stderr.on("data", (data) => {
-    const lines = data.toString().split("\n")
-    lines.forEach((line) => {
-      if (line.trim() === "") {
-        return
-      }
-      process.stdout.write(`${chalk.cyan("docker")}: ${chalk.yellow(line)}\n`)
-    })
-  })
-
-  // try {
-  //
-  // } catch (err) {
-  //   console.log("start_server::error\n", err)
-  //   process.exit(1)
-  // }
+  // WARNING: blocks the process
+  // this is the only way to have docker-compose shut down gracefully
+  execSync(`${cmd} ${cmd_args.join(" ")}`, {cwd: infrastructure_dir, stdio: "inherit"})
+
 }
 
 module.exports = run_docker

package/cli/run_native.js

@@ -1,46 +1,92 @@
 /* @flow */
 const {spawn} = require("child_process")
-// const dotenv = require("dotenv")
 const path = require("path")
 const fs = require("fs")
 
+const dotenv = require("dotenv")
+const mkdirp = require("mkdirp")
 
-const run_processes = [
-  ["yarn", ["dev"]]
-  // ["mongod", [
-  //   "--quiet",
-  //   "--port", "$DATABASE_PORT_0",
-  //   "--replSet", "rs0",
-  //   "--logpath", "/var/log/logs.txt",
-  // ]],
-  // ["mongod", [
-  //   "--quiet",
-  //   "--port", "$DATABASE_PORT_2",
-  //   "--replSet", "rs0",
-  //   "--logpath", "/var/log/logs.txt",
-  // ]],
-]
-
-// const get_env = () => {
-//   const env_path = path.join(process.cwd(), ".env")
-//   const env_buf = fs.readFileSync(env_path)
-//   const env = dotenv.parse(env_buf)
-//   return env
-// }
+// TODO: verify mongod and redis-sever executables are present
+// and have the right version
 
+// "redis-server", "/usr/local/etc/redis/redis.conf", "--port", $WORKER_QUEUE_PORT
+
+// load env
+const get_env = () => {
+  const env_path = path.join(process.cwd(), "./.env")
+  const env_buf = fs.readFileSync(env_path)
+  const env = dotenv.parse(env_buf)
+  return env
+}
+
+const init_processes = () => {
+  const env = get_env()
+
+  const infrastructure_conf_dir = path.join(__dirname, "../infrastructure")
+
+  // create data dirs
+  const db_path = path.join(process.cwd(), "../infrastructure/data/database/db/")
+  if (!fs.existsSync(db_path)) {
+    mkdirp.sync(db_path)
+  }
+  const db_logs_path = path.join(process.cwd(), "../infrastructure/data/database/log/")
+  if (!fs.existsSync(db_logs_path)) {
+    mkdirp.sync(db_logs_path)
+  }
+
+
+  const processes = [
+    // web server
+    // TODO: do not use yarn dev server command
+    {name: "server", cmd: ["yarn", ["dev"]]},
+    // mongodb database
+    {name: "database", cmd: ["mongod", [
+      "--quiet",
+      "--dbpath", db_path,
+      "--port", env.DATABASE_PORT,
+      // "--bind_ip_all",
+      // "--logpath", "/var/log/logs.txt",
+      "--replSet", "rs0"
+    ]]},
+    {name: "session-store", cmd: ["redis-server", [
+      path.join(infrastructure_conf_dir, "./redis/redis.conf"),
+      "--port", env.SESSION_STORE_PORT,
+    ]]},
+
+    // redis worker-queue
+    // redis session-store
+    // TODO: add a redis cache
+  ]
+
+  return processes
+}
 
 // TODO: run each native process from list
 // TODO: handle process close
 const run_native = (infrastructure_dir, proj_prefix) => {
   console.log("running in NATIVE mode")
-  // const env = get_env()
 
-  const ps = spawn("yarn", ["dev"], {env: {...process.env, CONTAINER_MODE: "native"}})
-  ps.stdout.on("data", (data) => {
-    process.stdout.write(data.toString())
-  })
+  const processes = init_processes()
+
+  const run_process = (item) => {
+    // console.log("start process", item)
+    const ps = spawn(item.cmd[0], item.cmd[1], {env: {...process.env, CONTAINER_MODE: "native"}})
 
+    ps.stdout.on("data", (data) => {
+      process.stdout.write(`${item.name}: ${data.toString()}`)
+    })
 
+    ps.stderr.on("data", (data) => {
+      process.stderr.write(`${item.name}: ${data.toString()}`)
+    })
+  }
+
+  const spawned = processes.map(run_process)
+
+  process.on("exit", () => {
+    console.log("EXIT from native1")
+    // ps.kill()
+  })
 }
 
 module.exports = run_native

package/cli/start_server.js

@@ -2,30 +2,29 @@
 const path = require("path")
 const fs = require("fs")
 
-const get_runtime = require("./get_runtime")
 const run_docker = require("./run_docker")
 const run_native = require("./run_native")
-
+const get_runtime = require("./get_runtime")
 
 // TODO: auto create network if necessary
 // docker network create local-network
 
-const start_server = async() => {
+const start_server = async(args) => {
   const infrastructure_dir = path.join(process.cwd(), "../infrastructure")
 
+  const runtime = get_runtime()
+
   // prefix
   const proj_parent_dir = path.join(infrastructure_dir, "../../")
   const proj_prefix = path.basename(proj_parent_dir)
 
-  const runtime = get_runtime()
-
-  if (runtime === "native") {
-    run_docker(infrastructure_dir, proj_prefix, true)
+  if (runtime === "docker") {
+    run_docker(infrastructure_dir, proj_prefix)
+  } else if (runtime === "native") {
     run_native(infrastructure_dir, proj_prefix)
   } else {
-    run_docker(infrastructure_dir, proj_prefix)
+    throw new Error("unknown runtime")
   }
-
 }
 
 module.exports = start_server

package/infrastructure/mongodb/mongod.conf

@@ -0,0 +1,9 @@
+systemLog:
+  destination: file
+  path: /opt/homebrew/var/log/mongodb/mongo.log
+  logAppend: true
+storage:
+  dbPath: /opt/homebrew/var/mongodb
+net:
+  bindIp: 127.0.0.1, ::1
+  ipv6: true