godprotocol 1.2.19 → 1.2.21

package/Objects/Oracle.js

@@ -3,355 +3,317 @@ 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{
+class Oracle extends Handlers {
   constructor(server, mirror) {
     super();
 
-    this.server = server
+    this.server = server;
     this.mirror = mirror;
-    this.repos = new Array()
-    this.remotes = new Array()
+    this.repos = new Array();
+    this.remotes = new Array();
+
+    this.account_repos = new Object();
+    this.configs = new Object();
   }
 
-  add_repo = async (repository)=>{
-    let {filter, repo} = repository
-    if (await this.get_repo(repo.type, repo.options.name))
-      return;
+  fetch = async (payload, server) => {
+    let response;
+    try {
+      response = await post_request({
+        options: {
+          ...server,
+          path: "/oracle",
+        },
+        data: JSON.stringify(payload),
+      });
+    } catch (e) {}
 
-    switch(repo.type){
-      case 'fs':
-        repo = new Fs(repo.options)
-        break
-      case 'github':
-        repo = new Github(repo.options)
-        break
-    }
-    this.repos.push({filter, repo})
+    return response;
+  };
 
-    if(!this.manager) return;
-    if (this.server_match(this.manager.server, this.server)){
-      for (let r=0; r< this.remotes.length; r++){
-        let remote = this.remotes[r]
+  call = async (payload) => {
+    let { method, args } = payload;
 
-        await this.fetch({
-          method: 'add_repo',
-          arg: {...repo}
-        }, remote)
-      }
-    } else {
-      await this.fetch({
-        method: 'add_repo',
-        arg: {...repo}
-      }, this.server)
-    }
-  }
+    switch (method) {
+      case "update_servers":
+        let { repos, account, server } = args;
 
-  call = async(payload)=>{
-    let {method, arg} = payload, result = {};
-
-    switch(method){
-      case 'update_servers':
-        let addr = `.oracle/${arg.account}/.configs`
-        let servers = await this.get_from_repos(addr)
-        if (servers){
-          servers = JSON.parse(servers)
-          if (servers.find(s=>this.server_match(s, arg.server))){
-            return
-          }
-          servers.push(arg.server)
-        }else servers = [arg.server]
-        
-        await this.set_to_repos(addr, JSON.stringify(servers))
-        break;
-      case 'update_accounts':
-        let a_addr = `.oracle/${arg.address}/.configs`
-        let accs = await this.get_from_repos(a_addr)
-        if (accs){
-          accs = JSON.parse(accs)
-          if (accs.includes(arg.account)){
-            return
-          }
-          accs.push(arg.account)
-        }else accs = [arg.account]
-        
-        await this.set_to_repos(a_addr, JSON.stringify(accs))
-        break
-      case 'get_accounts':
-        result = this.get_accounts(arg.address, true)
-        break
-      case 'get_servers':
-        result = this.get_servers(arg.account, true)
-        break
-      case 'write':
-        await this.set_to_repos(`${arg.prefix}/${arg.path}`, arg.content)
-        break;
-      case 'read':
-        let res = await this.get_from_repos(`${arg.prefix}/${arg.path}`)
-        result = {content: res}
+        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;
-      case 'fs':
-        let repo = await this.get_repo('fs', arg.name)
-        result = await repo.call(arg.payload)
-        break
-      case 'sync':
-        let repos = this.string_repos()
-        await this.push_remote(arg.manager_server)
-        result = {repos}
-        break
-      case 'add_repo':
-        await this.add_repo(arg)
-        break
     }
+  };
 
-    return result
-  }
+  stringify_repos = async () => {
+    let rp = [];
+    for (let r = 0; r < this.repos.length; r++) {
+      let repo = this.repos[r];
 
-  push_remote = async(remote)=>{
-    if (this.remotes.find(rem=>this.server_match(rem, remote))) return;
+      rp.push({ repo: await repo.repo.objectify(), filter: repo.filter });
+    }
+    return rp;
+  };
 
-    this.remotes.push(remote)
-  }
+  server_match = (s1, s2) => {
+    return s1.port === s2.port && s1.hostname === s2.hostname;
+  };
 
-  string_repos = ()=>{
-    let repos = new Array();
-    for(let r=0; r< this.repos.length; r++){
-      let {filter, repo} = this.repos[r];
-      repos.push({filter, repo:{type: repo.type, options: repo.objectify()}})
+  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 repos;
-  }
 
-  get_repo = async(type, name) => {
-    for (let r=0; r< this.repos.length; r++){
-      let {repo} = this.repos[r]
+    return repo;
+  };
 
-      if (repo.type === type && repo.name === name)
-        return 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;
+      }
     }
-  }
 
-  fetch = async(payload, server)=>{
-    let res;
-    try{
-      res = await post_request({
-        options: {
-          ...server,
-          path: '/oracle'
-        },
-        data: JSON.stringify(payload)
-      })
-    }catch(e){
-      console.log(e)
+    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;
     }
 
-    return res;
-  }
+    for (let r = 0; r < repos.length; r++) {
+      let repo = repos[r];
+      if (reps.find((rp) => rp.repo._id === repo.repo._id)) continue;
 
-  set_to_repos = async(address, content, options)=>{
-    let {count, args} = options, counted = count != null, res;
-    for (let r=0; r< this.repos.length; r++){
-      let repo = this.repos[r]
+      repo.repo = await this.cloth_repo(repo.repo);
 
-      if (!repo.filter || address.match(repo.filter)){
-        res = await repo.repo.write_file(address, content, args)
-        if (!args.just_exists){
-          res = await repo.repo.objectify()
-        }
-        if (counted && !count) break;
-        count --
-      }
+      reps.push(repo);
     }
+    return reps;
+  };
 
-    return res;
-  }
+  get_from_repos = async (path, options = {}) => {
+    let repos = await this.parse_option_repos(options),
+      content;
 
-  get_from_repos = async(address, repo_)=>{
-    let content
-    for (let r=0; r< this.repos.length; r++){
-      let repo = this.repos[r]
-      
-      if(repo_ && repo.repo.match(repo_)){
-        content = await repo.repo.read_file(address)
-        break
-      } else if (!repo.filter || address.match(repo.filter)){
-        content = await repo.repo.read_file(address)
-        if (content) break
+    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;
       }
     }
-    return content
-  }
+    return content;
+  };
 
-  read = async(path, options={})=>{
-    let {address, account, prefix} = options;
-    prefix = prefix || '.storage'
-
-    let has = (await this.get_accounts(address)).includes(account)
-
-    if(!has) return;
-    
-    let servers = await this.get_servers(account)
-    for (let s=0; s< servers.length; s++){
-      let server = servers[s]
-      if (this.server_match(server, this.server)){
-        let res = await this.fetch({
-          method: 'read',
-          arg: {path, prefix}
-        }, server)
-        
-        if(res && res.content){
-          return res.content
-        }else break;
-      }
-    }
-    for (let s=0; s< servers.length; s++){
-      let server = servers[s]
-      if (this.server_match(server, this.server)){
-        continue
-      }
+  parse_option_repos = async (options) => {
+    let repos = [];
+    if (options.repos) {
+      for (let r = 0; r < options.repos.length; r++) {
+        let rep = options.repos[r];
 
-      let res = await this.fetch({
-        method: 'read',
-        arg: {path, prefix}
-      }, server)
-      if(res && res.content){
-        return res.content
+        repos.push({
+          filter: rep.filter,
+          repo: rep.repo.get_id ? rep.repo : await this.cloth_repo(rep.repo),
+        });
       }
-    }
-  }
-
-  write = async(path, content, options={})=>{
-    let {account, address, prefix} = options
-    prefix = prefix || '.storage'
+    } else repos = this.repos;
 
-    await this.update_accounts(address, account)
-    let servers = await this.get_servers(account)
+    return repos;
+  };
 
-    for (let s=0; s< servers.length; s++){
-      let server = servers[s]
+  set_to_repos = async (path, content, options = {}) => {
+    let { exclude } = options;
+    let repos = await this.parse_option_repos(options),
+      reps = [];
 
-      await this.fetch({
-        method: 'write',
-        arg: {path, content, prefix}
-      }, server)
-    }
-  }
+    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);
 
-  get_servers = async(account, mirroring)=>{
-    let addr = `.oracle/${account}/.configs`
-    let servers = await this.get_from_repos(addr)
-    servers = servers ? JSON.parse(servers) : []
-
-    if(!mirroring && !servers.length && this.mirror){
-      servers = await this.fetch({
-        method: 'get_servers',
-        arg: {account}
-      }, this.mirror)
-      if (servers.length){ 
-        await this.set_to_repos(addr, JSON.stringify(servers))
-        await this.update_servers(account, [...servers])
+        reps.push({ filter: repo.filter, repo: repo.repo.objectify() });
       }
     }
-    return 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 = [];
 
-  update_servers = async(account, servers)=>{
-    servers = servers || await this.get_servers(account)
-    
-    if (servers.find(s=>this.server_match(s, this.server))){
-      return
+    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;
 
-    servers.push(this.server)
-    for (let s=0; s< servers.length; s++){
-      let server = servers[s]
+    conf = JSON.parse(conf);
+    this.configs[address] = conf;
 
-      await this.fetch({
-        method: 'update_servers',
-        arg: {account, server: this.server},
-      }, server)
+    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(path)
+      );
+
+      await this.set_to_repos(
+        `.oracle/${path}`,
+        JSON.stringify({
+          ...conf,
+          content,
+          repositories: reps.map((r) => r.repo._id || r.repo.get_id()),
+        }),
+        { 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(path)
+      );
+      await this.set_to_repos(`.storage/${path}`, content, { repos: reps });
     }
+  };
 
-    return servers
-  }
+  read = async (path, options = {}) => {
+    let { account, address } = options,
+      content;
 
-  get_accounts = async(address, mirroring)=>{
-    let addr = `.oracle/${address}/.configs`
-    let accounts = await this.get_from_repos(addr)
-    
-    accounts = accounts ? JSON.parse(accounts) : []
-
-    if (!mirroring && !accounts.length && this.mirror){
-      accounts = await this.fetch({
-        method: 'get_accounts',
-        arg: {address}
-      }, this.mirror)
+    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(path)
+      );
+
+      content = await this.get_from_repos(`.storage/${path}`, { repos: reps });
     }
 
-    return accounts 
-  }
+    return content;
+  };
 
-  update_accounts = async(address, account)=>{
-    let accounts = await this.get_accounts(address)
-    
-    if (accounts.includes(account)){
-      return
+  update_servers = async (account) => {
+    let servers = await this.get_servers(account);
+    if (servers.find((serv) => this.server_match(serv, this.server))) {
+      return;
     }
 
-    accounts.push(account)
+    servers.push(this.server);
+    let repos = await this.set_to_repos(
+      `.oracle/${account}/.config`,
+      JSON.stringify(servers)
+    );
+    this.account_repos[account] = repos;
 
-    let servers = await this.get_servers_from_address(address, accounts)
+    for (let s = 0; s < servers.length - 1; s++) {
+      let server = servers[s];
 
-    for (let s=0; s< servers.length; s++){
-      let server = servers[s]
+      let reps = await this.fetch(
+        {
+          method: "update_servers",
+          args: { account, repos, server: this.server },
+        },
+        server
+      );
 
-      await this.fetch({
-        method: 'update_accounts',
-        arg: {address, account},
-      }, server)
+      await this.merge_repos(reps, account);
     }
+  };
 
-    return accounts
-  }
+  filter_repos = async (address, repos) => {
+    repos = repos || this.repos;
+
+    let filtered_repos = new Array();
+    for (let r = 0; r < repos.length; r++) {
+      let repo = repos[r];
 
-  get_servers_from_address = async(address, accounts)=>{
-    accounts = accounts || await this.get_accounts(address)
-
-    let servers = []
-    for (let a=0; a< accounts.length; a++){
-      let acc = accounts[a]
-      let servers_ = await this.get_servers(acc)
-      servers_.map(serv=>{
-        if(!servers.find(s=>this.server_match(s, serv)))
-          servers.push(serv)
-      })
+      if (!repo.filter || address.match(repo.filter)) {
+        filtered_repos.push(repo);
+      }
     }
 
-    return servers
-  }
+    return filtered_repos;
+  };
 
-  server_match = (s1, s2)=>{
-    return s1.hostname === s2.hostname && s1.port === s2.port
-  }
+  get_repo = async (repo) => {
+    for (let r = 0; r < this.repos.length; r++) {
+      let rep = this.repos[r];
 
-  set_manager = async(manager)=>{
-    console.log(`Manager:${manager.name} Oracle running at ${this.server.hostname}:${this.server.port}`)
+      if (rep.repo.get_id() === repo.get_id()) return rep.repo;
+    }
+  };
 
-    if (!this.server_match(this.server, manager.server)){
-      let response = await this.fetch({
-        method: 'sync',
-        arg: {manager_server: manager.server}
-      }, this.server)
+  add_repo = async (repository) => {
+    let { filter, repo } = repository;
 
-      for (let r=0; r< response.repos.length; r++){
-        let repository = response.repos[r]
+    repo = await this.cloth_repo(repo);
+    if (await this.get_repo(repo)) return;
 
-        await this.add_repo(repository)
-      }
-    }
-  }
+    this.repos.push({ filter, repo });
+  };
 
-  sync = async () => {
-    
+  sync = async (mgr) => {
+    this.manager = mgr;
   };
 }
 

package/Objects/Repository.js

@@ -1,26 +1,43 @@
-class Repository{
-  constructor(type){
+class Repository {
+  constructor(type) {
     this.type = type;
   }
 
-  objectify = ()=>{
-    let obj = {}
-    if (this.type === 'fs'){
+  objectify = () => {
+    let obj = { type: this.type };
+    if (this.type === "fs") {
       obj.name = this.name;
-      obj.remote = this.remote
-      obj.__dirname = this.__dirname
-    }else if (this.type === 'github'){
-      obj.key = this.auth_token
-      obj.username = this.owner
+      obj.remote = this.remote;
+      obj.__dirname = this.__dirname;
+      obj._id = `${this.__dirname}/${this.name}`;
+    } else if (this.type === "github") {
+      obj.key = this.auth_token;
+      obj.username = this.owner;
       obj.repo = this.repo;
+      obj._id = `${this.owner}/${this.repo}`;
     }
 
-    return obj
-  }
+    return obj;
+  };
 
-  match = async()=>{
-    return false
-  }
+  get_id = () => {
+    if (this._id) return this._id;
+
+    switch (this.type) {
+      case "fs":
+        this._id = `${this.__dirname}/${this.name}`;
+        break;
+      case "github":
+        this._id = `${this.owner}/${this.repo}`;
+        break;
+    }
+
+    return this._id;
+  };
+
+  match = async () => {
+    return false;
+  };
 }
 
-export default Repository;
+export default Repository;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.2.19",
+  "version": "1.2.21",
   "description": "A distributed computing environment",
   "main": "Index.js",
   "scripts": {
@@ -28,12 +28,9 @@
   "type": "module",
   "homepage": "https://github.com/immanuel-savvy/GodProtocol#readme",
   "dependencies": {
-    "@octokit/rest": "^21.0.2",
     "crypto": "^1.0.1",
-    "elliptic": "^6.6.0",
     "fs": "^0.0.1-security",
     "generalised-datastore": "latest",
-    "js-base64": "^3.7.7",
     "aircode4": "latest"
   },
   "devDependencies": {