ajimi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f13196aaa42aa1ee9ffa66c1cb2d981301913299
+  data.tar.gz: edc36ca1ec66ad4ee23c3d0589c17e8b48aaef8e
+SHA512:
+  metadata.gz: afb2e37b084b8ac498f5d0b2326d06b238f92d0912b09e6d8b811e1281e304d581fb6a4e578dbbf000d64e0139155d361aa902b0492266bcc97e2e96d9095b2a
+  data.tar.gz: e3d1c6e525954f974d5f382445aa1b26eece64c80ef63a6bf0dcecf3299d7262f88a683729b9099a2cddc41104217656ca88c34e409fbf3e9cbc47bf72a8e7ab

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+Ajimifile

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.4
+before_install: gem install bundler -v 1.10.5

data/Ajimifile.sample

@@ -0,0 +1,50 @@
+# Ajimi configuration file
+
+# source setting
+source "source.example.com", {
+  ssh_options: {
+    host: "192.168.0.1",
+    user: "ec2-user",
+    key: "~/.ssh/id_rsa"
+  },
+  enable_nice: true
+}
+
+# target setting
+target "target.example.com", {
+  ssh_options: {
+    user: "ec2-user",
+    key: "~/.ssh/id_rsa"
+  },
+  enable_nice: false
+}
+
+# check setting
+check_root_path "/"
+
+pruned_paths [
+  "/dev",
+  "/proc",
+]
+
+ignored_paths [
+  *@config[:pruned_paths],
+  %r|^/lost\+found/?.*|,
+  %r|^/media/?.*|,
+  %r|^/mnt/?.*|,
+  %r|^/run/?.*|,
+  %r|^/sys/?.*|,
+  %r|^/tmp/?.*|
+]
+
+ignored_contents ({
+  "/root/.ssh/authorized_keys" => /Please login as the user \\"ec2-user\\" rather than the user \\"root\\"/
+})
+
+pending_paths [
+  "/etc/sudoers"
+]
+
+pending_contents ({
+  "/etc/hosts" => /127\.0\.0\.1/
+})

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,43 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Masayuki Morita
+
+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,256 @@
+# Ajimi
+
+Ajimi is a tool to compare servers by their files to shows difference in their configurations.
+It is useful to achieve some kind of a regression test against a server by finding unexpected changes to its configuration file after running Chef, Ansible, or your own provisioning tool.
+
+'Ajimi' means 'tasting' in Japanese. It was developed for originally replacing the existing server with the Chef's cookbook, but can be used for a general purpose of comparing two servers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ajimi'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ajimi
+
+## Configuration
+
+Generate a sample configuration file to current directory:
+
+    $ ajimi-init
+
+And then edit Ajimifile:
+
+    $ (Your favorite editor) ./Ajimifile
+
+A sample configuration looks like the following:
+
+```
+# Ajimi configuration file
+
+# source setting
+source "source.example.com", {
+  ssh_options: {
+    host: "192.168.0.1",
+    user: "ec2-user",
+    key: "~/.ssh/id_rsa"
+  },
+  enable_nice: true
+}
+
+# target setting
+target "target.example.com", {
+  ssh_options: {
+    user: "ec2-user",
+    key: "~/.ssh/id_rsa"
+  },
+  enable_nice: false
+}
+
+# check setting
+check_root_path "/"
+
+pruned_paths [
+  "/dev",
+  "/proc",
+]
+
+ignored_paths [
+  *@config[:pruned_paths],
+  %r|^/lost\+found/?.*|,
+  %r|^/media/?.*|,
+  %r|^/mnt/?.*|,
+  %r|^/run/?.*|,
+  %r|^/sys/?.*|,
+  %r|^/tmp/?.*|
+]
+
+ignored_contents ({
+  "/root/.ssh/authorized_keys" => /Please login as the user \\"ec2-user\\" rather than the user \\"root\\"/
+})
+
+pending_paths [
+  "/etc/sudoers"
+]
+
+pending_contents ({
+  "/etc/hosts" => /127\.0\.0\.1/
+})
+
+```
+
+The following arguments are supported in the Ajimifile:
+
+* `source` - String (Required), Hash (Required): Source server's name and options. Options are as follows.
+  * `ssh_options` - Hash (Required): SSH connection options
+      * `host` - String (Optional): SSH hostname, FQDN or IP address. Default is name of `source`.
+      * `user` - String (Required): SSH username.
+      * `key` - String (Required): Path to user's SSH secret key.
+    * `enable_nice` - Boolean (Optional): If true, the find process is wrapped by nice and ionice to lower load. Default is false. 
+* `target` - String (Required): Target server's name and options. Options are the same as source.
+* `check_root_path` - String (Required): Root path to check. If "/", Ajimi checks in the whole filesystem.
+* `pruned_paths` - Array[String|Regexp] (Optional): List of the path which should be excluded in the find process. Note that `pruned_paths` is better performance than `ignored_paths`/`pending_paths`.
+* `ignored_paths` - Array[String|Regexp] (Optional): List of the path which should be ignored as known difference.
+* `ignored_contents` - Hash{String => String|Regexp} (Optional): Hash of the path => pattern which should be ignored as known difference for each of the content.
+* `pending_paths`- Array[String|Regexp] (Optional): List of the path which should be resolved later but ignored temporarily as known difference.
+* `pending_contents` - Hash{String => String|Regexp} (Optional): Hash of the path => pattern which should be resolved later but ignored temporarily as known difference for each of the content.
+
+## Usage
+
+Ajimi is a single command-line application: `ajimi`.
+It takes a subcommand such as `check` or `exec`.
+To view a list of the available commands , just run `ajimi` with no arguments:
+
+```
+$ ajimi
+Commands:
+  ajimi check                         # Show differences between the source and the target server
+  ajimi dir <path>                    # Show differences between the source and the target server in the specified directory
+  ajimi exec source|target <command>  # Execute an arbitrary command on the source or the target server
+  ajimi file <path>                   # Show differences between the source and the target server in the specified file
+  ajimi help [COMMAND]                # Describe available commands or one specific command
+
+Options:
+  [--ajimifile=AJIMIFILE]      # Ajimifile path
+                               # Default: ./Ajimifile
+  [--verbose], [--no-verbose]
+                               # Default: true
+```
+
+After setting your Ajimifle, Run the following command in order to verify the SSH connection:
+
+    $ ajimi exec source hostname
+    $ ajimi exec target hostname
+    
+And then, first ajimi check with `--find-max-depth` option:
+
+    $ ajimi check --find-max-depth=3 > ajimi.log
+
+Check the diffs report in ajimi.log, and add roughly unnecessary paths to `pruned_paths` in Ajimifile.
+
+Next, gradually increasing `find-max-depth=4, 5, ...`,
+
+    $ ajimi check --find-max-depth=4 > ajimi.log
+
+Add known differences to `ignored_paths` or `pending_paths`.
+
+After checking the difference of paths, then check the contents of files where the difference has been reported:
+
+    $ ajimi check --enable-check-contents > ajimi.log
+
+Add known differences to `ignored_contents` or `pending_contents`,
+and repeat until the number of lines of diffs report becomes human-readable.
+
+Finally, resolve issues and remove `pending_paths` or `pending_contents`.
+
+## Command reference
+
+```
+$ ajimi
+Commands:
+  ajimi check                         # Show differences between the source and the target server
+  ajimi dir <path>                    # Show differences between the source and the target server in the specified directory
+  ajimi exec source|target <command>  # Execute an arbitrary command on the source or the target server
+  ajimi file <path>                   # Show differences between the source and the target server in the specified file
+  ajimi help [COMMAND]                # Describe available commands or one specific command
+
+Options:
+  [--ajimifile=AJIMIFILE]      # Ajimifile path
+                               # Default: ./Ajimifile
+  [--verbose], [--no-verbose]
+                               # Default: true
+```
+
+```
+$ ajimi help check
+Usage:
+  ajimi check
+
+Options:
+  [--check-root-path=CHECK_ROOT_PATH]
+  [--find-max-depth=N]
+  [--enable-check-contents], [--no-enable-check-contents]
+  [--limit-check-contents=N]
+                                                           # Default: 0
+  [--ajimifile=AJIMIFILE]                                  # Ajimifile path
+                                                           # Default: ./Ajimifile
+  [--verbose], [--no-verbose]
+                                                           # Default: true
+
+Show differences between the source and the target server
+```
+
+```
+$ ajimi help dir
+Usage:
+  ajimi dir <path>
+
+Options:
+  [--find-max-depth=N]
+                                       # Default: 1
+  [--ignored-pattern=IGNORED_PATTERN]
+  [--ajimifile=AJIMIFILE]              # Ajimifile path
+                                       # Default: ./Ajimifile
+  [--verbose], [--no-verbose]
+                                       # Default: true
+
+Show differences between the source and the target server in the specified directory
+```
+
+```
+$ ajimi help file
+Usage:
+  ajimi file <path>
+
+Options:
+  [--ignored-pattern=IGNORED_PATTERN]
+  [--ajimifile=AJIMIFILE]              # Ajimifile path
+                                       # Default: ./Ajimifile
+  [--verbose], [--no-verbose]
+                                       # Default: true
+
+Show differences between the source and the target server in the specified file
+```
+
+```
+$ ajimi help exec
+Usage:
+  ajimi exec source|target <command>
+
+Options:
+  [--ajimifile=AJIMIFILE]      # Ajimifile path
+                               # Default: ./Ajimifile
+  [--verbose], [--no-verbose]
+                               # Default: true
+
+Execute an arbitrary command on the source or the target server
+```
+
+## Development and Test
+
+    $ bundle install
+    $ bundle exec ajimi-init
+    (Implement some feature)
+    $ bundle exec rake spec
+
+## 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
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/ajimi.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ajimi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ajimi"
+  spec.version       = Ajimi::VERSION
+  spec.authors       = ["Masayuki Morita"]
+  spec.email         = ["masayuki.morita@crowdworks.co.jp"]
+
+  spec.summary       = %q{server diff tool}
+  spec.description   = %q{Ajimi is a tool to compare servers by their files to shows difference in their configurations. It is useful to achieve some kind of a regression test against a server by finding unexpected changes to its configuration file after running Chef, Ansible, or your own provisioning tool.}
+  spec.homepage      = "https://github.com/crowdworks/ajimi"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "net-ssh", "~> 2.0"
+  spec.add_runtime_dependency "diff-lcs"
+  spec.add_runtime_dependency "thor"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "guard-rspec", "~> 4.0"
+  spec.add_development_dependency "terminal-notifier-guard"
+
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ajimi"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/ajimi

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'ajimi'
+
+STDOUT.sync = true
+Ajimi::Client.start

