godprotocol 1.1.32 → 1.2.0

package/Objects/Oracle.js

@@ -1,268 +1,341 @@
-import fs from "fs";
-import { hash } from "../utils/hash";
-
+import Fs from "godprotocol/repos/fs.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();
+
+    this.server = server
+    this.mirror = mirror;
+    this.repos = new Array()
+    this.remotes = new Array()
+  }
 
-class Fs {
-  constructor(oracle) {
-    this.oracle = oracle;
+  add_repo = async (repository)=>{
+    let {filter, repo} = repository
+    if (await this.get_repo(repo.type, repo.options.name))
+      return;
 
-    this.fs = fs;
-    this.base = __dirname;
-  }
+    switch(repo.type){
+      case 'fs':
+        repo = new Fs(repo.options)
+        break
+    }
+    this.repos.push({filter, repo})
 
-  is_directory=async path=>{
-    if(!await this.exists(path, {pure:true}))return false;
+    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]
 
-    try {
-      const stats = this.fs.statSync(`${this.base}/${path}`);
-      return stats.isDirectory();
-    } catch (err) {
-      // console.error(`Error checking path: ${err.message}`);
-      return false; // Handle error, e.g., path doesn't exist
+        await this.fetch({
+          method: 'add_repo',
+          arg: {...repo}
+        }, remote)
+      }
+    } else {
+      await this.fetch({
+        method: 'add_repo',
+        arg: {...repo}
+      }, this.server)
     }
   }
 
-  exists = async (path, options={}) => { 
-    return this.fs.existsSync(`${this.base}/${path}`);
-  };
-
-  mkdir = async (path) => {
-    path = `${this.base}/${path}`;
+  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}
+        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
+    }
 
-    !(await this.exists(path, {pure:true})) && this.fs.mkdirSync(path, { recursive: true });
-  };
+    return result
+  }
 
-  read = async(path)=>{
-    let content;
-    try{
-      content = this.fs.readFileSync(`${this.base}/${path}`, {encoding:'utf-8'})
-      content = JSON.parse(content)
-    }catch(e){}
+  push_remote = async(remote)=>{
+    if (this.remotes.find(rem=>this.server_match(rem, remote))) return;
 
-    return content;
+    this.remotes.push(remote)
   }
 
-  retrieve = async(path, options)=>{
-    let config, result;
-    if (options.current){
-      config = {current: path}
-    }else{
-      config = await this.read(`${path}/.config`) || {};
-
-      if (!config.current) {
-        if (options.config){
-          return
-        }
-      }
-    }
-  
-    if (options.sibling){
-      if (config.sibling){
-        let res = await this.read(`${config.sibling}`)
-        result = res.content
-      }
-    }else{
-      if (config.current){
-        let res = await this.read(`${config.current}/.config`)
-
-        let value = await this.read(`${config.current}/${res.index-1}`)
-        if(!value && res.current && !res.current.includes('/')){
-          value = await this.read(`${config.current}/${res.current}`)
-        }
-        if(options.config){
-          result = typeof value.content === 'string'? JSON.parse(value.content): value.content;
-        }
-      }
+  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()}})
     }
+    return repos;
+  }
 
-    return result
+  get_repo = async(type, name) => {
+    for (let r=0; r< this.repos.length; r++){
+      let {repo} = this.repos[r]
+
+      if (repo.type === type && repo.name === name)
+        return repo
+    }
   }
 
