godprotocol 1.2.13 → 1.2.15

package/Objects/Manager.js

@@ -331,7 +331,7 @@ class Manager {
       else this.options.server_domain = this.options.server.hostname
       let handle = create_server({manager: this, ...this.options.server, app: this.options.app })
 
-      this.handler = (req, res)=>{
+      this.handler = (req, res, cb)=>{
         
         handle(req,res)
 
@@ -339,6 +339,13 @@ class Manager {
           this.served = true
           this.oracle = this.options.oracle;
           this.oracle.set_manager(this)
+            .then(async()=>{
+              if (this.options.init_account){
+                await this.add_account(this.options.init_account.name, {password: this.options.init_account.password, init: true})
+
+                cb && cb()
+              }
+            })
         }
       }
     }

package/Objects/Oracle.js

@@ -147,25 +147,38 @@ class Oracle extends Handlers{
     return res;
   }
 
-  set_to_repos = async(address, content)=>{
+  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]
 
       if (!repo.filter || address.match(repo.filter)){
-        await repo.repo.write_file(address, content)
+        res = await repo.repo.write_file(address, content, args)
+        if (!args.just_exists){
+          res = await repo.repo.objectify()
+        }
+        if (counted && !count) break;
+        count --
       }
     }
+
+    return res;
   }
 
-  get_from_repos = async(address)=>{
+  get_from_repos = async(address, repo_)=>{
+    let content
     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;
+      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
       }
     }
+    return content
   }
 
   read = async(path, options={})=>{

package/Objects/Repository.js

@@ -1,5 +1,6 @@
 class Repository{
-  constructor(){
+  constructor(type){
+    this.type = type;
   }
 
   objectify = ()=>{
@@ -8,10 +9,18 @@ class Repository{
       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.repo = this.repo;
     }
 
     return obj
   }
+
+  match = async()=>{
+    return false
+  }
 }
 
 export default Repository;

package/Objects/Utils.js

@@ -10,6 +10,34 @@ class Utils{
     
     await this.load({address: address.slice(this.physical_address.length+1), sequence: res, compiler: true, from_reload: true})
   }
+
+  get_from_repo = async(address, options) =>{
+    address = `./storage/${this.physical_address}/${address}/__literal__`
+    let content = await this.manager.oracle.get_from_repos(address, {count: 1, args: options})
+
+    return content && JSON.parse(content)
+  }
+
+  set_to_repo =  async(address, content, options) =>{
+    address = `./storage/${this.physical_address}/${address}/__literal__`
+    let response = await this.manager.oracle.set_to_repos(address, JSON.stringify(content), {count: 1, args: options})
+
+    return response
+  }
+
+  read_file = async(address) =>{
+    let content = await this.manager.oracle.read(address, {account: this.physical_address})
+
+    return content;
+  }
+
+  write_file = async(address, content)=>{
+    let res = await this.manager.oracle.write(address, JSON.stringify(content), {account: this.physical_address})
+  }
+
+  read = async(address, query)=>{
+
+  }
 }
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.2.13",
+  "version": "1.2.15",
   "description": "A distributed computing environment",
   "main": "Index.js",
   "scripts": {

package/repos/github.js

@@ -17,45 +17,69 @@ class Github extends Repository{
   });
 
   // Write (create or update) a file
-  write_file = async (file_path, content) => {
+  write_file = async (file_path, content, options={}) => {
     const url = `${this.base_url}/repos/${this.owner}/${this.repo}/contents/${file_path}`;
-    let sha = null;
+    let sha = null, exists;
 
     // Check if file exists, get its SHA
-    const exists = await this.file_exists(file_path);
-    if (exists) {
-      const res = await fetch(url, { headers: this.get_headers() });
-      if (res.ok) {
-        const data = await res.json();
-        sha = data.sha;
+    try{
+      exists = await this.file_exists(file_path);
+      
+      if (exists) {
+        const res = await fetch(url, { headers: this.get_headers() });
+        if (res.ok) {
+          const data = await res.json();
+          sha = data.sha;
+        }
       }
+      if (options.just_exists) return exists
+    }catch(e){
+      console.log(e.message)
+      return 
     }
 
     // Build payload
-    const body = {
+    let body;
+    try{
+      body = {
       message: exists ? 'Update file' : 'Create file',
       content: Buffer.from(content).toString('base64'),
       ...(sha && { sha }),
     };
+    }catch(e){
 
-    const response = await fetch(url, {
-      method: 'PUT',
-      headers: this.get_headers(),
-      body: JSON.stringify(body),
-    });
+    }
+
+    try{
+      const response = await fetch(url, {
+        method: 'PUT',
+        headers: this.get_headers(),
+        body: JSON.stringify(body),
+      });
 
-    return response.json();
+      return response.json();
+    }catch(e){
+      console.log(e.message)
+    }
+    
   };
 
   // Read a file
   read_file = async (file_path) => {
     const url = `${this.base_url}/repos/${this.owner}/${this.repo}/contents/${file_path}`;
 
-    const response = await fetch(url, { headers: this.get_headers() });
-    if (!response.ok) return null;
+    let response;
+    try{
+      response = await fetch(url, { headers: this.get_headers() })
+
+      if (!response.ok) return null;
 
-    const fileData = await response.json();
-    return Buffer.from(fileData.content, 'base64').toString('utf-8');
+      const fileData = await response.json();
+      return Buffer.from(fileData.content, 'base64').toString('utf-8');
+    }catch(e){
+      console.log(e.message)
+      return;
+    }
   };
 
   // Check if file exists

package/utils/create_server.js

@@ -72,17 +72,19 @@ export const handle_routes =  async (req, res, manager, app) => {
         result = await manager.oracle.call(data);
         break;
       default:
-        let accountName = account_uids[data.account];
-        if (!accountName) return res.end(JSON.stringify({ message: `Account ${data.account} not found` }));
-
-        let accountObj = await manager.get_account(accountName);
+        let account_name = account_uids[data.account], account_obj;
+        if (!account_name){
+          if (['load', 'run', 'parse'].includes(req.url.slice(1))){
+            return res.end(JSON.stringify({ message: `Account ${data.account} not found` }));
+          }
+        }else account_obj = await manager.get_account(account_name);
 
         if (req.url === '/load'){
-          result = await accountObj.load(data);
+          result = await account_obj.load(data);
         }else if (req.url === '/run'){
-          result = await accountObj.run(data);
+          result = await account_obj.run(data);
         }else if (req.url === '/parse'){
-          result = await accountObj.parse(data);
+          result = await account_obj.parse(data);
         }else {
           return app? app(req,res): res.writeHead(404).end('Not Found');
         }