data/exe/ajimi-init

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+src = File.expand_path('../../Ajimifile.sample', __FILE__)
+dst = "./Ajimifile"
+
+puts "copy: #{src} -> #{dst}"
+FileUtils.cp(src, dst)

data/lib/ajimi.rb

@@ -0,0 +1,6 @@
+require "ajimi/version"
+require 'ajimi/config'
+require 'ajimi/client'
+require 'ajimi/checker'
+require 'ajimi/reporter'
+require 'ajimi/server'

data/lib/ajimi/checker.rb

@@ -0,0 +1,210 @@
+require 'diff/lcs'
+
+module Ajimi
+  class Checker
+    attr_accessor :diffs, :result, :source, :target, :diff_contents_cache, :enable_check_contents
+
+    def initialize(config)
+      @config = config
+      @source = @config[:source]
+      @target = @config[:target]
+      @check_root_path = @config[:check_root_path]
+      @pruned_paths = @config[:pruned_paths] || []
+      @ignored_paths = @config[:ignored_paths] || []
+      @ignored_contents = @config[:ignored_contents] || {}
+      @pending_paths = @config[:pending_paths] || []
+      @pending_contents = @config[:pending_contents] || {}
+      @enable_check_contents = @config[:enable_check_contents] || false
+      @limit_check_contents = @config[:limit_check_contents] || 0
+      @find_max_depth = @config[:find_max_depth]
+      @verbose = @config[:verbose] || false
+    end
+    
+    def check
+      puts_verbose "Start ajimi check with options: #{@config}\n"
+
+      puts_verbose "Finding...: #{@source.host}\n"
+      @source_find = @source.find(@check_root_path, @find_max_depth, @pruned_paths)
+
+      puts_verbose "Finding...: #{@target.host}\n"
+      @target_find = @target.find(@check_root_path, @find_max_depth, @pruned_paths)
+
+      puts_verbose "Checking diff entries...\n"
+      @diffs = diff_entries(@source_find, @target_find)
+
+      puts_verbose "Checking ignored_paths and pending_paths...\n"
+      @diffs = filter_ignored_and_pending_paths(@diffs, @ignored_paths, @pending_paths)
+
+      if @enable_check_contents
+        puts_verbose "Checking ignored_contents and pending_contents...\n"
+        @diffs = filter_ignored_and_pending_contents(@diffs, @ignored_contents, @pending_contents, @limit_check_contents)
+      end
+
+      puts_verbose "Diffs empty?: #{@diffs.empty?}\n"
+      puts_verbose "\n"
+
+      @result = @diffs.empty?
+    end
+
+    def puts_verbose(message)
+      puts message if @config[:verbose]
+    end
+
+    def diff_entries(source_find, target_find)
+      diffs = ::Diff::LCS.diff(source_find, target_find)
+      diffs.map do |diff|
+        diff.map do |change|
+          ::Diff::LCS::Change.new(
+            change.action,
+            change.position,
+            Ajimi::Server::Entry.parse(change.element)
+          )
+        end
+      end
+    end
+
+    def filter_ignored_and_pending_paths(diffs, ignored_paths, pending_paths)
+      if !ignored_paths.empty?
+        @ignored_by_path = filter_paths(diffs, ignored_paths)
+        diffs = remove_entry_from_diffs(diffs, @ignored_by_path)
+      end
+      
+      if !pending_paths.empty?
+        @pending_by_path = filter_paths(diffs, pending_paths)
+        diffs = remove_entry_from_diffs(diffs, @pending_by_path)
+      end
+      diffs
+    end
+
+    def filter_paths(diffs, filter_paths = [])
+      filtered = []
+      union_regexp_pattern = Regexp.union(filter_paths)
+      diffs.each do |diff|
+        diff.each do |change|
+          filtered <<  change.element.path if change.element.path.match union_regexp_pattern
+        end
+      end
+      filtered.uniq.sort
+    end
+
+    def filter_ignored_and_pending_contents(diffs, ignored_contents, pending_contents, limit_check_contents)
+      @ignored_by_content = []
+      @pending_by_content = []
+      @diff_contents_cache = ""
+  
+      diff_files = product_set_file_paths(diffs)
+      diff_files = diff_files.slice(0, limit_check_contents) if limit_check_contents > 0
+      diff_files.each do |file|
+        diff_file_result = diff_file(file)
+        ignored_diff_file_result = filter_diff_file(diff_file_result, ignored_contents[file])
+        if ignored_diff_file_result.flatten.empty?
+          @ignored_by_content << file
+        else
+          pending_diff_file_result = filter_diff_file(ignored_diff_file_result, pending_contents[file])
+          if pending_diff_file_result.flatten.empty?
+            @pending_by_content << file
+          else
+            @diff_contents_cache << "--- #{@source.host}: #{file}\n"
+            @diff_contents_cache << "+++ #{@target.host}: #{file}\n"
+            @diff_contents_cache << "\n"
+            pending_diff_file_result.each do |diff|
+              diff.map do |change|
+                @diff_contents_cache << change.action + " " + change.position.to_s + " " + change.element.to_s + "\n"
+              end
+            end
+          end
+        end
+      end
+      diffs = remove_entry_from_diffs(diffs, @ignored_by_content + @pending_by_content)
+    end
+
+    def uniq_diff_file_paths(diffs)
+      return [] if diffs.flatten.empty?
+      diff_file_paths = []
+      diffs.each do |diff|
+        diff.each do |change|
+          diff_file_paths << change.element.path if change.element.file?
+        end
+      end
+      diff_file_paths.uniq.sort
+    end
+
+    def split_diff_file_paths(diffs)
+      return [],[] if diffs.flatten.empty?
+      minus = []
+      plus = []
+      diffs.each do |diff|
+        diff.each do |change|
+          minus << change.element.path if change.action == "-" && change.element.file?
+          plus << change.element.path if change.action == "+" && change.element.file?
+        end
+      end
+      return minus, plus
+    end
+    
+    def union_set_diff_file_paths(diffs)
+      minus, plus = split_diff_file_paths(diffs)
+      (minus | plus).sort
+    end
+
+    def product_set_file_paths(diffs)
+      minus, plus = split_diff_file_paths(diffs)
+      (minus & plus).sort
+    end
+
+    def diff_file(path)
+      source_file = @source.cat_or_md5sum(path)
+      target_file = @target.cat_or_md5sum(path)
+      diffs = ::Diff::LCS.diff(source_file, target_file)
+    end
+
+    def filter_diff_file(diffs, filter_pattern = nil)
+      if filter_pattern.nil?
+        diffs
+      else
+        diffs.map do |diff|
+          diff.reject do |change|
+            change.element.match filter_pattern
+          end
+        end
+      end
+    end
+
+    def remove_entry_from_diffs(diffs, remove_list)
+      diffs.map do |diff|
+        diff.reject do |change|
+          remove_list.include? change.element.path
+        end
+      end
+    end
+
+    def source_file_count
+      @source_find ? @source_find.count : 0
+    end
+
+    def target_file_count
+      @target_find ? @target_find.count : 0
+    end
+    
+    def ignored_by_path_file_count
+      @ignored_by_path ? @ignored_by_path.count : 0
+    end
+
+    def pending_by_path_file_count
+      @pending_by_path ? @pending_by_path.count : 0
+    end
+
+    def ignored_by_content_file_count
+      @ignored_by_content ? @ignored_by_content.count : 0
+    end
+
+    def pending_by_content_file_count
+      @pending_by_content ? @pending_by_content.count : 0
+    end
+
+    def diff_file_count
+      union_set_diff_file_paths(@diffs).count
+    end
+
+  end
+end