-  write = async(path, content, options={})=>{
-    let addr;
-    if (options.config){
-      await this.mkdir(path);
-
-      let conf_path = `${path}/.config`
-      let hash = await this.oracle.hash(content)
-      let conf = await this.read(conf_path) || {index: 0}
-      let obj = {content, sibling: conf.current}
-      let current = `${path}/${hash}`
-      conf.current = current;
-      await this.write(conf_path, JSON.stringify(conf))
-
-      await this.mkdir(current)
-      let current_conff = `${current}/.config`
-      let conff = await this.read(current_conff) || {index: 0}
-      await this.write(`${current}/${conff.index}`, JSON.stringify(obj))
-      conff.index++
-
-      await this.write(current_conff, JSON.stringify(conff))
-      addr = current
-    }else {
-      this.fs.writeFileSync(`${this.base}/${path}`, content)
-      addr = path;
+  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 addr;
+    return res;
   }
 
-  store = async(content, {path, type, hash: hash_, is_instance})=>{
-    if (!type) type = this.oracle.get_type(content)
+  set_to_repos = async(address, content)=>{
+    for (let r=0; r< this.repos.length; r++){
+      let repo = this.repos[r]
 
-    let result, hash = hash_;
-    switch(type){
-      case 'array':
-        hash = hash || await this.oracle.hash(content)
-        let arr_path = `${path}/${hash}`
-        await this.mkdir(arr_path)
+      if (!repo.filter || address.match(repo.filter)){
+        await repo.repo.write_file(address, content)
+      }
+    }
+  }
 
-        let arr = []
-        for (let i=0; i< content.length; i++){
-          let item = content[i]
+  get_from_repos = async(address)=>{
+    for (let r=0; r< this.repos.length; r++){
+      let repo = this.repos[r]
+      
+      if (!repo.filter || address.match(repo.filter)){
+        let content = await repo.repo.read_file(address)
+        if (content) return content;
+      }
+    }
+  }
 
-          let item_path = `${arr_path}/${i}`
-          await this.mkdir(item_path)
-          item = await this.store(item, {path: item_path})
+  read = async(path, options={})=>{
+    let {address, account, prefix} = options;
+    prefix = prefix || '.storage'
 
-          let conf = await this.read(`${item_path}/.config`) 
-          if(!conf) conf = {index:0}
-          else conf.index++
+    let has = (await this.get_accounts(address)).includes(account)
 
-          await this.write(`${item_path}/${conf.index}`, item)
-          await this.write(`${item_path}/.config`, JSON.stringify(conf));
+    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
+      }
 
-          arr.push(conf.index)
-        }
-        let aconf = await this.read(`${path}/.config`) || {}
-        let arr_hash = await this.oracle.hash(arr)
-        let arr_conf = await this.read(`${arr_path}/.config`) || {index: 0}
-        await this.write(`${arr_path}/${arr_hash}`, JSON.stringify({content:arr, type: is_instance? 'instance': type, previous: arr_conf.current, indice: aconf.indice}))
-        arr_conf.current = arr_hash
-        arr_conf.sibling = aconf.current;
+      let res = await this.fetch({
+        method: 'read',
+        arg: {path, prefix}
+      }, server)
+      if(res && res.content){
+        return res.content
+      }
+    }
+  }
 
-        await this.write(`${arr_path}/.config`, JSON.stringify(arr_conf));
+  write = async(path, content, options={})=>{
+    let {account, address, prefix} = options
+    prefix = prefix || '.storage'
 
-        aconf.current = arr_path;
-        await this.write(`${path}/.config`, JSON.stringify(aconf))
-        
-        result = arr_path
+    await this.update_accounts(address, account)
+    let servers = await this.get_servers(account)
 
-        break;
-      case 'twain':
-        hash = hash || await this.oracle.hash(content)
-        let twa_path = `${path}/${hash}`
-        await this.mkdir(twa_path)
-
-        let twa = {}
-        for (let prop in content){
-          let value = content[prop];
-          let p_hash = await this.oracle.hash(prop)
-          let pair_path = `${twa_path}/${p_hash}`
-          await this.mkdir(pair_path)
-          let p_addr = await this.store(prop, {path: pair_path})
-          let val_addr = await this.store(value, {path: pair_path})
-
-          let pair = [p_addr, val_addr]
-
-          let conf = await this.read(`${pair_path}/.config`) 
-          if (!conf){
-            conf = {index: 0}
-          }else if (!Object.keys(conf).includes('index'))conf.index = 0
-          else {
-            conf.index++
-          }
-          
-          await this.write(`${pair_path}/${conf.index}`, JSON.stringify(pair))
+    for (let s=0; s< servers.length; s++){
+      let server = servers[s]
 
-          twa[p_hash] = conf.index;
-          await this.write(`${pair_path}/.config`, JSON.stringify(conf));
-        }
-        
-        let pconf = await this.read(`${path}/.config`) || {}
+      await this.fetch({
+        method: 'write',
+        arg: {path, content, prefix}
+      }, server)
+    }
+  }
 
-        let twa_hash = await this.oracle.hash(twa)
-        let twa_conf = await this.read(`${twa_path}/.config`) || {index: 0}
-        await this.write(`${twa_path}/${twa_hash}`, JSON.stringify({content:twa, type: is_instance? 'instance': type, previous: twa_conf.current, indice: pconf.indice}))
-        twa_conf.current = twa_hash
-        twa_conf.sibling = pconf.current;
+  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])
+      }
+    }
+    return servers
+  }
 
