lego_ev3 0.9.0 → 0.9.1

data/lib/connection/local.rb

@@ -1,14 +1,59 @@
 module LegoEv3
   class LocalConnection < BaseConnection
+    def initialize
+      super()
+      @file_handles = {}
+    end
 
-    def close; end
+    def close
+      @file_handles.values.each do |handle|
+        handle.close
+      end
+    end
 
     protected
 
     def create_connection; end
 
-    def call_connection(command)
-      `command`
+    def call_connection(commands)
+      commands.map do |(verb, path, value, handle)|
+        if verb == :list then list(path)
+        elsif verb == :read then read(path, handle)
+        elsif verb == :write then write(path, value, handle)
+        else raise LegoEv3::InvalidCommandException.new(verb)
+        end
+      end
+    end
+
+    private
+
+    def list(path)
+      f = get_folder_handler(path)
+      f.map{ |f| f } - ['.', '..']
+    rescue
+      [] # TODO: Bug? The folder is not created if no sensor plugged in once.
+    end
+
+    def read(path, handle)
+      f = get_file_handler(path, handle)
+      f.rewind
+      f.read
+    end
+
+    def write(path, value, handle)
+      f = get_file_handler(path, handle)
+      f.rewind
+      f.write(value)
+      f.flush
+      nil
+    end
+
+    def get_file_handler(path, handle)
+      @file_handles[path] ||= File.open(path, handle)
+    end
+
+    def get_folder_handler(path)
+      @file_handles[path] ||= Dir.open(path)
     end
   end
 end

data/lib/connection/ssh.rb

@@ -0,0 +1,84 @@
+require 'net/ssh/simple'
+
+module LegoEv3
+  class SSHConnection < BaseConnection
+    attr_accessor :timeout
+
+    def initialize(host, port, user, password)
+      super()
+
+      @host = host
+      @port = port
+      @user = user
+      @password = password
+      @timeout = 10
+    end
+
+    def close
+      @connection.close if @connection
+      @connection = nil
+    end
+
+    protected
+
+    def create_connection
+      Net::SSH::Simple.new(host_name: @host, port: @port, user: @user, password: @password, timeout: @timeout)
+    end
+
+    def call_connection(commands)
+      begin
+        joined_command = join_commands(commands)
+
+        puts "Sending: #{joined_command}"
+
+        responses = @connection
+          .ssh(@host, joined_command)
+          .stdout
+          .split("\n")
+
+        commands.map do |(verb, _, _, _)|
+          if verb == :list
+            # TODO: Bug? The folder is not created if no sensor plugged in once.
+            r = responses.shift || ''
+            r.include?('No such file or directory') ? [] : r.split(' ').map(&:strip)
+          elsif verb == :read
+            responses.shift
+          elsif verb == :write
+            nil
+          else raise new LegoEv3::InvalidCommandException(verb)
+          end
+        end
+      rescue => e
+        if e.wrapped.kind_of?(Timeout::Error)
+          raise SSHConnectionException.new(@host, @user, @password)
+        else
+          raise e
+        end
+      end
+    end
+
+    private
+
+    def join_commands(commands)
+      commands.map do |(verb, path, value, _)|
+        if verb == :list then list(path)
+        elsif verb == :read then read(path)
+        elsif verb == :write then write(path, value)
+        else raise new LegoEv3::InvalidCommandException(verb)
+        end
+      end.join(';')
+    end
+
+    def list(path)
+      "ls -C #{path}"
+    end
+
+    def read(path)
+      "cat #{path}"
+    end
+
+    def write(path, value = nil)
+      "echo #{value} > #{path}"
+    end
+  end
+end

data/lib/connection/ssh_command.rb

