anywhere 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in anywhere.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Tobias Schwab
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Anywhere
+
+Simple wrapper for Net/SSH.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'anywhere'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install anywhere
+
+## Usage
+
+### From ruby
+    pry> require "anywhere/ssh"
+    pry> ssh = Anywhere::SSH.new(host = "test.host", user = "root", port: 1234)
+    pry> ssh.execute("uptime")
+    => <run_time=0.659416, cmd=<uptime>, stdout=<1 lines, 61 chars>, stderr=<empty>, exit_status=0>
+
+### From command line
+
+    $ anywhere root@host1 root@host2
+
+    pry> _"uptime"
+    2013-06-09T22:35:51.303413Z [host1] DEBUG  00:35:51 up 179 days,  7:48,  0 users,  load average: 0.00, 0.00, 0.00
+    2013-06-09T22:35:51.307168Z [host2] DEBUG  22:35:51 up 299 days, 10:49,  0 users,  load average: 0.08, 0.05, 0.06
+    => [<run_time=0.06875, cmd=<uptime>, stdout=<1 lines, 72 chars>, stderr=<empty>, exit_status=0>,
+     <run_time=0.067885, cmd=<uptime>, stdout=<1 lines, 72 chars>, stderr=<empty>, exit_status=0>]
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/anywhere.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'anywhere/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "anywhere"
+  spec.version       = Anywhere::VERSION
+  spec.authors       = ["Tobias Schwab"]
+  spec.email         = ["tobias.schwab@dynport.de"]
+  spec.description   = %q{Simple wrapper for Net/SSH}
+  spec.summary       = %q{Simple wrapper for Net/SSH}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "net-ssh"
+  spec.add_dependency "colorize"
+  spec.add_dependency "pry"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/bin/anywhere

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+$:.push(File.expand_path("../../lib", __FILE__))
+require "anywhere"
+require "anywhere/ssh"
+RUNNER = Anywhere::SSH.new(host = "test.host", user = "root")
+RUNNER.logger.prefix = "[" + RUNNER.host + "]"
+
+hosts = []
+names = []
+RUNNERS = ARGV.map do |host|
+  name, user = host.split("@").reverse
+  user ||= "root"
+  names << name
+  Anywhere::SSH.new(name, user)
+end
+
+max_name = names.sort_by(&:length).last.length
+
+RUNNERS.each do |runner|
+  runner.logger.prefix = "[%0#{max_name}s]" % [runner.host]
+end
+
+def _(*args)
+  RUNNERS.map do |runner|
+    Thread.new do
+      begin
+        runner.execute(args.join(" "))
+      rescue Anywhere::ExecutionError => err
+        err.result
+      end
+    end
+  end.map(&:join).map(&:value)
+end
+
+begin
+  puts "hosts: #{RUNNERS.map(&:host).join(",")}"
+  puts %(usage: _"ls -la")
+  require "pry"
+  pry.binding
+rescue SystemExit, NoMethodError
+end

data/lib/anywhere.rb

@@ -0,0 +1,10 @@
+require "anywhere/version"
+require "anywhere/logger"
+
+module Anywhere
+  class << self
+    def logger
+      @logger ||= Anywhere::Logger.new
+    end
+  end
+end

data/lib/anywhere/base.rb

