hocho 0.1.0.beta1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f40a1aecd4cf8840d456cf93fdd5523910c0187
-  data.tar.gz: ee1d577aaae256bffa0b2f94ca66539b4db941eb
+  metadata.gz: 71a35bcabdd7fb28b6ddcde2093f7cdde9ddcafa
+  data.tar.gz: f4ac549145b6940d4bef0ade7b3338d3f89f2028
 SHA512:
-  metadata.gz: ba38f1f5837dd7095c8f78bc06d2adcd50f7a281ca96008704816bd0d9a5e03579ffca9c0ed70cf02fd102097e8f61e2a31829d9318728922969fd0481b71c8a
-  data.tar.gz: c5dd335f31ee64c2a51ddf7bfbabd341436efa8e43b63db30c6a67563904991692ecd4db9552d88f17f1240b4a8bc3b64a2747d6043ad1508e12d2d93bc32fbf
+  metadata.gz: c5e35fb5d3d3263ae7fab63fb51d846ba3ce5bb41421dd43f8731dd256081f0e712f11c192aef676140ab8801adfc558927a71574fa5b32b5f7ef29f29dd2bd7
+  data.tar.gz: 82ecb70f5dbb71f3be59e3d5dd9c42e9c4d733604038d8d296eb94e2795e629dc779ede9de00df8ccf28efce72827ccdb4550d82854391c1ca06b3e929f49b97

data/README.md