@@ -0,0 +1,44 @@
+require 'net/ssh/simple'
+
+module LegoEv3
+  class SSHScript
+    def initialize(ssh_config, command)
+      @ssh_config = ssh_config
+      @command = command
+    end
+
+    def run
+      puts "Connecting to brick..."
+
+      Net::SSH::Simple.sync(@ssh_config) do
+        buffer = ''
+
+        puts "Opening Bash session..."
+
+        ssh('ev3', '/bin/sh') do |event, console, d|
+          case event
+            when :start
+              puts "Executing #{@command} locally..."
+
+              console.send_data(@command)
+              console.eof!
+            when :stdout
+              buffer << d
+              while line = buffer.slice!(/(.*)\r?\n/) do puts line end
+              :no_append
+            when :stderr
+              while line = buffer.slice!(/(.*)\r?\n/) do puts line end
+              :no_append
+            when :exit_code
+              puts d
+            when :exit_signal
+              puts d
+              :no_raise
+            when :finish
+              puts "Done."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/connection/tcp_client.rb

@@ -0,0 +1,64 @@
+require 'socket'
+require 'base64'
+
+module LegoEv3
+  class TCPConnection < BaseConnection
+    def initialize(host)
+      super()
+
+      @host = host
+    end
+
+    def close
+      @connection.close if @connection
+      @connection = nil
+    end
+
+    protected
+
+    def create_connection
+      socket = TCPSocket.new(@host.split(':').first, @host.split(':').last)
+      socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      socket
+    end
+
+    def call_connection(commands)
+      joined_command = join_commands(commands)
+
+      puts "Sending: #{joined_command}"
+
+      @connection.puts(Base64.strict_encode64(Marshal.dump(joined_command)))
+
+      responses = []
+
+      while responses.count < commands.count
+        raw = @connection.gets
+        response = Marshal.load(Base64.strict_decode64(raw.rstrip))
+        puts "Received: #{response}"
+        responses << response
+      end
+
+      responses
+    end
+
+    private
+
+    def join_commands(commands)
+      commands
+        .map { |command| command.join(';') }
+        .join("\n")
+    end
+
+    def list(path)
+      "ls -C #{path}"
+    end
+
+    def read(path)
+      "cat #{path}"
+    end
+
+    def write(path, value = nil)
+      "echo #{value} > #{path}"
+    end
+  end
+end

data/lib/connection/tcp_server.rb

@@ -0,0 +1,63 @@
+require 'socket'
+require 'base64'
+
+module LegoEv3
+  class TCPServer
+    def initialize(port)
+      @port = port
+      @local_connection = LegoEv3::LocalConnection.new
+    end
+
+    def open
+      @server = ::TCPServer.new(@port)
+
+      hostname = `hostname`.strip
+
+      puts "Started TCP server on #{hostname}:#{@port}."
+      puts "Waiting for clients..."
+      puts "Press CTRL+C to interrupt at any time."
+
+      loop do
+        client = @server.accept
+        client.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        puts "Client connected."
+
+        while raw_request = client.gets
+          request = Marshal.load(Base64.strict_decode64(raw_request.rstrip))
+          puts "Received: #{request}"
+
+          receive_commands(request).each do |(verb, path, value, handle)|
+            @local_connection.send(verb.to_sym, path, value, handle) do |response|
+              puts "Sending: #{response}"
+              client.puts(Base64.strict_encode64(Marshal.dump(response)))
+            end
+          end
+
+          @local_connection.flush
+        end
+
+        client.close
+        puts "Client closed."
+      end
+    rescue SystemExit, Interrupt
+      close
+    end
+
+    def close
+      @server.close if @server
+      @server = nil
+
+      @local_connection.close if @local_connection
+      @local_connection = nil
+    end
+
+    private
+
+    def receive_commands(raw)
+      raw
+        .strip
+        .split("\n")
+        .map{ |c| c.split(';') }
+    end
+  end
+end

data/lib/connection/upload.rb

@@ -2,51 +2,61 @@ require 'net/ssh/simple'
 
 module LegoEv3
   class Uploader
-    def initialize(host, user, password, project)
-      @host = host
-      @user = user
-      @password = password
-      @project = project
+    def initialize(ssh_config, project)
+      @ssh_config = ssh_config
+      @local_project_path = Pathname.new(project).realpath.to_s
     end
 
     def upload
