thor-ssh 0.2.5 → 0.2.6

data/lib/thor-ssh/actions.rb

@@ -76,11 +76,11 @@ module ThorSsh
     end
     
     # Similar to run, but silent and always executes on the remote server
-    def exec(command, with_codes=false)
-      return destination_server.run(command, with_codes)
+    def exec(command, options={})
+      return destination_server.run(command, options)
     end
     
-    def run(command, with_codes=false, config={})
+    def run(command, options={}, config={})
       return unless behavior == :invoke
 
       destination = relative_to_original_destination_root(destination_root, false)
@@ -95,7 +95,7 @@ module ThorSsh
 
       unless options[:pretend]
         # config[:capture] ? `#{command}` : system("#{command}")
-        return exec(command, with_codes)
+        return exec(command, options)
       end
     end
     

data/lib/thor-ssh/actions/file_manipulation.rb

@@ -27,6 +27,7 @@ class Thor
     
     
     def chmod(path, mode, config={})
+      # TODO: Check the mode first, only run if its changed
       return unless behavior == :invoke
       path = File.expand_path(path, destination_root)
       say_status :chmod, relative_to_original_destination_root(path), config.fetch(:verbose, true)
@@ -34,6 +35,24 @@ class Thor
       destination_files.chmod(mode, path) unless options[:pretend]
     end
     
+    def chown(user, group, files)
+      unless options[:pretend]
+        changed, not_changed = destination_files.chown(user, group, files)
+
+        not_changed.each do |file|
+          say_status :chown, file
+        end
+
+        changed.each do |file|
+          say_status :chown_identical, file, :blue
+        end
+      end
+    end
+
+    def chown_R(user, group, files)
+      destination_files.chown_R(user, group, files) unless options[:pretend]
+    end
+    
     
     def gsub_file(path, flag, *args, &block)
       return unless behavior == :invoke
@@ -56,6 +75,7 @@ class Thor
       say_status :remove, relative_to_original_destination_root(path), config.fetch(:verbose, true)
       destination_files.rm_rf(path) if !options[:pretend] && destination_files.exists?(path)
     end
+    alias :remove_dir :remove_file
     
     
   end

data/lib/thor-ssh/local_server.rb

@@ -8,6 +8,8 @@ module ThorSsh
       @base = base
     end
     
+    # TODO: This should inherit from the same thing as RemoteServer and
+    # it should have the same run but different run_with_codes
     def run_with_codes(command)
       # pid, stdin, stdout, stderr = Open4::popen4(command)
       # ignored, status = Process::waitpid2 pid
@@ -27,8 +29,8 @@ module ThorSsh
       return stdout_data, stderr_data, exit_code, exit_signal
     end
 
-    def run(command, with_codes=false)
-      if with_codes
+    def run(command, options={})
+      if options[:with_codes]
         return run_with_codes(command)
       else
         stdout, stdin, exit_code, exit_signal = run_with_codes(command)

data/lib/thor-ssh/remote_file.rb

@@ -2,7 +2,9 @@ require 'net/ssh'
 require 'net/sftp'
 require 'stringio'
 
-module ThorSsh  
+module ThorSsh
+  class PermissionError < StandardError ; end
+  
   class RemoteFile
     attr_reader :connection
     attr_reader :base
@@ -34,10 +36,19 @@ module ThorSsh
     def run(command)
       return base.exec(command)
     end
+
+    def exec(command, options={})
+      return base.exec(command, options)
+    end
     
     # Creates the directory at the path on the remote server
     def mkdir_p(path)
-      run "mkdir -p \"#{path}\""
+      stdout, stderr, _, _ = exec("mkdir -p #{path.inspect}", :with_codes => true)
+
+      if stderr =~ /Permission denied/
+        base.say_status :permission_error, stderr, :red
+        raise PermissionError, "unable to create directory #{path}"
+      end
     end
     
     # Remote the file/folder on the remote server
@@ -58,9 +69,17 @@ module ThorSsh
       # If we first logged in as the running user
       if base.destination_server.running_as_current_user?
         data = nil
-        connection.sftp.file.open(path, "rb") do |f|
-          data = f.read
+        begin
+          # Attempt to upload to the path
+          data = connection.sftp.upload!(path)
+        rescue Net::SFTP::StatusException => e
+          close_sftp!
+          raise PermissionError, "Unable to download #{path}"
         end