data/lib/ajimi/client.rb

@@ -0,0 +1,81 @@
+require 'thor'
+
+module Ajimi
+  class Client < Thor
+    attr_accessor :checker, :reporter
+
+    class_option :ajimifile, :default => './Ajimifile', :desc => "Ajimifile path"
+    class_option :verbose, :type => :boolean, :default => true
+
+    def initialize(*args)
+      super
+      @config = Ajimi::Config.load(options[:ajimifile])
+      @config[:verbose] = options[:verbose] unless options[:verbose].nil?
+    end
+
+    desc "check", "Show differences between the source and the target server"
+    option :check_root_path, :type => :string
+    option :find_max_depth, :type => :numeric
+    option :enable_check_contents, :type => :boolean, :default => false
+    option :limit_check_contents, :type => :numeric, :default => 0
+    def check
+      @config.merge!( {
+        find_max_depth: options[:find_max_depth],
+        enable_check_contents: options[:enable_check_contents],
+        limit_check_contents: options[:limit_check_contents]
+      } )
+      @config[:check_root_path] = options[:check_root_path] if options[:check_root_path]
+      _check
+    end
+
+    desc "dir <path>", "Show differences between the source and the target server in the specified directory"
+    option :find_max_depth, :type => :numeric, :default => 1
+    option :ignored_pattern, :type => :string
+    def dir(path)
+      @config.merge!( {
+        check_root_path: path,
+        find_max_depth: options[:find_max_depth],
+        enable_check_contents: false
+      } )
+      @config[:ignored_paths] << Regexp.new(options[:ignored_pattern]) if options[:ignored_pattern]
+
+      _check
+    end
+
+    desc "file <path>", "Show differences between the source and the target server in the specified file"
+    option :ignored_pattern, :type => :string
+    def file(path)
+      @config.merge!( {
+        check_root_path: path,
+        enable_check_contents: true
+      } )
+      @config[:ignored_contents].merge!( { path => Regexp.new(options[:ignored_pattern]) } ) if options[:ignored_pattern]
+
+      _check
+    end
+    
+    desc "exec source|target <command>", "Execute an arbitrary command on the source or the target server"
+    def exec(server, command)
+      raise ArgumentError, "server option must be source or target" unless %w(source target).include? server 
+
+      @server = @config[server.to_sym]
+      puts "Execute command at #{server}_host: #{@server.host}\n"
+      stdout = @server.command_exec(command)
+      puts "#{stdout}"
+      puts "\n"
+    end
+
+    private
+    
+    def _check
+      @checker ||= Checker.new(@config)
+      result = @checker.check
+
+      @reporter ||= Reporter.new(@checker)
+      @reporter.report
+      result
+    end
+    
+  end
+
+end

