ro_rmt 0.0.2

data/lib/ro_helper/dp.rb

@@ -0,0 +1,20 @@
+require File.expand_path("../../../conf/ro_rmt", __FILE__)
+require 'ro_helper/redis'
+
+module ::RoHelper
+  module Dp
+    include Redis
+    #@example  ro_stage "dp st", *args
+
+    def run_ro_with_stage(*args, &blk)
+      ensure_that(has_meth(:ivk_cmds), or_raise_err: NoMethodError) do
+        stage = record('cur_deploy_stage') || "staging"
+        implicit_ivk_cmds(*args, '-s', stage)
+      end
+    end
+
+    def stage(*args, &blk)
+      run_ro_with_stage(*args, &blk)
+    end
+  end
+end

data/lib/ro_helper/rmt/basic.rb

@@ -0,0 +1,441 @@
+require File.expand_path("../../../../conf/ro_rmt", __FILE__)
+require 'ro_err'
+require 'ro_cell/trace'
+require 'net/ssh'
+require 'net/scp'
+require 'ro_helper/thr'
+require 'ro_core_ext/string'
+require 'ro_cell/rmt/se_mgr'
+
+require_relative 'scp'
+require_relative 'rb'
+
+require 'ro_cell/rmt/opts'
+
+module RoHelper
+  module Rmt
+    module Basic
+      include ::RoHelper::Rmt::SeAttrs
+      include ::RoHelper::Thr
+      include Rb
+      include Scp
+
+      attr_accessor :os
+
+      # @param [String] _user_at_host such as 'root@localhost'
+
+      def initialize(_user_at_host=nil, *args, &blk)
+        set_opts(*args, &blk)
+        # @user_at_host = _user_at_host
+        _user_at_host.match(%r{([^\@]+)\@(.*)}) do |m|
+          @user = m[1]
+          @host = m[2]
+        end
+
+        @user_at_host = _user_at_host
+
+        begin
+          @se ||= Net::SSH.start(host, user, keys: keys, auth_methods: ['publickey'])
+            # @se_backup = se.clone
+        rescue Net::SSH::Disconnect => e
+          raise ::RoErr::Rmt::Discnn, <<-CONTENT
+err:#{e}
+cmd: ssh -Nvvv #{user_at_host}
+          CONTENT
+        rescue Net::SSH::AuthenticationFailed => e
+          raise ::RoErr::Rmt::AuthFailed, <<-CONTENT
+run "ssh -vvv #{user_at_host}" fail at #{Pj.user}@localhost, it's probably caused by #{RoRmt.home(".ssh/id_rsa")} doesn't exist or wrong, please chk which is wrong
+
+solution:
+run "ssh -vvv #{user_at_host}" on #{Pj.user}@localhost
+if you really don't know which is wrong, please rm #{RoRmt.home(".ssh/id_rsa")}, and run `ssh-keygen -t rsa` again
+          CONTENT
+        end
+
+        register_on_mgr
+
+        if se.nil?
+          raise ::RoErr::Nil, "se is nil, please set it"
+        else
+          se
+        end
+      end
+
+
+      # def reset_se(*args, &blk)
+      #   se.close
+      #   @se = se_backup.clone
+      # end
+
+      def keys
+        [Pj.home(".ssh/id_rsa"), "/home/roroco/.ssh/id_rsa"]
+      end
+
+      def handle_auth_failed(*args, &blk)
+        begin
+          Out.notify("auth #{user_at_host} failed, try `ssh -vvv #{user_at_host}` again, see console for what err is raised    ", icon: "failed")
+          Net::SSH.start(host, user, keys: [RoRmt.home(".ssh/id_rsa")], auth_methods: ['publickey'], verbose: :dbg)
+        rescue Net::SSH::AuthenticationFailed => e
+          raise e
+        end
+      end
+
+      def register_on_mgr(*args, &blk)
+        last_meth = ro_trace.last.not(file: __FILE__)
+        se.instance_variable_set(:"@inited_at", last_meth.location)
+        se.instance_variable_set(:"@host", host)
+        se.instance_variable_set(:"@user", user)
+        se.instance_variable_set(:"@user_at_host", user_at_host)
+
+        se.class_eval do
+          attr_accessor :inited_at, :host, :user
+
+          def user_at_host
+            "#{user}@#{host}"
+          end
+        end
+
+        se_mgr.register se
+      end
+
+      def se_mgr(*args, &blk)
+        ::RoCell::Rmt::SeMgr
+      end
+
+      def out_rmt_stdout(ctn, *args, &blk)
+        if ctn
+          ctn.split("\n").each do |line|
+            final_line = "#{' '*4}#{line}"
+            Out.out final_line
+          end
+        end
+      end
+
+      def exe(*args, &blk)
+        r = capture(*args, &blk)
+        r
+      end
+
+      attr_accessor :within_dir
+
+      def within(dir, *args, &blk)
+        tmply_set :within_dir, dir do
+          yield self
+        end
+      end
+
+      def opts_tmply_set(*args, &blk)
+        ::RoCell::Rmt::Opts.tmply_set *args, &blk
+      end
+
+      def capture(*args, &blk)
+        args_clone, opts = args.clone.ro_opts
+
+        cmd = args.join(" ")
+        msg = opts[:status] || cmd
+
+        if msg.len > 100
+          msg = "\n#{msg}"
+        end
+
+        Out.status("run", "'#{msg.strip}' on #{user_at_host}")
+
+        out = nil
+        clr = caller.clone
+        stderr_lines = []
+
+        ch = se.open_channel do |ch|
+          ch.exec(cmd) do |ch, success|
+            raise "could not execute command: #{command.inspect}" unless success
+
+            ch.on_data do |ch, data|
+              unless ::RoCell::Rmt::Opts.shutup
+                puts data
+              end
+              out = data
+            end
+
+            ch.on_extended_data do |ch, type, data|
+              if data.len > 100
+                err_msg = "\nerr_msg:\n#{data}"
+              else
+                err_msg = "err_msg:#{data}"
+              end
+
+              stderr_lines << data
+            end
+          end
+        end
+
+        ch.wait
+        ch.close
+
+        unless ::RoCell::Rmt::Opts.ignore_err or stderr_lines.empty?
+          if stderr_lines.any? do |l|
+            l.match(%r{\tfrom})
+          end
+            bt = []
+            err_msg_arr = []
+            stderr_lines.each do |l|
+              if l.match(%r{\tfrom})
+                l.split("\n").each do |_l|
+                  bt << _l.gsub(%r{^\tfrom\s+}, "")
+                end
+              else
+                err_msg_arr << l
+              end
+            end
+
+            e = RoErr::RmtErr.new(Out.uncolor(err_msg_arr.join), backtrace: bt.map(&:strip).hits)
+          else
+            e = RoErr::RmtErr.new(Out.uncolor(stderr_lines.join("\n")), backtrace: clr)
+          end
+
+          raise e
+        end
+
+        out
+      end
+
+      def listened?(*args, &blk)
+        rb3 <<-CONTENT
+require 'socket'
+begin
+  TCPServer.new('localhost', '23302')
+  puts false
+rescue Errno::EADDRINUSE => e
+  puts true
+end
+        CONTENT
+      end
+
+      def vagrant?
+        user == 'vagrant'
+      end
+
+      def mkdir(*args, &blk)
+        create_dir(*args, &blk)
+      end
+
+      def bash(*args, &blk)
+        if within_dir
+          exe(*["cd #{within_dir};", args].hits, &blk)
+        else
+          exe(*args, &blk)
+        end
+      end
+
+      def build_err(e, rescued_err)
+        err = lambda do
+          if e.inspect.match(%r{SSHKit})
+            msg = <<-CONTENT
+
+#{rescued_err.message}
+since
+\"#{e.inspect}\"
+SSHKit.conf.output_verbosity:#{SSHKit.cf.output_verbosity}
+            CONTENT
+
+            bt = rescued_err.backtrace
+            e.set_backtrace(bt)
+            e.class_eval do
+              define_method(:message) do |*args, &blk|
+                msg
+              end
+            end
+            e
+          elsif e.inspect.match(%r{Net\:\:SSH})
+            msg = <<-CONTENT
+#{rescued_err.message}
+since
+\"#{e.inspect}\"
+SSHKit::Backend::Netssh.conf.ssh_options:#{SSHKit::Backend::Netssh.cf.ssh_options}
+            CONTENT
+            bt = rescued_err.backtrace
+            e.set_backtrace(bt)
+            e.class_eval do
+              define_method(:message) do |*args, &blk|
+                msg
+              end
+            end
+            e
+          else
+            e.set_backtrace(rescued_err.backtrace)
+            e
+          end
+        end.call
+      end
+
+      def bash_shutup(*args, &blk)
+        ::RoCell::Rmt::Opts.tmply_set :shutup do
+          capture(*args, &blk)
+        end
+      end
+
+      def cmd(*args, &blk)
+        if within_dir
+          args = ["cd #{within_dir}", *args].flatten
+          bash *args, &blk
+        else
+          bash *args, &blk
+        end
+      end
+
+      def cd_bash(*args, &blk)
+        first_arg = args.shift
+        new_first_arg = "cd #{within_dir}; #{first_arg}"
+        bash(*[new_first_arg, args].flatten, &blk)
+      end
+
+      def cmd_force(*args, &blk)
+        begin
+          cmd(*args, &blk)
+        rescue SSHKit::Runner::ExecuteError => e
+        end
+      end
+
+      def cmdf(*args, &blk)
+        cmd_force(*args, &blk)
+      end
+
+      alias_method :cmdf, :cmd_force
+
+      def capture_shutup(*args, &blk)
+        capture(*args, &blk)
+      end
+
+      def cmd_recued_err(args, bt)
+        args = args.flatten.select do |arg|
+          !arg.blank?
+        end
+
+        ori_cmd = args.join("; ")
+        cmd = _format(ori_cmd)
+        msg = "run `#{ori_cmd}` fail"
+        rescued_err = RoErr::DeployErr.new(msg, bt)
+        return cmd, rescued_err
+      end
+
+      def pj_bash(cmd)
+        cmd "cd #{::RoRmt.rmt_rt} && #{cmd}"
+      end
+
+      def format(*cmds)
+        r = _format(cmds)
+        out_run_cmd(r)
+        r
+      end
+
+      def out_run_cmd(r)
+        Out.status("running", "#{r} on #{stage || ::RoRmt.cur_role}")
+      end
+
+      def _format(*cmds)
+        cmds_flatten_join = cmds.flatten.join("; ")
+        "#{prefix} #{cmds_flatten_join}"
+        cmds_flatten_join
+      end
+
+      def prefix
+        @prefix ||= "PATH=~/.rbenv/shims:~/.rbenv/bin:$PATH &&"
+      end
+
+      def rmt_output
+        @remote_output ||= "/tmp/ro_rmt.log"
+      end
+
+      def sudo(*cmds)
+        cmd "sudo #{cmds.flatten.join(" ")}"
+      end
+
+      def bashes_in_details(*cmds)
+        result = nil
+        on stage do
+          cmds.each do |cmd|
+            exe cmd
+          end
+        end
+        result
+      end
+
+      def bundle_exec(*args, &blk)
+        begin
+          r = bash "ro_stage=prod bundle exec #{args.join(" ")}"
+          if r.match(%r{Could not locate Gemfile})
+            raise ::RoErr::RmtErr, "#{r.strip} on #{user_at_host}"
+          end
+          r
+        rescue ::RoErr::RmtErr => e
+          loc = ro_trace.last_location_not(file: __FILE__)
+          raise ::RoErr::RmtErr, e.to_s, (e.backtrace + [loc])
+        end
+      end
+
+      # @param [String] to  to dir in rmt, such as root@rmt
+
+      def rsync(*args, &blk)
+        files, opts = args.ro_opts
+        parents = files.map do |f|
+          RoFile.parent(f).gsub(Pj.home, home)
+        end
+
+        ms_parents_str = "mkdir -p #{parents.join(" ")}"
+
+        cmd = "rsync --rsync-path='#{ms_parents_str}; rsync' -avzr --force #{files.join(" ")} -e 'ssh -p #{port} -i #{Pj.home(".vagrant.d/insecure_private_key")}' #{user_at_host}:#{opts[:to].gsub(Pj.home, home)} --include-from=#{RoRmt.conf("rsync/include_patterns")} --exclude-from=#{RoRmt.conf "rsync/exclude_patterns"}"
+        Bash.bash cmd
+      end
+
+      def rake(*args, &blk)
+        bundle_exec "rake", *args
+      end
+
+      def rk(*args, &blk)
+        rake(*args, &blk)
+      end
+
+      def bxro(bash, *args, &blk)
+        bundle_exec "ro #{bash}", *args
+      end
+
+      def ro(*args, &blk)
+        bxro(*args, &blk)
+      end
+
+      def home(*args, &blk)
+        _home = lambda do
+          if user == 'root'
+            "/root"
+          else
+            "/home/#{user}"
+          end
+        end.call
+
+        RoFile.join _home, *args, &blk
+      end
+
+      def format_path(path)
+        r = path.gsub(%r{^\~}, home)
+        r = r.gsub(%r{\/{2,}}, "\/")
+        r
+      end
+
+      def boolean?(r)
+        if r.is_a?(String)
+          r.match(%r{^[\n\s]*(true|false)[\n\s]*$})
+        elsif r == true or r == false
+          r
+        else
+          false
+        end
+      end
+
+      def eval_result_file
+        @rb_eval_result_file ||= "/tmp/rb_eval_result.yml"
+      end
+
+      def capture_eval(*args, &blk)
+        capture(create_lc_script(*args, &blk))
+      end
+    end
+  end
+end