+        
+        # connection.sftp.file.open(path, "rb") do |f|
+        #   data = f.read
+        # end
         close_sftp!
       else
         # We just run this as root, when reading we don't need to go back
@@ -73,8 +92,67 @@ module ThorSsh
     
     # TODO: we should just move this to a more standard thing
     def binwrite(path, data)
+      data = data.gsub(/\n\r/, "\n").gsub(/\r\n/, "\n")
+      
       io = StringIO.new(data)
-      connection.sftp.upload!(io, path)
+      begin
+        # Attempt to upload to the path
+        connection.sftp.upload!(io, path)
+      rescue Net::SFTP::StatusException => e
+        # In the event we don't have permission, upload to 
+        # a temp dir, then copy with sudo
+        close_sftp!
+        
+        temp_dir = nil
+        base.as_user(nil) do
+          current_dir = run("pwd").strip
+          temp_dir = "#{current_dir}/.thorssh"
+          # Make the dir as the default user
+          run("mkdir -p \"#{temp_dir}\"")
+        end
+        
+        temp_file = "#{temp_dir}/#{File.basename(path)}"
+        
+        # io = StringIO.new(data)
+        io = StringIO.new(data)
+        connection.sftp.upload!(io, temp_file)
+        close_sftp!
+
+
+        user = base.run_as_user
+
+        # Move the file as the user
+        base.as_root do
+          folder_path = File.dirname(path)
+          unless base.destination_files.exists?(folder_path)
+            # Create the directory this is supposed to transfer into
+            mkdir_p(folder_path)
+            
+            # And set the correct user/group
+            if user
+              chown(user, user, folder_path)
+            end
+          end
+          
+          # Move the file
+          run("mv #{temp_file.inspect} #{path.inspect}")
+        end
+        
+        unless base.destination_files.exists?(path)
+          # Something went wrong
+          raise PermissionError, "#{path} failed to create/update failed" 
+        end
+        
+        if user
+          # Set the correct user as if this user had uploaded
+          # directly.
+          base.as_root do
+            chown(user, user, path)
+          end
+        end
+
+        return
+      end
       close_sftp!
     end
     
@@ -87,6 +165,30 @@ module ThorSsh
       return run("chmod #{mode} \"#{file_name}\"")
     end
     
+    def chown(user, group, list, options={})
+      changed = []
+      not_changed = []
+      recursive_flag = options[:recursive] ? '-R' : ''
+      [list].flatten.each do |file|
+        _, _, file_user, file_group = exec("ls -lh #{file.inspect}").split(/\n/).reject {|l| l =~ /^total/ }.last.split(/\s/)
+        if user == file_user && group == file_group
+          not_changed << file
+        else
+          changed << file
+          base.as_root do
+            # We can just always run this as root for the user
+            exec("chown #{recursive_flag} #{user}:#{group} #{file.inspect}")
+          end
+        end
+      end
+      
+      return changed, not_changed
+    end
+    
+    def chown_R(user, group, list)
+      return chown(user, group, list, :recursive => true)
+    end
+    
     def inode(file_name)
       return run("ls -i \"#{file_name}\"").strip.split(/ /).first
     end
@@ -95,6 +197,5 @@ module ThorSsh
     def identical?(file1, file2)
       inode(file1) == inode(file2)
     end
-
   end
 end

data/lib/thor-ssh/remote_server.rb

@@ -11,12 +11,15 @@ module ThorSsh
       @connection = connection
     end
     
-    def run_with_codes(command)
+    def run_with_codes(command, options)
       stdout_data = ""
       stderr_data = ""
       exit_code = nil
       exit_signal = nil
       channel = connection.open_channel do |cha|
+        # TODO: Lets do more research on request_pty
+        # It fixes the bug with "stdin: is not a tty"
+        channel.request_pty unless options[:no_pty]
         cha.exec(command) do |ch, success|
           unless success
             abort "FAILED: couldn't execute command (connection.channel.exec)"
@@ -42,37 +45,68 @@ module ThorSsh
           #   channel.close
           # end
         end
-        # channel.wait
         # puts "Done Loop"
         # channel.close
       end
       connection.loop
-
+      
+      # puts "OUTPUT: #{[stdout_data, stderr_data, exit_code, exit_signal].inspect}"
+      
       return stdout_data, stderr_data, exit_code, exit_signal
     end
     
     def running_as_current_user?