data/lib/ajimi/config.rb

@@ -0,0 +1,44 @@
+module Ajimi
+  class Config
+
+    attr_accessor :config
+
+    def initialize
+      @config = {}
+    end
+
+    def self.load(path)
+      Ajimi::Config.new.tap do |obj|
+        obj.load_file(path)
+      end.config
+    end
+
+    def load_file(path)
+      instance_eval(File.read(path), path) if path
+    end
+
+    CONFIG_KEYWORDS = %i(
+      source
+      target
+      check_root_path
+      pruned_paths
+      ignored_paths
+      ignored_contents
+      pending_paths
+      pending_contents
+    )
+
+    CONFIG_KEYWORDS.each do |keyword|
+      define_method(keyword) do |args|
+        @config[keyword] = args
+      end
+    end
+
+    %i| source target |.each do |server_role|
+      define_method server_role do |*args|
+        @config[server_role] = Ajimi::Server.new(*args)
+      end
+    end
+
+  end
+end

data/lib/ajimi/reporter.rb

@@ -0,0 +1,23 @@
+require 'erb'
+
+module Ajimi
+  class Reporter
+
+    def initialize(checker, report_template_path = nil)
+      @checker = checker
+      @report_template_path = report_template_path || File.expand_path('../reporter/template.erb', __FILE__)
+    end
+
+    def report
+      if @checker.result
+        puts "no diffs"
+        true
+      else
+        erb = File.read(@report_template_path)
+        puts ERB.new(erb, nil, '-').result(binding)
+        false
+      end
+    end
+
+  end  
+end