@@ -4,14 +4,15 @@ Hocho is a wrapper of the provisioning tool [itamae](https://github.com/itamae-k
 
 ## Features
 
-- `itamae ssh` support
-- remote `itamae local` support on rsync+bundler
+- Drivers
+  - `itamae ssh` support
+  - remote `itamae local` support on rsync+bundler
+  - remote `mitamae` support
 - Simple pluggable host inventory, discovery
 
-## vs. other softwares
-
 ## Installation
 
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -33,14 +34,24 @@ Or install it yourself as:
 inventory_providers:
   file:
     path: './hosts'
+property_providers:
+  - add_default:
+      properties:
+        blah: blahblah
+        # preferred_driver: mitamae
+# driver_options:
+#   mitamae:
+#     mitamae_prepare_script: 'wget -O /usr/local/bin/mitamae https://...'
 ```
 
-```
+``` yaml
 # ./hosts/test.yml
 test.example.org:
   # ssh_options:
   #   user: ...
   properties:
+    # preferred_driver: bundler
+    # preferred_driver: mitamae
     run_list:
       - roles/app/default.rb
 ```

data/lib/hocho/command.rb

@@ -17,9 +17,6 @@ module Hocho
       hosts = inventory.hosts
 
       if options[:verbose]
-        hosts.each do |host|
-          config.property_providers.each { |_| _.determine(host) }
-        end
         case options[:format]
         when 'yaml'
           puts hosts.map(&:to_h).to_yaml
@@ -82,7 +79,7 @@ module Hocho
     private
 
     def inventory
-      @inventory ||= Hocho::Inventory.new(config.inventory_providers)
+      @inventory ||= Hocho::Inventory.new(config.inventory_providers, config.property_providers)
     end
 
     def config

data/lib/hocho/drivers/base.rb

@@ -17,6 +17,9 @@ module Hocho
         raise NotImplementedError
       end
 
+      def finalize
+      end
+
       def run_list
         [*initializers, *host.run_list]
       end

data/lib/hocho/drivers/bundler.rb

@@ -3,35 +3,22 @@ require 'hocho/drivers/ssh_base'
 module Hocho
   module Drivers
     class Bundler < SshBase
-      def initialize(host, base_dir: '.', initializers: [], itamae_options: [], bundle_without: [], bundle_path: nil, deploy_dir: nil, keep_synced_files: nil)
+      def initialize(host, base_dir: '.', initializers: [], itamae_options: [], bundle_without: [], bundle_path: nil, deploy_options: {})
         super host, base_dir: base_dir, initializers: initializers
 
         @itamae_options = itamae_options
         @bundle_without = bundle_without
         @bundle_path = bundle_path
-        @deploy_dir = deploy_dir
-        @keep_synced_files = keep_synced_files
-      end
-
-      def keep_synced_files?
-        @keep_synced_files
+        @deploy_options = deploy_options
       end
 
       def run(dry_run: false)
-        deploy
-        bundle_install
-        run_itamae(dry_run: dry_run)
-      ensure
-        cleanup
+        deploy(**@deploy_options) do
+          bundle_install
+          run_itamae(dry_run: dry_run)
+        end
       end
 
-      def deploy
-        ssh_cmd = ['ssh', *host.openssh_config.flat_map { |l| ['-o', "\"#{l}\""] }].join(' ')
-        rsync_cmd = [*%w(rsync -az --copy-links --copy-unsafe-links --delete --exclude=.git), '--rsh', ssh_cmd, '.', "#{host.hostname}:#{host_basedir}"]
-
-        puts "=> $ #{rsync_cmd.inspect}"
-        system(*rsync_cmd, chdir: base_dir) or raise 'failed to rsync'
-      end
 
       def bundle_install
         bundle_path_env = @bundle_path ? "BUNDLE_PATH=#{@bundle_path.shellescape} " : nil
@@ -46,12 +33,7 @@ module Hocho
           puts "=> #{host.name} # #{bundle_install.shelljoin}"
 
           ssh_run("bash") do |c|
-            c.on_data do |c, data|
-              puts "[#{host.name}] #{data}"
-            end
-            c.on_extended_data do |c, _, data|
-              puts "[#{host.name}/ERR] #{data}"
-            end
+            set_ssh_output_hook(c)
 
             c.send_data("cd #{host_basedir.shellescape}\n#{sudovars}\n#{sudocmd}#{bundle_install.shelljoin}\n")
             c.eof!
@@ -69,12 +51,7 @@ module Hocho
           prepare_sudo do |sh, sudovars, sudocmd|
             puts "=> #{host.name} # #{host.bundler_cmd} exec #{itamae_cmd.shelljoin}"
             ssh_run("bash") do |c|
-              c.on_data do |c, data|
-                puts "[#{host.name}] #{data}"
-              end
-              c.on_extended_data do |c, _, data|
-                puts "[#{host.name}/ERR] #{data}"
-              end
+              set_ssh_output_hook(c)
 
               c.send_data("cd #{host_basedir.shellescape}\n#{sudovars}\n#{sudocmd}#{host.bundler_cmd} exec #{itamae_cmd.shelljoin}\n")
               c.eof!
@@ -82,19 +59,6 @@ module Hocho
           end
         end
       end
-
-      def cleanup
-        return unless !keep_synced_files? || !deploy_dir
-
-        cmd = "rm -rf #{host_basedir.shellescape}"
-        puts "=> #{host.name} $ #{cmd}"
-        ssh_run(cmd, error: false)
-      end
-
-      def host_basedir
-        @deploy_dir || "#{host_tmpdir}/itamae"
-      end
-
     end
   end
 end

data/lib/hocho/drivers/mitamae.rb

@@ -0,0 +1,87 @@
+require 'hocho/drivers/ssh_base'
+
+module Hocho
+  module Drivers
+    class Mitamae < SshBase
+      def initialize(host, base_dir: '.', mitamae_path: 'mitamae', mitamae_prepare_script: [], mitamae_outdate_check_script: nil, initializers: [], mitamae_options: [], deploy_options: {})
+        super host, base_dir: base_dir, initializers: initializers
+
+        @mitamae_path = mitamae_path
+        @mitamae_prepare_script = mitamae_prepare_script
+        @mitamae_outdate_check_script = mitamae_outdate_check_script
+        @mitamae_options = mitamae_options
+        @deploy_options = deploy_options
+      end
+
+
+      def run(dry_run: false)
+        deploy(**@deploy_options) do
+          prepare_mitamae
+          run_mitamae(dry_run: dry_run)
+        end
+      end
+
+      def mitamae_available?
+        exitstatus, _ = if @mitamae_path.start_with?('/')
+          ssh_run("test -x #{@mitamae_path.shellescape}", error: false)
+        else
+          ssh_run("which #{@mitamae_path.shellescape} 2>/dev/null >/dev/null", error: false)
+        end
+        exitstatus == 0
+      end
+
+      def mitamae_outdated?
+        if @mitamae_outdate_check_script
+          exitstatus, _ = ssh_run("export HOCHO_MITAMAE_PATH=#{@mitamae_path.shellescape}; #{@mitamae_outdate_check_script}", error: false)
+          exitstatus == 0
+        else
+          false
+        end
+      end
+
+      def prepare_mitamae
+        return if mitamae_available? && !mitamae_outdated?
+        script = [*@mitamae_prepare_script].join("\n\n")
+        if script.empty?
+          raise "We have to prepare MItamae, but not mitamae_prepare_script is specified"
+        end
+        prepare_sudo do |sh, sudovars, sudocmd|
+          log_prefix = "=> #{host.name} # "
+          log_prefix_white = ' ' * log_prefix.size
+          puts "#{log_prefix}#{script.each_line.map{ |_| "#{log_prefix_white}#{_.chomp}" }.join("\n")}"
+
+          ssh_run("bash") do |c|
+            set_ssh_output_hook(c)
+
+            c.send_data("cd #{host_basedir.shellescape}\n#{sudovars}\n#{sudocmd} bash <<-'HOCHOEOS'\n#{script}HOCHOEOS\n")
+            c.eof!
+          end
+        end
+        availability, outdated = mitamae_available?, mitamae_outdated?
+        if !availability || outdated
+          status = [availability ? nil : 'unavailable', outdated ? 'outdated' : nil].compact.join(' and ')
+          raise "prepared MItamae, but it's still #{status}"
+        end
+      end
+
+      def run_mitamae(dry_run: false)
+        with_host_node_json_file do
+          itamae_cmd = [@mitamae_path, 'local', '-j', host_node_json_path, *@mitamae_options]
+          itamae_cmd.push('--dry-run') if dry_run
+          # itamae_cmd.push('--color') if $stdout.tty?
+          itamae_cmd.push(*run_list)
+
+          prepare_sudo do |sh, sudovars, sudocmd|
+            puts "=> #{host.name} # #{itamae_cmd.shelljoin}"
+            ssh_run("bash") do |c|
+              set_ssh_output_hook(c)
+
+              c.send_data("cd #{host_basedir.shellescape}\n#{sudovars}\n#{sudocmd} #{itamae_cmd.shelljoin}\n")
+              c.eof!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hocho/drivers/ssh_base.rb

@@ -9,6 +9,47 @@ module Hocho
         host.ssh_connection
       end
 
+      def finalize
+        remove_host_tmpdir!
+        remove_host_shmdir!
+      end
+
+      def deploy(deploy_dir: nil, shm_prefix: [])
+        @host_basedir = deploy_dir if deploy_dir
+
+        shm_prefix = [*shm_prefix]
+
+        ssh_cmd = ['ssh', *host.openssh_config.flat_map { |l| ['-o', "\"#{l}\""] }].join(' ')
+        shm_exclude = shm_prefix.map{ |_| "--exclude=#{_}" }
+        rsync_cmd = [*%w(rsync -az --copy-links --copy-unsafe-links --delete --exclude=.git), *shm_exclude, '--rsh', ssh_cmd, '.', "#{host.hostname}:#{host_basedir}"]
+
+        puts "=> $ #{rsync_cmd.shelljoin}"
+        system(*rsync_cmd, chdir: base_dir) or raise 'failed to rsync'
+
+        unless shm_prefix.empty?
+          shm_include = shm_prefix.map{ |_| "--include=#{_.sub(%r{/\z},'')}/***" }
+          rsync_cmd = [*%w(rsync -az --copy-links --copy-unsafe-links --delete), *shm_include, '--exclude=*', '--rsh', ssh_cmd, '.', "#{host.hostname}:#{host_shm_basedir}"]
+          puts "=> $ #{rsync_cmd.shelljoin}"
+          system(*rsync_cmd, chdir: base_dir) or raise 'failed to rsync'
+          shm_prefix.each do |x|
+            mkdir = if %r{\A[^/].*\/.+\z} === x
+                      %Q(mkdir -vp "$(basename #{x.shellescape})" &&)
+                    else
+                      nil
+                    end
+            ssh_run(%Q(cd #{host_basedir} && #{mkdir} ln -sfv #{host_shm_basedir}/#{x.shellescape} ./#{x.sub(%r{/\z},'').shellescape}))
+          end
+        end
+
+        yield
+      ensure
+        if !deploy_dir || !keep_synced_files
+          cmd = "rm -rf #{host_basedir.shellescape}"
+          puts "=> #{host.name} $ #{cmd}"
+          ssh_run(cmd, error: false)
+        end
+      end
+
       private
 
       def prepare_sudo(password = host.sudo_password)
@@ -35,7 +76,8 @@ module Hocho
         end
 
         begin
-          temp_executable = ssh.exec!('mktemp').chomp
+          tmpdir = host_shmdir ? "TMPDIR=#{host_shmdir.shellescape} " : nil
+          temp_executable = ssh.exec!("#{tmpdir}mktemp").chomp
           raise unless temp_executable.start_with?('/')
 
           ssh_run("chmod 0700 #{temp_executable.shellescape}; cat > #{temp_executable.shellescape}; chmod +x #{temp_executable.shellescape}") do |ch|
@@ -53,6 +95,69 @@ module Hocho
         end
       end
 
+      def set_ssh_output_hook(c)
+        outbuf, errbuf = [], []
+        check = ->(prefix,data,buf) do
+          has_newline = data.include?("\n")
+          lines = data.lines
+          last = lines.pop
+          if last[-1] == "\n"
+            buf << last
+          end
+          if has_newline
+            (buf+lines).join.each_line do |line|
+              puts "#{prefix} #{line}"
+            end
+            buf.replace([])
+          end
+          if last[-1] != "\n"
+            buf << last
+          end
+        end
+
+        c.on_data do |c, data|
+          check.call "[#{host.name}] ", data, outbuf
+        end
+        c.on_extended_data do |c, _, data|
+          check.call "[#{host.name}/ERR] ", data, errbuf
+        end
+      end
+
+      def host_basedir
+        @host_basedir || "#{host_tmpdir}/itamae"
+      end
+
+      def host_shm_basedir
+        host_shmdir && "#{host_shmdir}/itamae"
+      end
+
+      def host_shmdir
+        return @host_shmdir if @host_shmdir
+        return nil if @host_shmdir == false
+
+        shmdir = host.shmdir
+        unless shmdir
+          if ssh.exec!('uname').chomp == 'Linux'
+            shmdir = '/dev/shm'
+            mount = ssh.exec!("grep -F #{shmdir.shellescape} /proc/mounts").each_line.map{ |_| _.chomp.split(' ') }
+            unless mount.find { |_| _[1] == shmdir }&.first == 'tmpfs'
+              @host_shmdir = false
+              return nil
+            end
+          else
+            @host_shmdir = false
+            return nil
+          end
+        end
+
+        mktemp_cmd = "TMPDIR=#{shmdir.shellescape} #{%w(mktemp -d -t hocho-run-XXXXXXXXX).shelljoin}"
+
+        res = ssh.exec!(mktemp_cmd)
+        unless res.start_with?(shmdir)
+          raise "Failed to shm mktemp #{mktemp_cmd.inspect} -> #{res.inspect}"
+        end
+        @host_shmdir = res.chomp
+      end
 
       def host_tmpdir
         @host_tmpdir ||= begin
@@ -60,13 +165,28 @@ module Hocho
           mktemp_cmd.prepend("TMPDIR=#{host.tmpdir.shellescape} ") if host.tmpdir
 
           res = ssh.exec!(mktemp_cmd)
-          unless res.start_with?('/tmp')
+          unless res.start_with?(host.tmpdir || '/')
             raise "Failed to mktemp #{mktemp_cmd.inspect} -> #{res.inspect}"
           end
           res.chomp
         end
       end
 
+      def remove_host_tmpdir!
+        if @host_tmpdir
+          host_tmpdir, @host_tmpdir = @host_tmpdir, nil
+          ssh.exec!("rm -rf #{host_tmpdir.shellescape}")
+        end
+      end
+
+      def remove_host_shmdir!
+        if @host_shmdir
+          host_shmdir, @host_shmdir = @host_shmdir, nil
+          ssh.exec!("rm -rf #{host_shmdir.shellescape}")
+        end
+      end
+
+
       def host_node_json_path
         "#{host_tmpdir}/node.json"
       end

data/lib/hocho/host.rb

@@ -5,28 +5,34 @@ require 'net/ssh/proxy/command'
 
 module Hocho
   class Host
-    def initialize(name, provider: nil, properties: {}, tags: {}, ssh_options: nil, tmpdir: nil, sudo_password: nil)
+    def initialize(name, provider: nil, providers: nil, properties: {}, tags: {}, ssh_options: nil, tmpdir: nil, shmdir: nil, sudo_password: nil)
+      if provider
+        warn "DEPRECATION WARNING: #{caller[1]}: Hocho::Host.new(provider:) is deprecated. Use providers: instead "
+      end
+
       @name = name
-      @provider = provider
+      @providers = [*provider, *providers]
       self.properties = properties
       @tags = tags
       @override_ssh_options = ssh_options
       @tmpdir = tmpdir
+      @shmdir = shmdir
       @sudo_password = sudo_password
     end
 
-    attr_reader :name, :provider, :properties, :tmpdir
+    attr_reader :name, :providers, :properties, :tmpdir, :shmdir
     attr_writer :sudo_password
     attr_accessor :tags
 
     def to_h
       {
         name: name,
-        provider: provider,
+        providers: providers,
         tags: tags.to_h,
         properties: properties.to_h,
       }.tap do |h|
         h[:tmpdir] = tmpdir if tmpdir
+        h[:shmdir] = shmdir if shmdir
         h[:ssh_options] = @override_ssh_options if @override_ssh_options
       end
     end
@@ -35,12 +41,23 @@ module Hocho
       @properties = Hashie::Mash.new(other)
     end
 
-    def add_properties_from_providers(providers)
+    def merge!(other)
+      @tags.merge!(other.tags)
+      @tmpdir = other.tmpdir if other.tmpdir
+      @shmdir = other.shmdir if other.shmdir
+      @properties.merge(other.properties)
+    end
+
+    def apply_property_providers(providers)
       providers.each do |provider|
         provider.determine(self)
       end
     end
 
+    def ssh_name
+      properties[:ssh_name] || name
+    end
+
     def run_list
       properties[:run_list] || []
     end
@@ -58,70 +75,72 @@ module Hocho
     end
 
     def ssh_options
-      (Net::SSH::Config.for(name) || {}).merge(Hocho::Utils::Symbolize.keys_of(properties[:ssh_options] || {})).merge(@override_ssh_options || {})
+      (Net::SSH::Config.for(ssh_name) || {}).merge(Hocho::Utils::Symbolize.keys_of(properties[:ssh_options] || {})).merge(@override_ssh_options || {})
     end
 
-    def openssh_config
+    def openssh_config(separator='=')
       ssh_options.flat_map do |key, value|
         case key
         when :encryption
-          "Ciphers #{[*value].join(?,)}"
+         [["Ciphers", [*value].join(?,)]]
         when :compression
-          "Compression #{value}"
+         [["Compression", value]]
         when :compression_level
-          "CompressionLevel #{value}"
+         [["CompressionLevel", value]]
         when :timeout
-          "ConnectTimeout #{value}"
+         [["ConnectTimeout", value]]
         when :forward_agent
-          "ForwardAgent #{value ? 'yes' : 'no'}"
+         [["ForwardAgent", value ? 'yes' : 'no']]
         when :keys_only
-          "IdentitiesOnly #{value ? 'yes' : 'no'}"
+         [["IdentitiesOnly", value ? 'yes' : 'no']]
         when :global_known_hosts_file
-          "GlobalKnownHostsFile #{value}"
+         [["GlobalKnownHostsFile", value]]
         when :auth_methods
           [].tap do |lines|
             methods = value.dup
             value.each  do |val|
               case val
               when 'hostbased'
-                lines << "HostBasedAuthentication yes"
+                lines << ["HostBasedAuthentication", "yes"]
               when 'password'
-                lines << "PasswordAuthentication yes"
+                lines << ["PasswordAuthentication", "yes"]
               when 'publickey'
-                lines << "PubkeyAuthentication yes"
+                lines << ["PubkeyAuthentication", "yes"]
               end
             end
             unless methods.empty?
-              lines << "PreferredAuthentications #{methods.join(?,)}"
+              lines << ["PreferredAuthentications", methods.join(?,)]
             end
           end
         when :host_key
-          "HostKeyAlgorithms #{[*value].join(?,)}"
+         [["HostKeyAlgorithms", [*value].join(?,)]]
         when :host_key_alias
-          "HostKeyAlias #{value}"
+         [["HostKeyAlias", value]]
         when :host_name
-          "HostName #{value}"
+         [["HostName", value]]
         when :keys
           [*value].map do |val|
-            "IdentityFile #{val}"
+           ["IdentityFile", val]
           end
         when :hmac
-          "Macs #{[*value].join(?,)}"
+         [["Macs", [*value].join(?,)]]
         when :port
-          "Port #{value}"
+         [["Port", value]]
         when :proxy
           if value.kind_of?(Net::SSH::Proxy::Command)
-            "ProxyCommand #{value.command_line_template}"
+           [["ProxyCommand", value.command_line_template]]
           else
-            "ProxyCommand #{value}"
+           [["ProxyCommand", value]]
           end
         when :rekey_limit
-          "RekeyLimit #{value}"
+         [["RekeyLimit", value]]
         when :user
-          "User #{value}"
+         [["User", value]]
         when :user_known_hosts_file
-          "UserKnownHostsFile #{value}"
+         [["UserKnownHostsFile", value]]
         end
+      end.compact.map do |keyval|
+        keyval.join(separator)
       end
     end
 

data/lib/hocho/inventory.rb

@@ -1,11 +1,23 @@
 module Hocho
   class Inventory
-    def initialize(providers)
+    def initialize(providers, property_providers)
       @providers = providers
+      @property_providers = property_providers
     end
 
     def hosts
-      @hosts ||= @providers.flat_map(&:hosts)
+      @hosts ||= @providers.inject({}) do |r,provider|
+        provider.hosts.each do |host|
+          if r.key?(host.name)
+            r[host.name].merge!(host)
+          else
+            r[host.name] = host
+          end
+        end
+        r
+      end.each do |name, host|
+        host.apply_property_providers(@property_providers)
+      end.values
     end
 
     def filter(filters)

data/lib/hocho/inventory_providers/file.rb

@@ -27,7 +27,7 @@ module Hocho
           content.map do |name, value|
             Host.new(
               name.to_s,
-              provider: self.class,
+              providers: self.class,
               properties: value[:properties],
               tags: value[:tags],
               ssh_options: value[:ssh_options]

data/lib/hocho/property_providers.rb

@@ -3,7 +3,7 @@ require 'hocho/utils/finder'
 module Hocho
   module PropertyProviders
     def self.find(name)
-      Hocho::Utils::Finder.find(self, 'hocho/inventory_providers', name)
+      Hocho::Utils::Finder.find(self, 'hocho/property_providers', name)
     end
   end
 end

data/lib/hocho/property_providers/add_default.rb

@@ -0,0 +1,15 @@
+require 'hocho/property_providers/base'
+
+module Hocho
+  module PropertyProviders
+    class AddDefault < Base
+      def initialize(properties: {})
+        @properties = properties
+      end
+
+      def determine(host)
+        host.properties.replace(host.properties.reverse_merge(@properties))
+      end
+    end
+  end
+end

data/lib/hocho/runner.rb

@@ -18,7 +18,10 @@ module Hocho
     def run(dry_run: false)
       puts "Running using #{best_driver_name}"
       driver_options = @driver_options[best_driver_name] || {}
-      best_driver.new(host, base_dir: base_dir, initializers: initializers, **driver_options).run(dry_run: dry_run)
+      driver = best_driver.new(host, base_dir: base_dir, initializers: initializers, **driver_options)
+      driver.run(dry_run: dry_run)
+    ensure
+      driver.finalize if driver
     end
 
     # def check_ssh_port

data/lib/hocho/version.rb

@@ -1,3 +1,3 @@
 module Hocho
-  VERSION = "0.1.0.beta1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hocho
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta1
+  version: 0.2.0
 platform: ruby
 authors:
 - sorah (Shota Fukumori)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-29 00:00:00.000000000 Z
+date: 2017-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -132,6 +132,7 @@ files:
 - lib/hocho/drivers/base.rb
 - lib/hocho/drivers/bundler.rb
 - lib/hocho/drivers/itamae_ssh.rb
+- lib/hocho/drivers/mitamae.rb
 - lib/hocho/drivers/ssh_base.rb
 - lib/hocho/host.rb
 - lib/hocho/inventory.rb
@@ -139,6 +140,7 @@ files:
 - lib/hocho/inventory_providers/base.rb
 - lib/hocho/inventory_providers/file.rb
 - lib/hocho/property_providers.rb
+- lib/hocho/property_providers/add_default.rb
 - lib/hocho/property_providers/base.rb
 - lib/hocho/runner.rb
 - lib/hocho/utils/finder.rb
@@ -161,12 +163,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.3
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Server provisioning tool with itamae