ro_rmt 0.0.2

data/lib/ro_helper/rmt/compress.rb

@@ -0,0 +1,31 @@
+module RoHelper
+  module Rmt
+    module Compress
+      def uncompress(compressed_file, out_dir, *args, &blk)
+        if zip?(compressed_file)
+          unzip(compressed_file, out_dir)
+        end
+
+        if tar?(compressed_file)
+          tar_xf(compressed_file, out_dir)
+        end
+      end
+
+      def zip?(file, *args, &blk)
+        file.match(%r{\.zip$})
+      end
+
+      def tar?(file, *args, &blk)
+        file.match(%r{\.tar\.gz$})
+      end
+
+      def unzip(zip_file, out_dir, *args, &blk)
+        bash "unzip #{zip_file} -d #{out_dir}"
+      end
+
+      def tar_xf(tar_file, out_dir, *args, &blk)
+        bash "tar xf #{tar_file} -C #{out_dir}"
+      end
+    end
+  end
+end

data/lib/ro_helper/rmt/determinations.rb

@@ -0,0 +1,25 @@
+module RoHelper
+  module Rmt
+    module Determinations
+      def lc?(*args, &blk)
+        host?('lchost') or host?("localhost")
+      end
+
+      def host?(hostname, *args, &blk)
+        host == hostname
+      end
+
+      def rmt?(*args, &blk)
+        rmt?('rmthost')
+      end
+
+      def x?(*args, &blk)
+        x?('xhost')
+      end
+
+      def rt?(*args, &blk)
+        user == 'root'
+      end
+    end
+  end
+end

data/lib/ro_helper/rmt/dir.rb

@@ -0,0 +1,11 @@
+require File.expand_path("../../../../conf/ro_rmt", __FILE__)
+require_relative 'file_dir'
+require_relative 'scp'
+
+module RoHelper
+  module Rmt
+    module Dir
+      include FileDir
+    end
+  end
+end

data/lib/ro_helper/rmt/file.rb

@@ -0,0 +1,13 @@
+require File.expand_path("../../../../conf/ro_rmt", __FILE__)
+require 'ro_cell/rmt/file'
+require 'ro_cell/rmt/dir'
+require_relative 'file_dir'
+require_relative 'scp'
+
+module RoHelper
+  module Rmt
+    module File
+      include FileDir
+    end
+  end
+end

data/lib/ro_helper/rmt/file_dir.rb

@@ -0,0 +1,60 @@
+require 'ro_helper/misc'
+require 'ro_cell/rmt/file'
+require 'ro_cell/rmt/dir'
+require 'ro_core_ext/module'
+
+module RoHelper
+  module Rmt
+    module FileDir
+      class << self
+        def included(base)
+          base.send(:include, RoHelper::Misc)
+
+          base.class_eval do
+            meth_name = cst_basename
+            ins_name = meth_name
+            kls_name = "RoCell::Rmt::#{cst_kls_name}"
+
+            begin
+              kls = eval(kls_name)
+            rescue NameError => e
+              kls = nil
+            end
+
+            if kls
+              def_meth(meth_name) do |path, *args, &blk|
+                begin
+                  last_frame = ro_trace.last_frame_not(file: %r{\/rmt\/})
+                  meth_name = last_frame.meth
+                  file = last_frame.file
+
+                  Out.out "##{meth_name} ---- in #{file}"
+                  kls.new(path, {se: RoCell::Rmt::SeMgr.cur_se}, *args, &blk)
+                rescue Exception => e
+                  raise e
+                end
+              end
+
+              ms = kls.ins_meths_defined_in_self
+
+              # set breakpoint on RmtFile#meth_name or RmtDir#meth_name to dbg
+
+              # def file_write and write_file
+              ms.each do |meth_name|
+                new_meth_name = "#{ins_name}_#{meth_name}"
+                reverse_meth_name = "#{meth_name}_#{ins_name}".gsub(%r{(.+)\?(.+)}, '\1\2?')
+                def_meth(new_meth_name) do |path, *args, &blk|
+                  send(:"#{ins_name}", path).send(:"#{meth_name}", *args, &blk)
+                end
+
+                def_meth(reverse_meth_name) do |*args, &blk|
+                  send(:"#{new_meth_name}", *args, &blk)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ro_helper/rmt/process.rb