-        await this.write(`${twa_path}/.config`, JSON.stringify(twa_conf));
+  update_servers = async(account, servers)=>{
+    servers = servers || await this.get_servers(account)
+    
+    if (servers.find(s=>this.server_match(s, this.server))){
+      return
+    }
 
-        pconf.current = twa_path;
-        await this.write(`${path}/.config`, JSON.stringify(pconf))
-        
-        result = twa_path
-        break;
-      case 'string':
-        hash = await this.oracle.hash(content)
-        result = await this.write(`${path}/${hash}`, content)
-        break
-      case 'number':
-        hash = await this.oracle.hash(`0${content}`)
-        result = await this.write(`${path}/${hash}`, JSON.stringify(content))
-        break
-      case 'boolean':
-        hash = await this.oracle.hash(`0${content}`)
-        result = await this.write(`${path}/${hash}`, JSON.stringify(content))
-        break
+    servers.push(this.server)
+    for (let s=0; s< servers.length; s++){
+      let server = servers[s]
+
+      await this.fetch({
+        method: 'update_servers',
+        arg: {account, server: this.server},
+      }, server)
     }
 
-    return result;
+    return servers
   }
-}
 
-class Oracle {
-  constructor(manager) {
+  get_accounts = async(address, mirroring)=>{
+    let addr = `.oracle/${address}/.configs`
+    let accounts = await this.get_from_repos(addr)
+    
+    accounts = accounts ? JSON.parse(accounts) : []
 
-    this.manager = manager;
+    if (!mirroring && !accounts.length && this.mirror){
+      accounts = await this.fetch({
+        method: 'get_accounts',
+        arg: {address}
+      }, this.mirror)
+    }
 
-    this.fs = new Fs(this);
+    return accounts 
   }
 
-  read = async(path, options)=>{
-    let result = await this.fs.retrieve(path, options)
+  update_accounts = async(address, account)=>{
+    let accounts = await this.get_accounts(address)
+    
+    if (accounts.includes(account)){
+      return
+    }
 
-    return result;
-  }
+    accounts.push(account)
 
-  write = async(path, content, options={})=>{
-    let type = this.get_type(content), addr;
+    let servers = await this.get_servers_from_address(address, accounts)
+
+    for (let s=0; s< servers.length; s++){
+      let server = servers[s]
 
-    if(options.config){
-      return await this.fs.write(path, JSON.stringify(content), {config: true})
+      await this.fetch({
+        method: 'update_accounts',
+        arg: {address, account},
+      }, server)
     }
 
-    if (options.hash) path = `${path}/${options.hash}`
+    return accounts
+  }
 
-    addr = await this.fs.store(content, {path, type, has_hash: options.hash, is_instance: options.is_instance})
+  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)
+      })
+    }
 
-    return addr;
+    return servers
   }
 