-      Net::SSH::Simple.sync({ host_name: @host, user: @user, password: @password, timeout: 600 }) do
-        puts "Creating folder #{project_folder}..."
-        ssh('ev3', "rm -rf #{project_folder}")
+      Net::SSH::Simple.sync(@ssh_config) do
+        puts "Removing previous folder #{remote_project_path}..."
+        ssh('ev3', "rm -rf #{remote_project_path}/**/*")
+
+        puts "Creating folder #{remote_project_path}..."
+        ssh('ev3', "mkdir -p #{remote_project_path}")
 
         puts "Upload project..."
-        upload_folder(@project)
+        upload_folder(@local_project_path)
+
+        # Takes too much time, better to do it once on the brick.
+        #puts "Installing lib..."
+        #ssh('ev3', "cd #{remote_project_path} && gem install lego_ev3")
 
-        puts "Downloading dependencies from Gemfile..."
-        ssh('ev3', "cd #{project_folder} && gem install bundler && bundle install")
+        # Takes too much time, better to do it once on the brick.
+        #puts "Downloading dependencies from Gemfile..."
+        #ssh('ev3', "cd #{remote_project_path} && gem install bundler && bundle install")
       end
     end
 
     private
 
-    def upload_file(src_relative, dst_relative)
-      file_remote = "#{project_folder}/#{dst_relative}"
-      puts "Sending #{src_relative} to #{file_remote}..."
-      scp_put('ev3', src_relative, file_remote)
+    def upload_file(src, dst_relative)
+      file_remote = "#{remote_project_path}/#{dst_relative}"
+      puts "Sending #{src} to #{file_remote}..."
+      scp_put('ev3', src, file_remote)
     end
 
-    def upload_folder(src_relative)
-      folders = Dir.glob("#{src_relative}/**/*/")
-      files = Dir.glob("#{src_relative}/**/*").select { |f| File.file?(f) }
+    def upload_folder(src)
+      folders = Dir.glob("#{src}/**/*/")
+      files = Dir.glob("#{src}/**/*").select { |f| File.file?(f) }
 
-      folders.each do |path_relative|
-        folder_remote = "#{project_folder}/#{path_relative}"
+      folders.each do |path|
+        folder_remote = "#{remote_project_path}/#{local_abs_to_rel_path(path)}"
         puts "Creating folder #{folder_remote}..."
         ssh('ev3', "mkdir -p #{folder_remote}")
       end
 
-      files.each do |path_relative|
-        upload_file(path_relative, path_relative)
+      files.each do |path|
+        upload_file(path, local_abs_to_rel_path(path))
       end
     end
 
-    def project_folder
-      "/home/#{@project.split('/').last}"
+    def local_abs_to_rel_path(path)
+      path.gsub(/^#{@local_project_path}\//, '')
+    end
+
+    def remote_project_path
+      "/home/#{@local_project_path.split('/').last}"
     end
   end
 end

data/lib/exceptions.rb

@@ -1,5 +1,5 @@
 module LegoEv3
-  class RemoteConnectionException < Exception
+  class SSHConnectionException < Exception
     def initialize(host, user, password)
       super(
         "Could not connect to the brick. " +
@@ -8,4 +8,38 @@ module LegoEv3
         "[ssh #{user}@#{host} + enter your password]")
     end
   end
+
+  class InvalidCommandException < Exception
+    def initialize(verb)
+      super(
+        "The command with verb #{verb} is not supported." +
+        "You must implement it.")
+    end
+  end
+
+  class InvalidModeException < Exception
+    def initialize(type, sub_type, mode, valid_modes)
+      super(
+        "The mode #{mode} is not valid on the #{type} of type #{sub_type}. " +
+        "Supported modes are: #{valid_modes}")
+    end
+  end
+
+  class InvalidChannelException < Exception
+    def initialize(channel)
+      super(
+        "The channel #{channel} is not supported in the mode :control_alt of " +
+        "the infrared sensor. The only supported channel is 1."
+      )
+    end
+  end
+
+  class InvalidRemoteServiceException < Exception
+    def initialize(service)
+      super(
+        "The 'remote.service' configuration is not valid. " +
+        "Supported services are: 'tcp', 'ssh'."
+      )
+    end
+  end
 end