godprotocol 1.2.25 → 1.2.27

package/Objects/Oracle.js

@@ -1,321 +1,108 @@
-import Fs from "godprotocol/repos/fs.js";
-import Github from "godprotocol/repos/github.js";
-import Handlers from "godprotocol/utils/oracle_handlers.js";
-import { post_request } from "godprotocol/utils/services.js";
-
-class Oracle extends Handlers {
-  constructor(server, mirror) {
-    super();
+import { post_request } from "../utils/services.js";
 
+class Oracle_client {
+  constructor(server) {
     this.server = server;
-    this.mirror = mirror;
-    this.repos = new Array();
-    this.remotes = new Array();
 
-    this.account_repos = new Object();
-    this.configs = new Object();
+    this.repo_cache = new Object();
   }
 
-  fetch = async (payload, server) => {
-    let response;
-    try {
-      response = await post_request({
-        options: {
-          ...server,
-          path: "/oracle",
-        },
-        data: JSON.stringify(payload),
-      });
-    } catch (e) {}
-
-    return response;
-  };
-
-  call = async (payload) => {
-    let { method, args } = payload;
-
-    switch (method) {
-      case "update_servers":
-        let { repos, account, server } = args;
-
-        let servers = await this.get_servers(account);
-        if (servers.find((serv) => this.server_match(serv, server))) return;
-        servers.push(server);
-
-        let reps = await this.set_to_repos(
-          `.oracle/${account}/.config`,
-          JSON.stringify(servers),
-          { exclude: repos }
-        );
-        await this.merge_repos([...repos, ...reps], account);
-
-        return reps;
-        break;
-    }
-  };
-
-  stringify_repos = async () => {
-    let rp = [];
-    for (let r = 0; r < this.repos.length; r++) {
-      let repo = this.repos[r];
-
-      rp.push({ repo: await repo.repo.objectify(), filter: repo.filter });
-    }
-    return rp;
-  };
-
-  server_match = (s1, s2) => {
-    return s1.port === s2.port && s1.hostname === s2.hostname;
-  };
-
-  cloth_repo = async (repo) => {
-    switch (repo.type) {
-      case "fs":
-        repo = new Fs(repo.options || repo);
-        break;
-      case "github":
-        repo = new Github(repo.options || repo);
-        break;
-    }
-
-    return repo;
+  add_repo = async (repo) => {
+    await this.fetch({
+      method: "add_repo",
+      args: repo,
+    });
   };
 
-  repo_object = (repos, account) => {
-    repos = [...repos];
-    let acc_repos = this.account_repos[account] || [];
-    for (let r = 0; r < repos.length; r++) {
-      let repo = repos[r];
-
-      let fnd =
-        this.repos.find((r) => r.repo.get_id() === repo) ||
-        acc_repos.find((r) => (r.repo._id || r.repo.get_id()) === repo);
-      if (fnd) {
-        if (fnd.repo.get_id) {
-          fnd = { ...fnd };
-          fnd.repo = fnd.repo.objectify();
-        }
-        repos[r] = fnd;
-      }
-    }
-
-    return repos.filter((r) => !!r.repo);
-  };
-
-  merge_repos = async (repos, account) => {
-    let reps = Array.isArray(account) ? account : this.account_repos[account];
-    if (!reps) {
-      reps = new Array();
-      this.account_repos[account] = reps;
-    }
-
-    for (let r = 0; r < repos.length; r++) {
-      let repo = repos[r];
-      if (reps.find((rp) => rp.repo._id === repo.repo._id)) continue;
-
-      repo.repo = await this.cloth_repo(repo.repo);
-
-      reps.push(repo);
-    }
-    return reps;
+  write = async (path, content) => {
+    await this.fetch({
+      method: Array.isArray(content) ? "write_bulk" : "write",
+      args: { path, content },
+    });
   };
 
-  get_from_repos = async (path, options = {}) => {
-    let repos = await this.parse_option_repos(options),
+  read = async (path) => {
+    let repo = this.repo_cache[path],
       content;
 
-    for (let r = 0; r < repos.length; r++) {
-      let repo = repos[r];
-      if (!repo.filter || path.match(repo.filter)) {
-        content = await repo.repo.read_file(path);
-        if (content) break;
+    if (repo) {
+      content = await repo.read(path);
+    }
+    if (!content) {
+      let response = await this.fetch({
+        method: "read",
+        args: { path },
+      });
+      content = response.content;
+      if (content) {
+        repo = response.repo;
+        repo = await this.cloth_repo(repo);
+        if (repo) this.repo_cache[path] = response.repo;
       }
     }
     return content;
   };
 
-  parse_option_repos = async (options) => {
-    let repos = [];
-    if (options.repos) {
-      for (let r = 0; r < options.repos.length; r++) {
-        let rep = options.repos[r];
-
-        repos.push({
-          filter: rep.filter,
-          repo: rep.repo.get_id ? rep.repo : await this.cloth_repo(rep.repo),
-        });
-      }
-    } else repos = this.repos;
+  server_match = (s1, s2) => s1.hostname === s2.hostname && s1.port === s2.port;
 
-    return repos;
-  };
-
-  set_to_repos = async (path, content, options = {}) => {
-    let { exclude } = options;
-    let repos = await this.parse_option_repos(options),
-      reps = [];
-
-    for (let r = 0; r < repos.length; r++) {
-      let repo = repos[r];
-      if (exclude && exclude.find((e) => e._id === repo.repo.get_id())) {
-        continue;
-      }
-      if (!repo.filter || path.match(repo.filter)) {
-        await repo.repo.write_file(path, content);
+  update_servers = async (account) => {
+    let addr = `${account}/.servers`;
 
-        reps.push({ filter: repo.filter, repo: repo.repo.objectify() });
-      }
+    let servers = await this.read(addr);
+    servers = servers ? JSON.parse(servers) : [];
+    if (!servers.find((s) => this.server_match(s, this.client))) {
+      servers.push(this.client);
+      await this.write(addr, JSON.stringify(servers));
     }
-    return reps;
-  };
-
-  get_servers = async (account) => {
-    let servers = await this.get_from_repos(`.oracle/${account}/.config`);
-    if (servers) servers = JSON.parse(servers);
-    else servers = [];
-
     return servers;
   };
 
-  get_config = async (address, cache) => {
-    let conf;
-    if (cache) {
-      conf = this.configs[address];
-      if (conf) return conf;
-    }
-    conf = await this.get_from_repos(`.oracle/${address}/.config`);
-    if (!conf) return;
-
-    conf = JSON.parse(conf);
-    this.configs[address] = conf;
-
-    return conf;
-  };
-
-  dot_config = ".config";
-
-  write = async (path, content, options = {}) => {
-    let { account, address } = options,
-      conf;
-
-    if (path.endsWith(this.dot_config)) {
-      let sli = path.slice(0, (this.dot_config.length + 1) * -1);
-      conf = await this.get_config(sli);
-
-      let conf_repos = conf ? this.repo_object(conf.repositories, account) : [];
-      let reps = await this.merge_repos(
-        conf_repos,
-        await this.filter_repos(`.oracle/${path}`)
-      );
-      conf = {
-        ...conf,
-        content,
-        repositories: reps.map((r) => r.repo._id || r.repo.get_id()),
+  fetch = async (payload) => {
+    let headers;
+    if (payload.method !== "authenticate" && !this.auth_token) {
+      await this.sync(this.client);
+    } else if (payload.method !== "authenticate") {
+      headers = {
+        authorisation: this.auth_token,
       };
-
-      this.configs[sli] = conf;
-
-      await this.set_to_repos(`.oracle/${path}`, JSON.stringify(conf), {
-        repos: reps,
-      });
-    } else {
-      conf = await this.get_config(address, true);
-
-      let conf_repos = conf ? this.repo_object(conf.repositories, account) : [];
-      let reps = await this.merge_repos(
-        conf_repos,
-        await this.filter_repos(`.storage/${path}`)
-      );
-      await this.set_to_repos(`.storage/${path}`, content, { repos: reps });
-    }
-  };
-
-  read = async (path, options = {}) => {
-    let { account, address } = options,
-      content;
-
-    if (path.endsWith(this.dot_config)) {
-      content = await this.get_config(
-        path.slice(0, (this.dot_config.length + 1) * -1)
-      );
-      content = content ? content.content : content;
-    } else {
-      let conf = await this.get_config(address, true);
-      let conf_repos = conf ? this.repo_object(conf.repositories, account) : [];
-      let reps = await this.merge_repos(
-        conf_repos,
-        await this.filter_repos(`.storage/${path}`)
-      );
-
-      content = await this.get_from_repos(`.storage/${path}`, { repos: reps });
     }
 
-    return content;
-  };
-
-  update_servers = async (account) => {
-    let servers = await this.get_servers(account);
-    if (servers.find((serv) => this.server_match(serv, this.server))) {
-      return;
-    }
-
-    servers.push(this.server);
-    let repos = await this.set_to_repos(
-      `.oracle/${account}/.config`,
-      JSON.stringify(servers)
-    );
-    this.account_repos[account] = repos;
-
-    for (let s = 0; s < servers.length - 1; s++) {
-      let server = servers[s];
-
-      let reps = await this.fetch(
-        {
-          method: "update_servers",
-          args: { account, repos, server: this.server },
+    try {
+      let resp = await post_request({
+        options: {
+          ...this.server,
+          path: `/oracle/${payload.method}`,
+          headers,
         },
-        server
-      );
+        data: JSON.stringify(payload.args),
+      });
 
-      await this.merge_repos(reps, account);
+      return resp || null;
+    } catch (e) {
+      console.warn("fetch error:", e.message || e);
+      return null;
     }
   };
 
-  filter_repos = async (address, repos) => {
-    repos = repos || this.repos;
+  sync = async (client, Repos) => {
+    this.client = client;
+    if (Repos) this.Repos = new Repos();
 
-    let filtered_repos = new Array();
-    for (let r = 0; r < repos.length; r++) {
-      let repo = repos[r];
+    let auth = await this.fetch({
+      method: "authenticate",
+      args: {
+        client: this.client,
+      },
+    });
 
-      if (!repo.filter || address.match(repo.filter)) {
-        filtered_repos.push(repo);
-      }
-    }
-
-    return filtered_repos;
-  };
-
-  get_repo = async (repo) => {
-    for (let r = 0; r < this.repos.length; r++) {
-      let rep = this.repos[r];
-
-      if (rep.repo.get_id() === repo.get_id()) return rep.repo;
+    if (auth.token) {
+      this.auth_token = auth.token;
     }
   };
 
-  add_repo = async (repository) => {
-    let { filter, repo } = repository;
-
-    repo = await this.cloth_repo(repo);
-    if (await this.get_repo(repo)) return;
-
-    this.repos.push({ filter, repo });
-  };
-
-  sync = async (mgr) => {
-    this.manager = mgr;
+  cloth_repo = async (repo) => {
+    return await this.Repos.cloth_repo(repo);
   };
 }
 
-export default Oracle;
+export default Oracle_client;