data/lib/ajimi/reporter/template.erb

@@ -0,0 +1,26 @@
+###### diff entries report ######
+--- <%= @checker.source.host %>
++++ <%= @checker.target.host %>
+
+<%- @checker.diffs.each do |diff| -%>
+  <%- diff.each do |change| -%>
+<%= "#{change.action} #{change.position} #{change.element}" %>
+  <%- end -%>
+<%- end -%>
+
+###### diff contents report ######
+<%- if @checker.enable_check_contents -%>
+<%= @checker.diff_contents_cache -%>
+<%- else -%>
+check_contents was skipped (enable_check_contents = false)
+<%- end -%>
+
+###### diff summary report ######
+source: <%= @checker.source_file_count %> files
+target: <%= @checker.target_file_count %> files
+ignored_by_path: <%= @checker.ignored_by_path_file_count %> files
+pending_by_path: <%= @checker.pending_by_path_file_count %> files
+ignored_by_content: <%= @checker.ignored_by_content_file_count %> files
+pending_by_content: <%= @checker.pending_by_content_file_count %> files
+diff: <%= @checker.diff_file_count %> files
+

data/lib/ajimi/server.rb

@@ -0,0 +1,68 @@
+require 'ajimi/server/ssh'
+require 'ajimi/server/entry'
+
+module Ajimi
+  class Server
+
+    def initialize(name, **options)
+      @name = name
+      @options = options
+      @options[:ssh_options] = options[:ssh_options] || {}
+      @options[:ssh_options][:host] = options[:ssh_options][:host] || @name
+    end
+
+    def ==(other)
+      self.instance_variable_get(:@name) == other.instance_variable_get(:@name)
+      self.instance_variable_get(:@options) == other.instance_variable_get(:@options)
+    end
+
+    def host
+      @options[:ssh_options][:host]
+    end
+
+    def backend
+      @backend ||= Ajimi::Server::Ssh.new(@options[:ssh_options])
+    end
+
+    def command_exec(cmd)
+      backend.command_exec(cmd)
+    end
+    
+    def find(dir, find_max_depth = nil, pruned_paths = [], enable_nice = nil)
+      enable_nice = @options[:enable_nice] if enable_nice.nil?
+      cmd = build_find_cmd(dir, find_max_depth, pruned_paths, enable_nice)
+      stdout = command_exec(cmd)
+      stdout.split(/\n/).map {|line| line.chomp }.sort
+    end
+
+    def entries(dir)
+      @entries ||= find(dir).map{ |line| Ajimi::Server::Entry.parse(line) }
+    end
+
+    def cat(file)
+      stdout = command_exec("sudo cat #{file}")
+      stdout.split(/\n/).map {|line| line.chomp }
+    end
+
+    def cat_or_md5sum(file)
+      stdout = command_exec("if (sudo file -b #{file} | grep text > /dev/null 2>&1) ; then (sudo cat #{file}) else (sudo md5sum #{file}) fi")
+      stdout.split(/\n/).map {|line| line.chomp }
+    end
+
+    private
+
+    def build_find_cmd(dir, find_max_depth  = nil, pruned_paths = [], enable_nice = false)
+      cmd = "sudo"
+      cmd += " nice -n 19 ionice -c 2 -n 7" if enable_nice
+      cmd += " find #{dir} -ls"
+      cmd += " -maxdepth #{find_max_depth}" if find_max_depth
+      cmd += build_pruned_paths_option(pruned_paths)
+      cmd += " | awk  '{printf \"%s, %s, %s, %s, %s\\n\", \$11, \$3, \$5, \$6, \$7}'"
+    end
+
+    def build_pruned_paths_option(pruned_paths = [])
+      pruned_paths.map{ |path| " -path #{path} -prune" }.join(" -o")
+    end
+
+  end
+end