@@ -0,0 +1,46 @@
+module RoHelper
+  module Rmt
+    module Process
+      def kill(pid, *args, &blk)
+        begin
+          if lc?
+            ::Bash.kill(pid)
+          else
+            sudo "kill -s KILL #{pid}"
+          end
+        rescue SSHKit::Runner::ExecuteError => e
+        end
+      end
+
+      def running?(kw, *args, &blk)
+        pgrep.any? do |l|
+          l.match(kw)
+        end
+      end
+
+      def get_result(*args, &blk)
+        YAML.load(read_file("/tmp/rb_eval_result.yml"))
+      end
+
+      def pgrep(*args, &blk)
+        eval_script RoRmt.lib("ro_script/pgrep.rb")
+        get_result
+      end
+
+      def kill_port(port, *args, &blk)
+        script_file = RoRmt.lib("ro_script/kill_port")
+        eval_script(script_file, port)
+      end
+
+      def service(*args, &blk)
+        sudo "service #{args.join(" ")}"
+      end
+
+      def pkill(*args, &blk)
+        re_str = "\"#{args.join(" ")}\""
+        eval_script RoRmtPlus.lib("ro_script/pkill.rb"), re_str
+        get_result
+      end
+    end
+  end
+end

data/lib/ro_helper/rmt/rb.rb