@@ -0,0 +1,124 @@
+require "benchmark"
+require "anywhere/logger"
+
+module Anywhere
+  class Base
+    attr_writer :logger
+
+    def logger
+      @logger ||= Anywhere::Logger.new
+    end
+
+    def root?
+      whoami == "root"
+    end
+
+    def execute(cmd, stdin = nil)
+      do_execute(cmd, stdin) do |stream, data|
+        data.split("\n").each do |line|
+          if stream == :stderr
+            logger.error line
+          else
+            logger.debug line
+          end
+        end
+      end
+    end
+
+    def whoami
+      @whoami ||= execute("whoami").stdout.strip
+    end
+
+    def do_execute(*args)
+      raise "implement me in subclass"
+    end
+
+    def file_exists?(path)
+      execute("test -e #{path}")
+      true
+    rescue Anywhere::ExecutionError => err
+      if err.result.exit_status == 1
+        false
+      else
+        raise
+      end
+    end
+
+    def md5sum(path)
+      execute("md5sum #{path} | awk '{ print $1 }'").stdout.strip
+    end
+
+    def sudo_cmd
+      @sudo_cmd ||= root? ? "" : "sudo"
+    end
+
+    def add_system_user(login)
+      raise "user #{login} already exists" if user_exists?(login)
+      logger.info "adding system user #{login}"
+      execute!("#{sudo_cmd} adduser --system #{login}")
+    end
+
+    def run_as(user, cmd)
+      execute("sudo -- sudo -u #{user} -- #{cmd}")
+    end
+
+    def user_exists?(login)
+      execute("id #{login} 2>/dev/null").success?
+    end
+
+    def write_file(path, content, attributes = {})
+      md5 = Digest::MD5.hexdigest(content).to_s
+      if file_exists?(path)
+        logger.debug "file #{path} already exists"
+        file_md5 = md5sum(path)
+        if file_md5 == md5
+          logger.info "file #{path} did not change => not writing"
+          return :not_changed
+        end
+      end
+      logger.info "writing #{content.length} bytes to #{path} (md5: #{md5})"
+      tmp_path = "/opt/urknall/tmp/files.#{md5}"
+      execute("#{sudo_cmd} mkdir -p #{File.dirname(tmp_path)}")
+      execute("#{sudo_cmd} chown #{whoami} #{File.dirname(tmp_path)}")
+      logger.debug "writing to #{tmp_path}"
+      execute(%(rm -f #{tmp_path}; cat - > #{tmp_path}), content)
+      if mode = attributes[:mode]
+        logger.info "changing mode to #{mode}"
+        execute("chmod #{mode} #{tmp_path}")
+      end
+      if owner = attributes[:owner]
+        logger.info "changing owner to #{owner}"
+        execute("#{sudo_cmd} chown #{owner} #{tmp_path}")
+      end
+      execute("#{sudo_cmd} mkdir -p #{File.dirname(path)}")
+      logger.debug "moving #{tmp_path} to #{path}"
+      if file_exists?(path)
+        logger.debug "diff #{path} #{tmp_path}"
+        execute("diff #{tmp_path} #{path}").stdout.split("\n").each do |line|
+          logger.debug line
+        end
+      end
+      execute("#{sudo_cmd} mv #{tmp_path} #{path}")
+    end
+
+    def extract_tar(path, dst)
+      ms = Benchmark.measure do
+        data = File.open(path, "rb") do |f|
+          f.read
+        end
+        logger.info "writing #{data.length} bytes"
+        execute(%(mkdir -p #{dst} && cd #{dst} && tar xfz -), data)
+      end
+      logger.info "extracted archive in %.3f" % [ms.real]
+    end
+
+    def mkdir_p(path)
+      logger.info "creating directory #{path}"
+      execute("mkdir -p #{path}")
+    end
+
+    def home_dir
+      execute("env | grep HOME | cut -d = -f 2").stdout.strip
+    end
+  end
+end

data/lib/anywhere/execution_error.rb

@@ -0,0 +1,9 @@
+module Anywhere
+  class ExecutionError < StandardError
+    attr_reader :result
+
+    def initialize(result)
+      @result = result
+    end
+  end
+end

data/lib/anywhere/local.rb

@@ -0,0 +1,39 @@
+require "anywhere"
+require "anywhere/result"
+require "anywhere/execution_error"
+require "anywhere/base"
+
+module Anywhere
+  class Local < Base
+    def do_execute(cmd, stdin_data = nil)
+      require "open3"
+      result = Result.new(cmd)
+      result.started!
+      Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
+        stdin.print stdin_data if stdin_data
+        stdin.close
+        while true
+          streams, _ = IO.select([stdout, stderr], [], [], 1)
+          break if streams.nil? || streams.all? { |s| s.eof? }
+          streams.compact.each do |stream|
+            stream.each do |line|
+              if stream == stdout
+                result.add_stdout(line.strip)
+                logger.info(line) if logger
+              elsif stream == stderr
+                result.add_stderr(line.strip)
+                logger.error(line) if logger
+              end
+            end
+          end
+        end
+        result.exit_status = wait_thr.value.exitstatus
+      end
+      result.finished!
+      if !result.success?
+        raise ExecutionError.new(result)
+      end
+      result
+    end
+  end
+end

data/lib/anywhere/logger.rb

@@ -0,0 +1,51 @@
+require "colorize"
+require "time"
+
+module Anywhere
+  class Logger
+    attr_accessor :prefix
+
+    class << self
+      def mutex
+        @mutex ||= Mutex.new
+      end
+    end
+
+    def initialize(attributes = {})
+      @attributes = attributes
+    end
+
+    def prefix
+      @prefix ||= @attributes[:prefix]
+    end
+
+    def stream
+      @attributes[:stream] ||= STDOUT
+    end
+
+    def info(message)
+      print_with_prefix "INFO ".green + " #{message}"
+    end
+
+    def error(message)
+      print_with_prefix "ERROR".red + " #{message}"
+    end
+
+    def debug(message)
+      print_with_prefix "DEBUG".blue + " #{message}"
+    end
+
+    def print_with_prefix(message)
+      out = [Time.now.utc.iso8601(6)]
+      if prefix.is_a?(String)
+        out << prefix
+      elsif prefix.respond_to?(:call)
+        out << prefix.call
+      end
+      out << message
+      self.class.mutex.synchronize do
+        stream.puts out.join(" ")
+      end
+    end
+  end
+end

data/lib/anywhere/result.rb

@@ -0,0 +1,60 @@
+module Anywhere
+  class Result
+    attr_accessor :cmd, :stdout, :stderr, :exit_status
+
+    def initialize(cmd)
+      @cmd = cmd
+      @stdout = []
+      @stderr = []
+    end
+
+    def add_stderr(line)
+      @stderr << line
+    end
+
+    def add_stdout(line)
+      @stdout << line
+    end
+
+    def stderr
+      @stderr.join("\n")
+    end
+
+    def stdout
+      @stdout.join("\n")
+    end
+
+    def started!(time = Time.now)
+      @started = time
+    end
+
+    def finished!(time = Time.now)
+      @finished = time
+    end
+
+    def success?
+      @exit_status == 0
+    end
+
+    def run_time
+      @finished - @started
+    end
+
+    def inspect
+      parts = ["run_time=#{run_time}"]
+      parts << "cmd=<#{@cmd}>"
+      parts << "stdout=#{inspect_string(@stdout)}"
+      parts << "stderr=#{inspect_string(@stderr)}"
+      parts << "exit_status=#{@exit_status}"
+      "<" + parts.join(", ") + ">"
+    end
+
+    def inspect_string(string)
+      if string.empty?
+        "<empty>" 
+      else
+        "<#{string.count} lines, #{string.join(" ").length} chars>"
+      end
+    end
+  end
+end