Merge branch 'develop'

Author: RalphHogenbirk

keymaps/pycom-sync.json

@@ -1,6 +1,8 @@
 {
   "atom-workspace": {
-    "ctrl-alt-s": "pymakr:sync",
+    "ctrl-alt-up": "pymakr:upload",
+    "ctrl-alt-u": "pymakr:upload",
+    "ctrl-alt-down": "pymakr:upload",
     "ctrl-alt-t": "pymakr:toggleREPL",
     "ctrl-alt-c": "pymakr:connect",
     "ctrl-alt-d": "pymakr:disconnect",

lib/board/project-status.js

@@ -0,0 +1,174 @@
+'use babel';
+var fs = require('fs');
+var crypto = require('crypto');
+import Logger from '../helpers/logger.js'
+import ShellWorkers from './shell-workers.js'
+import ApiWrapper from '../main/api-wrapper.js';
+import Utils from '../helpers/utils.js';
+var binascii = require('binascii');
+var utf8 = require('utf8');
+
+var EventEmitter = require('events');
+const ee = new EventEmitter();
+
+export default class ProjectStatus {
+
+  constructor(shell,settings,local_folder){
+    this.shell = shell
+    this.logger = new Logger('ProjectStatus')
+    this.utils = new Utils(settings)
+    this.local_folder = local_folder
+    this.settings = settings
+    this.allowed_file_types = this.settings.get_allowed_file_types()
+    this.content = []
+    this.board_file_hashes = {}
+    this.local_file_hashes = this.__get_local_files_hashed()
+    this.changed = false
+  }
+
+  read(cb){
+    var _this = this
+    this.shell.readFile('project.pymakr',function(err,content_buffs,content_str){
+      if(err){
+        cb(err)
+        return
+      }
+
+      var json_content = []
+      if(content_str != ""){
+        try{
+          json_content = JSON.parse(content_str)
+          err = false
+        } catch(e){
+          _this.logger.error(e)
+          err = true
+        }
+      }
+      _this.content = json_content
+      _this.__process_file()
+      cb(err,json_content)
+    })
+  }
+
+  write_all(cb){
+    this.board_file_hashes = this.local_file_hashes
+    this.write(cb)
+  }
+
+  write(cb){
+    if(this.changed){
+      this.logger.info('Writing project status file to board')
+      var board_hash_array = Object.values(this.board_file_hashes)
+      var project_file_content = new Buffer(JSON.stringify(board_hash_array))
+      this.shell.writeFile('project.pymakr',project_file_content,cb,10) // last param prevents any retries
+    }else{
+      this.logger.info('No changes to file, not writing')
+      cb()
+    }
+  }
+
+  update(name){
+    this.changed = true
+    if(!this.local_file_hashes[name]){
+      delete this.board_file_hashes[name]
+    }else{
+      this.board_file_hashes[name] = this.local_file_hashes[name]
+    }
+  }
+
+  remove(filename){
+    delete this.board_file_hashes[name]
+  }
+
+  __process_file(){
+    for(var i=0;i<this.content.length;i++){
+      var h = this.content[i]
+      this.board_file_hashes[h[0]] = h
+    }
+  }
+
+  __get_local_files(dir){
+    return fs.readdirSync(dir)
+  }
+
+  __get_local_files_hashed(files,path){
+    if(!files){
+      files = this.__get_local_files(this.local_folder)
+    }
+    if(!path){
+      path = ""
+    }
+    var file_hashes = {}
+
+    files = this.utils.ignore_filter(files)
+
+    for(var i=0;i<files.length;i++){
+      var filename = path + files[i]
+      if(filename.length > 0 && filename.substring(0,1) != "."){
+        var file_path = this.local_folder + filename
+        var stats = fs.lstatSync(file_path)
+        if(stats.isDirectory()){
+          var files_from_folder = this.__get_local_files(file_path)
+          if(files_from_folder.length > 0){
+            var hash = crypto.createHash('sha256').update(filename).digest('hex')
+            file_hashes[filename] = [filename,"d",hash]
+            var hashes_in_folder = this.__get_local_files_hashed(files_from_folder,filename+"/")
+            file_hashes = Object.assign(file_hashes,hashes_in_folder)
+          }
+        }else{
+          this.total_file_size += stats.size
+          this.total_number_of_files += 1
+          var contents = fs.readFileSync(file_path)
+          var hash = crypto.createHash('sha256').update(contents).digest('hex')
+          file_hashes[filename] = [filename,"f",hash]
+        }
+      }
+    }
+    return file_hashes
+  }
+
+  get_changes(){
+    var changed_files = []
+    var changed_folders = []
+    var deletes = []
+    var board_hashes = Object.assign({}, this.board_file_hashes)
+    var local_hashes = Object.assign({}, this.local_file_hashes)
+
+    // all local files
+    for(var name in local_hashes){
+      var local_hash = this.local_file_hashes[name]
+      var board_hash = board_hashes[name]
+
+      if(board_hash){
+        // check if hash is the same
+        if (local_hash[2] != board_hash[2]){
+
+          if(local_hash[1] == "f"){
+            changed_files.push(local_hash)
+          }else{
+            changed_folders.push(local_hash)
+          }
+        }
+        delete board_hashes[name]
+
+      }else{
+        if(local_hash[1] == "f"){
+          changed_files.push(local_hash)
+        }else{
+          changed_folders.push(local_hash)
+        }
+      }
+    }
+    for(var name in board_hashes){
+      if(board_hashes[name][1] == 'f'){
+        deletes.unshift(board_hashes[name])
+      }else{
+        deletes.push(board_hashes[name])
+      }
+
+    }
+    return {'delete': deletes, 'files': changed_files,'folders': changed_folders}
+  }
+
+
+}

lib/board/pyboard.js

@@ -46,19 +46,26 @@ export default class Pyboard {
     this.logger = new Logger('Pyboard')
     this.config = Config.constants()
     this.refreshConfig()
+    this.address = null
   }
 
   refreshConfig(){
     this.settings.refresh()
     this.params = {
-      host: this.settings.address,
       port: 23,
       username: this.settings.username,
       password:this.settings.password,
       enpassword:"",
       timeout: this.settings.timeout,
       ctrl_c_on_connect: this.settings.ctrl_c_on_connect
     }
+    if(!this.settings.auto_connect){
+      this.address = this.settings.address
+    }
+  }
+
+  setAddress(address){
+    this.address = address
   }
 
   getCallbacks(){
@@ -152,12 +159,13 @@ export default class Pyboard {
     this.send(CTRL_D,cb,5000)
   }
 
-  safe_boot(cb){
+  safe_boot(cb,timeout){
     var _this = this
     this.logger.info("Safe boot")
     this.send_wait_for(CTRL_F,'Type "help()" for more information.\r\n>>>',function(err){
+      this.logger.info("Safe boot done...")
       cb(err)
-    },4000)
+    },timeout)
 
   }
 
@@ -167,10 +175,11 @@ export default class Pyboard {
     },5000)
   }
 