@@ -0,0 +1,131 @@
+require 'ro_core_ext/kernel'
+module ::RoHelper
+  module Rmt
+    module Rb
+      def create_lc_script(_script, *args, &blk)
+        script = _script.del_blank.gsub(%r{\"}, "'")
+        ctn = <<-CONTENT
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'yaml'
+require 'open3'
+
+def bash(*args, &blk)
+  cmd = args.join(' ')
+  out, err, status = Open3.capture3(cmd)
+  unless status.success?
+    raise err
+  end
+  out
+end
+
+result = lambda do
+  begin
+    #{script}
+  rescue Exception => e
+    e
+  end
+end.call
+
+File.write('#{eval_result_file}', YAML.dump(result))
+        CONTENT
+
+        script2 = %Q(#{ctn})
+        fin_script = ::RoCell::Formatter.format(script2)
+        RoFile.write(script_path, fin_script)
+      end
+
+      def script_path(*args, &blk)
+        RoFile.join "/tmp/rb_eval/scripts", *args, &blk
+      end
+
+      def eval_result_file(*args, &blk)
+        "/tmp/rb_eval/result.yml"
+      end
+
+      def rb(*args, &blk)
+        eval(*args, &blk)
+      end
+
+      def rb2(*args, &blk)
+        rb_exe(*args, &blk)
+      end
+
+      def rb_exe(script, *args, &blk)
+        bash("ruby -e '#{script}'")
+      end
+
+      def rb3(*args, &blk)
+        rb_capture(*args, &blk)
+      end
+
+      def rb_capture(script, *args, &blk)
+        bash_shutup("ruby -e \"#{script}\"").try_to_boolean
+      end
+
+      def eval(script, *args, &blk)
+        script = script.gsub(%r{\n$}, "")
+        fin_script = %Q(#{script})
+        r = bash_shutup "ruby -e \"require 'fileutils'; require 'yaml'; puts(YAML.dump(#{fin_script}))\""
+        YAML.load(r)
+      end
+
+      def up_eval_script(f, *args, &blk)
+        lc, rmt = get_lc_rmt_script_path(f)
+        up(lc)
+        eval_script(f, *args, &blk)
+      end
+
+      # if you can not eval script since script is too complex,  up script and run it with this meth, mk writing more easier. Attention, if script exist in rmt, #eval_script will run this script without uploading
+      # @example see lib/ro_script/pkill.rb
+      # attention: don't use puts on ruby path  if  you wanna get a correct value from sv, sshkit will capture full stdout, and it will effect your val
+
+      # @param [String] _path lc script path
+
+      def eval_script(_path, *args, &blk)
+        lc, rmt = get_lc_rmt_script_path(_path)
+
+        begin
+          _eval_script(rmt, *args, &blk)
+        rescue ::RoErr::RmtErr => e
+          msg = e.to_s
+          if msg.match(%r{No such file or directory})
+            up(lc, rmt)
+          elsif msg.match(%r{cannot load such file})
+            bash "gem 'ro_thor', git: 'https://github.com/roroco/ro_thor'"
+          else
+            raise e
+          end
+
+          _eval_script(rmt, *args, &blk)
+        end
+      end
+
+      def get_lc_rmt_script_path(_path)
+        lc = _path.suffix(".rb")
+
+        unless test(?f, lc)
+          lc = Pj.cur_lib("ro_script", lc)
+        end
+
+        rmt = lc.gsub(Pj.home, home)
+        return lc, rmt
+      end
+
+      def _eval_script(rmt, *args, &blk)
+        begin
+          bash("ruby #{rmt} #{args.join(" ")}")
+        rescue ::RoErr::RmtErr => e
+          if e.to_s.match("cannot load such file -- ro_thor")
+            Out.warn e
+            bash "sudo gem install 'ro_thor'"
+            _eval_script(rmt, *args, &blk)
+          else
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ro_helper/rmt/scp.rb

@@ -0,0 +1,117 @@
+require 'ro_helper/misc'
+require_relative 'se_attrs'
+require 'net/scp'
+
+module RoHelper
+  module Rmt
+    module Scp
+      include ::RoHelper::Misc
+      include SeAttrs
+
+      def se(*args, &blk)
+        if defined? super
+          return super
+        end
+
+        not_implement
+      end
+
+      def tmply_down(path, *args, &blk)
+        to_tmp_path = down_to_tmp(path)
+        r = yield(to_tmp_path)
+        up_tmp(path)
+        r
+      end
+
+      def scp(*args, &blk)
+        se.scp(*args, &blk)
+      end
+
+      def out(*args, &blk)
+        ro_trace.tap do |c|
+          last_meth_name = c.last_meth
+          call_line = c.last.not(file: __FILE__).location
+          Out.status("#{last_meth_name}", "#{args.join(" ")} ---- #{call_line}")
+        end
+      end
+
+      def down(*args, &blk)
+        out
+        _down(*args, &blk)
+      end
+
+      def down2(url, output_name = nil, *args, &blk)
+        output_name ||= RoFile.basename(url)
+        path = "~/Downloads/#{output_name}"
+        unless exist?(path)
+          dir = RoFile.parent(path)
+          bash("mkdir -p #{dir}; cd #{dir}; aria2c #{url} --out #{RoFile.basename(path)}")
+          if block_given?
+            yield path
+          end
+        end
+        path
+      end
+
+      def _down(from, to=nil, *args, &blk)
+        to ||= from
+        RoFile.mkparent(to)
+        Out.status("down", "\nfrom #{from}\nto #{to}")
+        Out.out
+
+        # don't use if rmt_path_is_dir?, it will waste time, use #download_dir to download a dir
+        scp.download!(from, to, *args, &blk)
+        to
+      end
+
+      def down_dir(*args, &blk)
+        not_implement
+      end
+
+      def up(f, *args, &blk)
+        out(f)
+        _up(f, *args, &blk)
+      end
+
+      def _up(from, to=nil, *args, &blk)
+        to ||= from
+
+        from = from.gsub(%r{^~}, Pj.home)
+        to = format_path(to)
+
+        begin
+          rsync(from, to: to)
+        rescue ::RoErr::BashErr => e
+          if e.match("Permission denied")
+            tmp_to = RoFile.join("/tmp", to.gsub(%r{/}, "-"))
+            rsync(from, to: tmp_to)
+            bash "sudo mv #{tmp_to} #{to}"
+          else
+            raise e
+          end
+        end
+
+        to
+      end
+
+      def down_to_tmp(from_rmt_path, *args, &blk)
+        out
+        to_lc_path = lc_tmp(from_rmt_path)
+        _down(from_rmt_path, to_lc_path)
+      end
+
+      def lc_tmp(path=nil)
+        RoRmt.cur_tmp("#{user}/at/#{host}", path)
+      end
+
+      def up_tmp(to_rmt_path, *args, &blk)
+        out
+        from_lc_path = lc_tmp(to_rmt_path)
+        _up(from_lc_path, to_rmt_path)
+        rmt_path = to_rmt_path
+      end
+    end
+
+
+  end
+end

data/lib/ro_helper/rmt/se_attrs.rb

@@ -0,0 +1,28 @@
+require 'ro_helper/misc'
+module ::RoHelper
+  module Rmt
+    module SeAttrs
+      include ::RoHelper::Misc
+
+      # attr_accessor :se, :se_backup
+      attr_accessor :se
+
+      def host
+        @host ||= se.transport.host
+      end
+
+      def user
+        @user ||= se.options[:user]
+      end
+
+      def port
+      	@port ||= se.transport.port
+      end
+
+      def user_at_host
+        @user_at_host ||= "#{user}@#{host}"
+      end
+
+    end
+  end
+end