data/lib/ajimi/server/entry.rb

@@ -0,0 +1,49 @@
+module Ajimi
+  class Server
+    class Entry
+      attr_accessor :path, :mode, :user, :group, :bytes
+      
+      def initialize(params)
+        @path = params[:path]
+        @mode = params[:mode]
+        @user = params[:user]
+        @group = params[:group]
+        @bytes = params[:bytes]
+      end
+      
+      def ==(other)
+        self.path == other.path &&
+        self.mode == other.mode &&
+        self.user == other.user &&
+        self.group == other.group &&
+        self.bytes == other.bytes
+      end
+      
+      def to_s
+        "#{@path}, #{@mode}, #{@user}, #{@group}, #{@bytes}"
+      end
+
+      def dir?
+        @mode[0] == "d"
+      end
+
+      def file?
+        @mode[0] == "-"
+      end
+      
+      class << self
+        def parse(line)
+          path, mode, user, group, bytes = line.chomp.split(', ')
+          Ajimi::Server::Entry.new(
+            path: path,
+            mode: mode,
+            user: user,
+            group: group,
+            bytes: bytes
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/ajimi/server/ssh.rb

@@ -0,0 +1,37 @@
+require 'net/ssh'
+
+module Ajimi
+  class Server
+    class Ssh
+      def initialize(options = {})
+        @host = options[:host]
+        @user = options[:user]
+        @key = options[:key]
+      end
+
+      def net_ssh
+        Net::SSH
+      end
+      
+      def command_exec(cmd)
+        ssh_options_default = {}
+        ssh_options_override = {
+          keys: @key
+        }
+        ssh_options = ssh_options_default.merge(ssh_options_override)
+
+        stdout = ""
+        stderr = ""
+        net_ssh.start(@host, @user, ssh_options) do |session|
+          session.exec!(cmd) do |channel, stream, data|
+            stdout << data if stream == :stdout
+            stderr << data if stream == :stderr
+          end
+        end
+        $stderr.puts stderr unless stderr == ""
+        stdout
+      end
+
+    end
+  end
+end

data/lib/ajimi/version.rb

@@ -0,0 +1,3 @@
+module Ajimi
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: ajimi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Masayuki Morita
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: diff-lcs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier-guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ajimi is a tool to compare servers by their files to shows difference
+  in their configurations. It is useful to achieve some kind of a regression test
+  against a server by finding unexpected changes to its configuration file after running
+  Chef, Ansible, or your own provisioning tool.
+email:
+- masayuki.morita@crowdworks.co.jp
+executables:
+- ajimi
+- ajimi-init
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Ajimifile.sample
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ajimi.gemspec
+- bin/console
+- bin/setup
+- exe/ajimi
+- exe/ajimi-init
+- lib/ajimi.rb
+- lib/ajimi/checker.rb
+- lib/ajimi/client.rb
+- lib/ajimi/config.rb
+- lib/ajimi/reporter.rb
+- lib/ajimi/reporter/template.erb
+- lib/ajimi/server.rb
+- lib/ajimi/server/entry.rb
+- lib/ajimi/server/ssh.rb
+- lib/ajimi/version.rb
+homepage: https://github.com/crowdworks/ajimi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: server diff tool
+test_files: []