-  stop_running_programs_double(cb){
+  stop_running_programs_double(cb,timeout){
+
     this.send_wait_for(CTRL_C+CTRL_C,">>>",function(err){
       if(cb) cb(err)
-    },5000)
+    },timeout)
   }
 
 
@@ -214,23 +223,24 @@ export default class Pyboard {
     this.connect(cb,onerror,ontimeout,onmessage,true)
   }
 
-  connect(callback,onerror,ontimeout,onmessage,raw){
+  connect(address,callback,onerror,ontimeout,onmessage,raw){
     this.connecting = true
     this.onconnect = callback
     this.onmessage = onmessage
     this.ontimeout = ontimeout
     this.onerror = onerror
+    this.address = address
     this.stopWaitingForSilent()
     this.refreshConfig()
     var _this = this
-    Pyserial.isSerialPort(this.params.host,function(res){
+    Pyserial.isSerialPort(this.address,function(res){
       _this.isSerial = res
       if(res){
-        _this.connection = new Pyserial(_this.params)
+        _this.connection = new Pyserial(_this.address,_this.params)
       }else if (raw){
-        _this.connection = new Pysocket(_this.params)
+        _this.connection = new Pysocket(_this.address,_this.params)
       }else{
-        _this.connection = new Pytelnet(_this.params)
+        _this.connection = new Pytelnet(_this.address,_this.params)
       }
       _this.type = _this.connection.type
 
@@ -475,15 +485,17 @@ export default class Pyboard {
 
 
     var _this = this
+    clearTimeout(this.waiting_for_timer)
     if(timeout){
       this.waiting_for_timer = setTimeout(function(){
         if (_this.waiting_for_cb) {
-          _this.waiting_for_cb(new Error("timeout"),_this.receive_buffer)
+          var tmp_cb = _this.waiting_for_cb
           _this.waiting_for_cb = null
           _this.wait_for_block = false
           _this.waiting_for = null
           _this.receive_buffer = ""
           _this.receive_buffer_raw = Buffer(0)
+          tmp_cb(new Error("timeout"),_this.receive_buffer)
         }
       },timeout)
     }
@@ -492,7 +504,7 @@ export default class Pyboard {
   follow(cb){
     var _this = this
     var data_err,data = ""
-    this.logger.verbose("Following up...")  
+    this.logger.verbose("Following up...")
     cb(null,"")
   }
 
@@ -501,7 +513,7 @@ export default class Pyboard {
   }
 
   exec_raw_no_reset(code,cb){
-    this.logger.info("Executing code:" +code)
+    this.logger.verbose("Executing code:" +code)
     var data = new Buffer(code,"binary")
     this.send_raw(data,function(err){
       if(cb){
@@ -521,8 +533,8 @@ export default class Pyboard {
   exec_(code,cb){
     var _this = this
     this.exec_raw_no_reset("\r\n"+code,function(){
-        _this.logger.silly("Executed code, now resetting")
-          _this.soft_reset(cb)
+      _this.logger.silly("Executed code, now resetting")
+      _this.soft_reset(cb)
     })
   }
 

lib/board/shell-workers.js

@@ -18,23 +18,32 @@ export default class ShellWorkers {
     this.logger = new Logger('ShellWorkers')
   }
 
-  write_file(content,callback){
+  write_file(value,callback){
     var _this = this
     var blocksize = _this.BIN_CHUNK_SIZE
-    var chunk = content.slice(0,blocksize)
-    content = content.slice(blocksize,content.length)
-    if(chunk.length == 0){
+    var content = value[0]
+    var counter = value[1]
+
+    if(counter*blocksize >= content.length){
       callback(null,content,true)
     }else{
-      c = binascii.hexlify(chunk)
-      _this.pyboard.exec_raw("f.write(ubinascii.unhexlify('"+c+"'))\r\n",function(err,data){
+      var start = counter*blocksize
+      var end = Math.min((counter+1)*blocksize,content.length)
+      var chunk = content.base64Slice(start,end)
+      // c = binascii.b2a_base64(chunk)
+
+      _this.pyboard.exec_raw("f.write(ubinascii.a2b_base64('"+chunk+"'))\r\n",function(err,data){
+        if(data.indexOf("Traceback: ") > -1 || data.indexOf("Error: ") > -1){
+          err_mssg = data.slice(data.indexOf("Error: ")+7,-3)
+          err = new Error("Failed to write file: "+err_mssg)
+        }
         if(err){
           _this.logger.error("Failed to write chunk:")
           _this.logger.error(err)
-          callback(err)
+          callback(err,null)
           return
         }
-        callback(null,content)
+        callback(null,[content,counter+1])
       })
     }
   }