-      base.run_as_user && connection.options[:user] != base.run_as_user
+      base.run_as_user && connection.options[:user] == base.run_as_user
     end
 
-    def run(command, with_codes=false)
-      if running_as_current_user?
+    def run(command, options={})
+      options[:with_codes] ||= false
+      options[:log_stderr] = true unless options.has_key?(:log_stderr)
+      # Runs the command with the correct sudo's to get it to the current
+      # user.  You can also do as_user(nil) do ... to get to the login
+      # user.
+      
+      puts command
+      
+      # A few notes on running commands as a different user
+      # 1) we use -i to get it as if you had logged in directly
+      #    as the other user
+      # 2) we use bash -c to run it all in bash so things like rediects
+      #    and multiple commands work
+      if !running_as_current_user? && base.run_as_user != nil
         # We need to change to a different user
         if base.run_as_user == 'root'
          # We need to go up to root
-         command = "sudo #{command}"
+         # TODO: We don't need to run in bash if its not going to pipe
+         command = "sudo -i bash -c #{command.inspect}"
        else
          # We need to go up to root, then down to this user
          # This involves running sudo (to go up to root), then running
          # sudo again as the new user, then running the command
-         command = "sudo sudo -u #{base.run_as_user} #{command}"
+         command = "sudo sudo -u #{base.run_as_user} -i bash -c #{command.inspect}"
         end
       end
-      results = run_with_codes(command)
-      if with_codes
-        return results
+      stdout_data, stderr_data, exit_code, exit_signal = run_with_codes(command, options)
+      
+      # if stderr_data.strip != ''
+      if exit_code != 0
+        base.say "#{exit_code}>> #{command}", :red
+        base.say stderr_data, :red
+      end
+      
+      unless options[:keep_colors]
+        stdout_data = stdout_data.gsub(/\e\[(\d+)m/, '')
+        stderr_data = stderr_data.gsub(/\e\[(\d+)m/, '')
+      end
+      
+      # Remove \r's
+      stdout_data = stdout_data.gsub(/\r\n/, "\n").gsub(/\n\r/, "\n").gsub(/\r/, "\n") if stdout_data
+      stderr_data = stderr_data.gsub(/\r\n/, "\n").gsub(/\n\r/, "\n").gsub(/\r/, "\n") if stderr_data
+      
+      if options[:with_codes]
+        return stdout_data, stderr_data, exit_code, exit_signal
       else
-        return results.first
+        return stdout_data
       end
     end
     

data/lib/thor-ssh/version.rb

@@ -1,3 +1,3 @@
 module ThorSsh
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

data/spec/actions_spec.rb

@@ -168,18 +168,18 @@ describe "Thor SSH" do
   end
   
   it "should run exec with an exit code remotely" do
-    stdout, stderr, exit_code, exit_signal = @remote_test.exec('false', true)
+    stdout, stderr, exit_code, exit_signal = @remote_test.exec('false', :with_codes => true)
     exit_code.should == 1
   
-    stdout, stderr, exit_code, exit_signal = @remote_test.exec('true', true)
+    stdout, stderr, exit_code, exit_signal = @remote_test.exec('true', :with_codes => true)
     exit_code.should == 0
   end
   
   it "should run exec with an exit code locally" do
-    stdout, stderr, exit_code, exit_signal = @local_test.exec('false', true)
+    stdout, stderr, exit_code, exit_signal = @local_test.exec('false', :with_codes => true)
     exit_code.should == 1
   
-    stdout, stderr, exit_code, exit_signal = @local_test.exec('true', true)
+    stdout, stderr, exit_code, exit_signal = @local_test.exec('true', :with_codes => true)
     exit_code.should == 0
   end
   

data/spec/vagrant/.vagrant

@@ -1 +1 @@
-{"active":{"default":"11f0dbac-afd7-43ce-b6d8-7c10268c68f7"}}
+{"active":{"default":"d6c832ef-65a2-45d3-9f87-3a28ce460b04"}}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thor-ssh
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-15 00:00:00.000000000 Z
+date: 2012-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -207,7 +207,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3424361872212654297
+      hash: 543030509093831011
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -216,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3424361872212654297
+      hash: 543030509093831011
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.22