rundock 0.1.0

data/lib/rundock/logger.rb

@@ -0,0 +1,106 @@
+require 'rundock'
+require 'logger'
+require 'ansi/code'
+
+module Rundock
+  module Logger
+    class Formatter
+      attr_accessor :colored
+      attr_accessor :indent_depth
+      attr_accessor :color
+
+      def initialize(*args)
+        super
+        @indent_depth = 0
+      end
+
+      def call(severity, datetime, progname, msg)
+        out = "[%5s:] %s%s\n" % [severity, ' ' * 2 * indent_depth, msg2str(msg)]
+        if colored
+          colorize(out, severity)
+        else
+          out
+        end
+      end
+
+      def indent
+        add_indent
+        yield
+      ensure
+        reduce_indent
+      end
+
+      def add_indent
+        @indent_depth += 1
+      end
+
+      def reduce_indent
+        @indent_depth -= 1 if @indent_depth > 0
+      end
+
+      def color(code)
+        prev_color = @color
+        @color = code
+        yield
+      ensure
+        @color = prev_color
+      end
+
+      private
+
+      def msg2str(msg)
+        case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{msg.message} (#{msg.class})\n" << (msg.backtrace || []).join("\n")
+        else
+          msg.inspect
+        end
+      end
+
+      def colorize(msg, severity)
+        if @color
+          col = @color
+        else
+          col = case severity
+                when 'INFO'
+                  :clear
+                when 'WARN'
+                  :yellow
+                when 'ERROR'
+                  :red
+                else
+                  :clear
+                end
+        end
+
+        ANSI.public_send(col) { msg }
+      end
+    end
+
+    class << self
+      def logger
+        @logger ||= create_logger
+      end
+
+      private
+
+      def create_logger
+        ::Logger.new($stdout).tap do |logger|
+          logger.formatter = Formatter.new
+        end
+      end
+
+      private
+
+      def respond_to_missing?(method, include_private = false)
+        logger.respond_to?(method)
+      end
+
+      def method_missing(method, *args, &block)
+        logger.public_send(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/rundock/node.rb

@@ -0,0 +1,27 @@
+require 'rundock'
+
+module Rundock
+  class Node
+    attr_reader :name
+    attr_reader :operations
+    attr_reader :backend
+
+    def initialize(name, backend)
+      @name = name
+      @backend = backend
+    end
+
+    def add_operation(ope)
+      @operations = [] unless @operations
+      @operations << ope
+    end
+
+    def run
+      Logger.debug("run name: #{@name}")
+      @operations.each do |ope|
+        Logger.debug("operation type: #{ope.class}")
+        ope.run(@backend, ope.attributes)
+      end
+    end
+  end
+end

data/lib/rundock/operation/base.rb

@@ -0,0 +1,20 @@
+module Rundock
+  module Operation
+    class Base
+      OperationNotImplementedError = Class.new(NotImplementedError)
+
+      attr_reader :instruction
+      attr_reader :attributes
+
+      def initialize(instruction, attributes)
+        @instruction = instruction
+        @attributes = attributes
+        @attributes = {} unless attributes
+      end
+
+      def run(backend, attributes = {})
+        raise OperationNotImplementedError
+      end
+    end
+  end
+end

data/lib/rundock/operation/command.rb

@@ -0,0 +1,11 @@
+module Rundock
+  module Operation
+    class Command < Base
+      def run(backend, attributes = {})
+        @instruction.each do |i|
+          backend.run_commands(i, attributes)
+        end
+      end
+    end
+  end
+end

data/lib/rundock/operation/task.rb

@@ -0,0 +1,16 @@
+module Rundock
+  module Operation
+    class Task < Base
+      def run(backend, attributes = {})
+        @instruction.each do |i|
+          unless attributes.key?(i)
+            Logger.warn("[WARN]task not found and ignored: #{i}")
+            next
+          end
+
+          backend.run_commands(attributes[i])
+        end
+      end
+    end
+  end
+end

data/lib/rundock/operation_factory.rb

@@ -0,0 +1,30 @@
+module Rundock
+  class OperationFactory
+    OperationNotImplementedError = Class.new(NotImplementedError)
+
+    def self.instance(type)
+      self.new(type)
+    end
+
+    def initialize(type)
+      @type = type
+    end
+
+    def create(instruction, attributes)
+      klass = "Rundock::Operation::#{@type.to_s.to_camel_case}"
+      raise OperationNotImplementedError unless Rundock::Operation::Base.subclasses.map(&:to_s).include?(klass)
+
+      obj = nil
+      klass.split('::').map do |k|
+        if obj.nil?
+          obj = Kernel.const_get(k)
+        else
+          obj = obj.const_get(k)
+        end
+      end
+
+      operation = obj.new(instruction, attributes)
+      operation
+    end
+  end
+end

data/lib/rundock/runner.rb

@@ -0,0 +1,182 @@
+require 'rundock'
+require 'yaml'
+require 'tempfile'
+require 'open-uri'
+
+module Rundock
+  class Runner
+    PRESET_SSH_OPTIONS_DEFAULT_FILE_PATH = "#{Gem::Specification.find_by_path('rundock').full_gem_path}/default_ssh.yml"
+    ScenarioNotFoundError = Class.new(StandardError)
+    CommandArgNotFoundError = Class.new(StandardError)
+
+    class << self
+      def run(options)
+        Logger.info 'Starting Rundoc:'
+
+        runner = self.new(options)
+        runner.build(options)
+        runner.run
+      end
+    end
+
+    attr_reader :backend
+    attr_reader :scenario
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      @scenario.run
+    end
+
+    def build(options)
+      if options['scenario_yaml']
+        unless FileTest.exist?(options['scenario_yaml'])
+          raise ScenarioNotFoundError, "'#{options['scenario_yaml']}' scenario file is not found."
+        end
+
+        # parse scenario
+        if options['scenario_yaml'] =~ %r{^(http|https)://}
+          # read from http/https
+          open(options['scenario_yaml']) do |f|
+            @scenario = parse_scenario(f, options)
+          end
+        else
+          File.open(options['scenario_yaml']) do |f|
+            @scenario = parse_scenario(f, options)
+          end
+        end
+      else
+        @scenario = parse_scenario(nil, options)
+      end
+    end
+
+    private
+
+    def parse_default_ssh(options)
+      opts = {}
+
+      if options['default_ssh_opts_yaml'] && FileTest.exist?(options['default_ssh_opts_yaml'])
+        def_ssh_file = options['default_ssh_opts_yaml']
+      else
+        def_ssh_file = PRESET_SSH_OPTIONS_DEFAULT_FILE_PATH
+      end
+
+      File.open(def_ssh_file) do |f|
+        YAML.load_documents(f) do |y|
+          y.each do |k, v|
+            opts["#{k}_ssh_default"] = v
+          end
+        end
+      end
+
+      opts
+    end
+
+    def parse_scenario(scen_file, options)
+      # parse default ssh file
+      opts = parse_default_ssh(options)
+      opts.merge!(options)
+
+      scen = Scenario.new
+
+      # no use scenario file
+      if opts['host']
+        scen << build_no_scenario_node_operation(opts)
+        return scen
+      end
+
+      type = [:main, :node_info, :tasks]
+      scenario_data = {}
+
+      if scen_file
+        YAML.load_documents(scen_file).each_with_index do |data, idx|
+          scenario_data[type[idx]] = data
+        end
+      end
+
+      node = nil
+
+      # use scenario file
+      scenario_data[:main].each do |n|
+        scen << node if node
+
+        n.each do |k, v|
+          if k == 'node'
+            node = Node.new(
+              v,
+              build_backend(v, scenario_data[:node_info], opts))
+          else
+            ope = build_operations(k, v, scenario_data[:tasks], opts)
+            node.add_operation(ope) if node
+          end
+        end
+      end
+
+      scen << node if node
+      scen
+    end
+
+    def build_no_scenario_node_operation(options)
+      raise CommandArgNotFoundError, %("--command or -c" option is not specified.) unless options['command']
+
+      node_info = { options['host'] => { 'ssh_opts' => {} } }
+
+      %w(user key port ssh_config ask_password sudo).each { |o| node_info[options['host']]['ssh_opts'][o] = options[o] if options[o]  }
+
+      node = Node.new(options['host'], build_backend(options['host'], node_info, options))
+      node.add_operation(Rundock::OperationFactory.instance(:command).create(Array(options['command']), nil))
+      node
+    end
+
+    def build_operations(ope_type, ope_content, tasks, options)
+      if options['command']
+        Logger.debug(%("--command or -c" option is specified and ignore scenario file.))
+        return Rundock::OperationFactory.instance(:command).create(Array(options['command']), nil)
+      end
+
+      Rundock::OperationFactory.instance(ope_type.to_sym).create(Array(ope_content), tasks)
+    end
+
+    def build_backend(host, node_info, options)
+      opts = {}
+
+      if !node_info ||
+         !node_info[host]
+        node_info = { host => {} }
+      end
+      node_info[host]['ssh_opts'] = {} unless node_info[host]['ssh_opts']
+      is_local = host =~ /localhost|127\.0\.0\.1/
+
+      # replace default ssh options if exists
+      options.keys.select { |o| o =~ /(\w+)_ssh_default$/ }.each do |oo|
+        opt = oo.gsub(/_ssh_default/, '')
+        # no use default ssh options if local
+        # (like docker or localhost with port access host should not use default ssh options)
+        node_info[host]['ssh_opts'][opt] = options[oo] if !is_local && !node_info[host]['ssh_opts'][opt]
+      end
+
+      if is_local &&
+         !node_info[host]['ssh_opts']['port'] &&
+         !node_info[host]['ssh_opts']['user'] &&
+         !node_info[host]['ssh_opts']['ssh_config']
+        backend_type = :local
+      else
+        backend_type = :ssh
+        opts['host'] = host
+      end
+
+      opts.merge!(options)
+
+      # update ssh options for node from node_info
+      opts.merge!(node_info[host]['ssh_opts'])
+      # delete trash ssh_options(node[host::ssh_options])
+      node_info[host].delete('ssh_opts')
+
+      # add any attributes for host from node_info
+      opts.merge!(node_info[host])
+      Backend.create(backend_type, opts)
+    end
+  end
+end

data/lib/rundock/scenario.rb

@@ -0,0 +1,7 @@
+module Rundock
+  class Scenario < Array
+    def run
+      self.each(&:run)
+    end
+  end
+end

data/lib/rundock/version.rb

@@ -0,0 +1,3 @@
+module Rundock
+  VERSION = '0.1.0'
+end

data/lib/rundock.rb

@@ -0,0 +1,17 @@
+require 'rundock/version'
+require 'rundock/ext/object/blank'
+require 'rundock/ext/hash'
+require 'rundock/logger'
+require 'rundock/operation/base'
+require 'rundock/operation/task'
+require 'rundock/operation/command'
+require 'rundock/operation_factory'
+require 'rundock/node'
+require 'rundock/scenario'
+require 'rundock/backend'
+require 'rundock/runner'
+require 'rundock/cli'
+
+module Rundock
+  # Your code goes here...
+end

data/rundock.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rundock/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rundock'
+  spec.version       = Rundock::VERSION
+  spec.authors       = ['hiracy']
+  spec.email         = ['leizhen@mbr.nifty.com']
+
+  spec.summary       = 'Simple Execution framework for various servers'
+  spec.homepage      = 'https://github.com/hiracy/rundock'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.9'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'serverspec', '~> 2.1'
+  spec.add_development_dependency 'rubocop'
+
+  spec.add_runtime_dependency 'specinfra', ['>= 2.31.0', '< 3.0.0']
+  spec.add_runtime_dependency 'ansi'
+  spec.add_runtime_dependency 'thor'
+  spec.add_runtime_dependency 'net-ssh'
+end

data/scenario_sample.yml

@@ -0,0 +1,53 @@
+#
+# This file is example of rundock scenario file based on yaml format.
+#
+# -------------------------------------------------------------------
+# ###  scenario section  ###
+# - node: <nodename>
+#   <taskname>:
+#     - <task detail>
+#     - :
+#   <taskname>:
+#     - <task detail>
+#     - :
+# - node: <nodename>
+#   :
+# ---
+# ###  host information section  ###
+# <hostname>:
+#   host: xxx.xxx.xxx.xxx
+#   <other_attributes>:
+#     :
+# <hostname>:
+#   :
+# ---
+# ###  task information section  ###
+# <taskname>:
+#   - "<actual command>"
+#   - :
+# <taskname>:
+#   :
+# -------------------------------------------------------------------
+#
+
+- node: 127.0.0.1
+  command:
+    - "hostname"
+    - "uname -a"
+- node: anyhost-01
+  task:
+    - echo_platform
+    - echo_users
+---
+anyhost-01:
+  host: 192.168.1.11
+  ssh_opts:
+    port: 22
+    user: anyuser
+---
+echo_platform:
+  - "hostname"
+  - "uname -a"
+echo_users:
+  - "whoami"
+  - "w"

data/spec/integration/platforms/centos6/Dockerfile

@@ -0,0 +1,16 @@
+FROM centos:6
+
+RUN yum install -y yum install openssh openssh-server openssh-clients sudo
+RUN useradd tester
+RUN echo "tester" | passwd --stdin tester
+RUN mkdir -p /home/tester/.ssh; chown tester /home/tester/.ssh; chmod 700 /home/tester/.ssh
+ADD authorized_keys /home/tester/.ssh/
+RUN chown tester /home/tester/.ssh/authorized_keys; chmod 600 /home/tester/.ssh/authorized_keys
+RUN echo "tester    ALL=(ALL)       ALL" >> /etc/sudoers.d/tester
+RUN sed -ri 's/UsePAM yes/#UsePAM yes/g' /etc/ssh/sshd_config
+RUN sed -ri 's/#UsePAM no/UsePAM no/g' /etc/ssh/sshd_config
+RUN sed -ri 's/PasswordAuthentication yes/PasswordAuthentication no/g' /etc/ssh/sshd_config
+RUN /etc/init.d/sshd start
+RUN /etc/init.d/sshd stop
+
+CMD /usr/sbin/sshd -D

data/spec/integration/platforms/centos6/setup.sh

@@ -0,0 +1,78 @@
+#!/bin/sh
+
+set -e
+PROJECT_ROOT="spec/integration"
+PROJECT_NAME=rundock_spec
+PLATFORM_NAME=centos6
+PLATFORM_DIR="${PROJECT_ROOT}/platforms/${PLATFORM_NAME}"
+DOCKER_IMAGE_NAME="${PROJECT_NAME}/${PLATFORM_NAME}"
+DOCKER_CACHE_DIR="${HOME}/docker"
+DOCKER_CACHE_IMAGE_PATH="${DOCKER_CACHE_DIR}/${PLATFORM_NAME}.tar"
+DOCKER_SSH_PORT=22222
+DOCKER_SSH_USER=tester
+DOCKER_SSH_KEY_PRIVATE="${HOME}/.ssh/id_rsa_${PROJECT_NAME}_${PLATFORM_NAME}_tmp"
+DOCKER_SSH_KEY_PUBLIC_LOCAL="${HOME}/.ssh/id_rsa_${PROJECT_NAME}_${PLATFORM_NAME}_tmp.pub"
+DOCKER_SSH_KEY_PUBLIC_REMOTE="${PLATFORM_DIR}/authorized_keys"
+DOCKER_SSH_CONFIG="${HOME}/.ssh/config_${PROJECT_NAME}_${PLATFORM_NAME}"
+RUNDOCK_SCENARIO_DIR="${PROJECT_ROOT}/scenarios"
+RUNDOCK_CACHE_DIR="${HOME}/.rundock/${PLATFORM_NAME}"
+RUNDOCK_DEFAULT_SSH_YML="${RUNDOCK_CACHE_DIR}/integration_default_ssh.yml"
+RUNDOCK_SCENARIO_CACHE_DIR="${RUNDOCK_CACHE_DIR}/scenarios"
+
+if [ "${1}x" = "--cleanx" ];then
+  if sudo docker ps | grep "${DOCKER_IMAGE_NAME}" > /dev/null; then
+    rm -f "${DOCKER_CACHE_IMAGE_PATH}"
+    rm -f "${DOCKER_SSH_KEY_PRIVATE}"
+    rm -f "${DOCKER_SSH_KEY_PUBLIC_LOCAL}"
+    rm -f "${DOCKER_SSH_CONFIG}"
+    rm -f ${DOCKER_SSH_KEY_PUBLIC_REMOTE}
+    set +x
+    sudo docker ps -q | xargs sudo docker rm -f
+  fi
+
+  exit 0
+fi
+
+mkdir -p "${RUNDOCK_SCENARIO_CACHE_DIR}"
+
+if [ ! -f ${RUNDOCK_DEFAULT_SSH_YML} ]; then
+(
+cat << EOP
+:port: ${DOCKER_SSH_PORT}
+:paranoid: false
+:user: "${DOCKER_SSH_USER}"
+:keys: ["${DOCKER_SSH_KEY_PRIVATE}"]
+EOP
+) > ${RUNDOCK_DEFAULT_SSH_YML}
+fi
+
+cp ${RUNDOCK_SCENARIO_DIR}/* ${RUNDOCK_SCENARIO_CACHE_DIR}
+
+find ${RUNDOCK_SCENARIO_CACHE_DIR} -type f -name "*_scenario.yml" | \
+  xargs sed -i -e "s#<replaced_by_platforms>#${DOCKER_SSH_KEY_PRIVATE}#g"
+
+sudo docker ps | grep "${DOCKER_IMAGE_NAME}" && { echo "docker image is already standing."; exit 0; }
+
+yes | ssh-keygen -N "" -t rsa -f ${DOCKER_SSH_KEY_PRIVATE}
+cp ${DOCKER_SSH_KEY_PUBLIC_LOCAL} ${DOCKER_SSH_KEY_PUBLIC_REMOTE}
+
+if sudo docker ps | grep "${DOCKER_IMAGE_NAME}" > /dev/null 2>&1; then
+  sudo docker ps -q | xargs sudo docker rm -f > /dev/null
+fi
+
+if file ${DOCKER_CACHE_IMAGE_PATH} | grep empty; then
+  sudo docker load --input ${DOCKER_CACHE_IMAGE_PATH}
+fi
+
+sudo docker build -t "${DOCKER_IMAGE_NAME}" ${PLATFORM_DIR}
+rm -f ${DOCKER_SSH_KEY_PUBLIC_REMOTE}
+mkdir -p ${DOCKER_CACHE_DIR}
+sudo docker save "${DOCKER_IMAGE_NAME}" > ${DOCKER_CACHE_IMAGE_PATH}
+sudo docker run -d --privileged -p ${DOCKER_SSH_PORT}:22 "${DOCKER_IMAGE_NAME}"
+
+echo "Host ${PLATFORM_NAME}"                          >  $DOCKER_SSH_CONFIG
+echo "        HostName 127.0.0.1"                     >> $DOCKER_SSH_CONFIG
+echo "        User     ${DOCKER_SSH_USER}"            >> $DOCKER_SSH_CONFIG
+echo "        Port     ${DOCKER_SSH_PORT}"            >> $DOCKER_SSH_CONFIG
+echo "        IdentityFile ${DOCKER_SSH_KEY_PRIVATE}" >> $DOCKER_SSH_CONFIG
+echo "        StrictHostKeyChecking no"               >> $DOCKER_SSH_CONFIG

data/spec/integration/platforms/localhost/scenarios/simple_echo_scenario.yml

@@ -0,0 +1,9 @@
+- node: localhost
+  command:
+    - "rm -f /var/tmp/hello_rundock_from_scenario"
+  task:
+    - write_echo
+---
+---
+write_echo:
+  - "echo 'Hello Rundock from Scenario.' > /var/tmp/hello_rundock_from_scenario"

data/spec/integration/platforms/localhost/scenarios/use_default_ssh_scenario.yml

@@ -0,0 +1,4 @@
+- node: localhost
+  command:
+    - "hostname"
+    - "uname -a"

data/spec/integration/recipes/simple_echo_scenario_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe file('/var/tmp/hello_rundock') do
+  it { should be_file }
+  its(:content) { should match(/Hello Rundock./) }
+end

data/spec/integration/recipes/simple_echo_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe file('/var/tmp/hello_rundock_from_scenario') do
+  it { should be_file }
+  its(:content) { should match(/Hello Rundock from Scenario./) }
+end

data/spec/integration/scenarios/simple_echo_scenario.yml

@@ -0,0 +1,33 @@
+- node: localhost
+  command:
+    - "rm -f /var/tmp/hello_rundock_from_scenario"
+    - "echo 'Hello Rundock from Scenario.' > /var/tmp/hello_rundock_from_scenario"
+- node: anyhost-01
+  task:
+    - echo_platform
+  command:
+    - "hostname"
+- node: anyhost-02
+  command:
+    - "uname -a"
+  task:
+    - write_echo
+---
+anyhost-01:
+  host: 127.0.0.1
+  ssh_opts:
+    port: 22222
+    user: tester
+    key: "<replaced_by_platforms>"
+anyhost-02:
+  host: "127.0.0.1"
+  ssh_opts:
+    port: 22222
+    user: tester
+    keys: ["<replaced_by_platforms>"]
+---
+echo_platform:
+  - "hostname"
+  - "uname -a"
+write_echo:
+  - "echo 'Hello Rundock from Scenario.' > /var/tmp/hello_rundock_from_scenario"

data/spec/integration/scenarios/use_default_ssh_scenario.yml

@@ -0,0 +1,4 @@
+- node: localhost
+  command:
+    - "hostname"
+    - "uname -a"