-  hash = async(value, alg)=>{
-    if (typeof value !== 'string')value = JSON.stringify(value)
-    
-    return hash(value, alg)
+  server_match = (s1, s2)=>{
+    return s1.hostname === s2.hostname && s1.port === s2.port
   }
 
-  sync = async () => {
-    this.manager.path = `${this.manager.trinity.game}/${this.manager.name}`;
-    await this.fs.mkdir(this.manager.path)
-  };
-  
-  get_type = (content)=>{
-    let type = typeof content;
+  set_manager = async(manager)=>{
+    console.log(`Manager:${manager.name} Oracle running at ${this.server.hostname}:${this.server.port}`)
 
-    if (content == null) return 'void'
-    
-    if (type === 'object'){
-      if (Array.isArray(content)) type = 'array'
-      else if (!content) type = 'void'
-      else type = 'twain'
+    if (!this.server_match(this.server, manager.server)){
+      let response = await this.fetch({
+        method: 'sync',
+        arg: {manager_server: manager.server}
+      }, this.server)
+
+      for (let r=0; r< response.repos.length; r++){
+        let repository = response.repos[r]
+
+        await this.add_repo(repository)
+      }
     }
-    return type;
   }
+
+  sync = async () => {
+    
+  };
 }
 
 export default Oracle;

package/Objects/Repository.js

@@ -1,38 +1,17 @@
-import { get_request, post_request } from "../utils/services";
-
-class Repository {
-  constructor(manager) {
-    this.manager = manager;
-
-    this.gds = this.manager.oracle.gds;
+class Repository{
+  constructor(){
   }
 
-  read_address = async (address) => {
-    let content = await this.manager.oracle.fs.read_file(`${address}`);
-
-    try {
-      content = JSON.parse(content);
-    } catch (err) {}
-
-    return content;
-  };
+  objectify = ()=>{
+    let obj = {}
+    if (this.type === 'fs'){
+      obj.name = this.name;
+      obj.remote = this.remote
+      obj.__dirname = this.__dirname
+    }
 
-  sync = async () => {
-  };
-
-  create_or_update_file = async (path, content, message, sha) => {
-    
-  };
-
-  get_file_sha = async (path) => {
-    
-  };
-
-  write_file = async (path, content, message = "") => {
-    await this.manager.oracle.fs.write_file(path, content)
-    
-    return path
-  };
+    return obj
+  }
 }
 
-export default Repository;
+export default Repository;

package/Objects/Trinity.js

@@ -1,4 +1,4 @@
-import Manager from "./Manager";
+import Manager from "./Manager.js";
 
 class Trinity {
   constructor(game) {
@@ -7,18 +7,20 @@ class Trinity {
   }
 
   add_manager = async (name, options) => {
+    let mgr = this.managers[name];
+    if(mgr) return manager
+
     let manager = new Manager(name, {...options, trinity: this});
-    let mgrs = this.managers[name];
-    if (!mgrs) {
-      mgrs = new Array();
-      this.managers[name] = mgrs;
-    }
     await manager.sync();
 
-    mgrs.push(manager);
+    this.managers[name] = manager;
 
     return manager;
   };
+
+  get_manager = (name)=>{
+    return this.managers[name]
+  }
 }
 
 export default Trinity;

package/Objects/Utils.js

@@ -1,14 +1,14 @@
 class Utils{
-  constructor(){}
-
-  resolve_addr = (addr)=>{
-    if (!addr)return addr;
+  on = async(event_name, filter, handler) => {
+    
+  }
 
-    if (!addr.startsWith(this.physical_address)){
-      addr = `${this.physical_address}/${addr}`
-    }
+  reload = async(payload)=>{
+    let {address} = payload;
 
-    return addr;
+    let res = await this.manager.oracle.read(`${address}/air`, {address, prefix: '.codes', account: this.physical_address})
+    
+    await this.load({address: address.slice(this.physical_address.length+1), sequence: res, compiler: true, from_reload: true})
   }
 }