knife-zero 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f5e2d9755e4e6f715cd77516dc2fb0d6f79d4c07
+  data.tar.gz: fce3c2e244371f998167e360afb7c97bf80e776f
+SHA512:
+  metadata.gz: f31dac88e7c0f4ada81fbba4310f0c1ed2c5adf2b48684beb19b5644b4a4aff9a4d35333e02ec05daf718a2054d3957afcd96f7678ff363cedd7de5d008886c4
+  data.tar.gz: bc0b9977368987df43e7f2d6bad671436bcad7a5e4a42aba4223b1257c89700e3dbf70c4639cf4feb018f29b5252c3818d48a8c4c047767d2ed576adcb6ff260

data/.gitignore

@@ -0,0 +1,43 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+# Created by http://www.gitignore.io
+
+### vim ###
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+*.un~
+Session.vim
+.netrwhist
+*~
+
+## Development
+
+.rvmrc
+
+## Integration
+nodes/
+roles/
+environments/
+data_bags/
+clients/
+cookbooks/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright (c) 2014 sawanoboly@higanworks.com
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,109 @@
+# Knife-Plugin Zero
+
+Run chef-client at remote node with chef-zero(local-mode) via HTTP over SSH port fowarding.
+
+- It doesn't have to transport cookbooks via scp,rsync or something.
+- It can collect node object into local chef-repo.
+- It supports all functioanly of chef(C/S).
+- You have only to manage one chef-repo.
+
+## Requirements
+
+- Must support AllowTcpForward 
+
+## Installation
+
+> This gem has not been released yet.
+
+Add this line to your application's Gemfile:
+
+    gem 'knife-zero'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install knife-zero
+
+## Usage
+
+```
+** ZERO COMMANDS **
+knife zero bootstrap FQDN (options)
+```
+
+### Bootstrap
+
+Install Chef to remote node and run chef-client under chef-zero via tcp-forward.
+
+Supported options are mostly the same as `knife bootstrap`.
+
+
+#### Example
+
+```
+$ bundle exec knife zero bootstrap host.example.com -r hogehoge::default --no-host-key-verify
+Connecting to host.example.com
+host.example.com Installing Chef Client...
+-- snip --
+host.example.com Thank you for installing Chef!
+
+host.example.com Starting first Chef Client run...
+host.example.com Starting Chef Client, version 11.14.6
+host.example.com Creating a new client identity for host.example.com using the validator key.
+
+## Resolv and sync cookbook via http over ssh tcp-forward by run-list.
+host.example.com resolving cookbooks for run list: ["hogehoge::default"]
+host.example.com Synchronizing Cookbooks:
+host.example.com   - hogehoge
+host.example.com Compiling Cookbooks...
+host.example.com Converging 0 resources
+host.example.com 
+host.example.com Running handlers:
+host.example.com Running handlers complete
+host.example.com Chef Client finished, 0/0 resources updated in 4.895561879 seconds
+
+
+## Creates node object into local.
+ $ ls nodes/host.example.com.json 
+nodes/host.example.com.json
+host.example.com
+
+## Search by knife with --local--mode option.
+$ bundle exec knife search node --local-mode
+1 items found
+
+Node Name:   host.example.com
+Environment: _default
+FQDN:        
+IP:          xxx.xxx.xxx.xxx
+Run List:    recipe[hogehoge::default]
+Roles:       
+Recipes:     hogehoge::default
+Platform:    ubuntu 12.04
+Tags:        
+```
+
+### SSH
+
+Search nodes from local chef-repo directory, and run command at remote node.
+
+Supported options are mostly the same as `knife ssh`.
+
+> Pending
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/knife-zero/fork )
+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 a new Pull Request
+
+## License
+
+Licensed under the Apache License, Version 2.0.
+

data/Rakefile

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

data/knife-zero.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'knife-zero/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "knife-zero"
+  spec.version       = Knife::Zero::VERSION
+  spec.authors       = ["sawanoboly"]
+  spec.email         = ["sawanoboriyu@higanworks.com"]
+  spec.summary       = %q{Run chef-client at remote node with chef-zero(local-mode) via HTTP over SSH port fowarding.}
+  spec.description   = File.read('README.md')
+  spec.homepage      = ""
+  spec.license       = "Apache2"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency "chef", "~> 11.8"
+end

data/lib/chef/knife/bootstrap/chef-full-localmode.erb

@@ -0,0 +1,75 @@
+bash -c '
+<%= "export https_proxy=\"#{knife_config[:bootstrap_proxy]}\"" if knife_config[:bootstrap_proxy] -%>
+
+distro=`uname -s`
+
+if test "x$distro" = "xSunOS"; then
+  if test -d "/usr/sfw/bin"; then
+    PATH=/usr/sfw/bin:$PATH
+    export PATH
+  fi
+fi
+
+exists() {
+  if command -v $1 &>/dev/null
+  then
+    return 0
+  else
+    return 1
+  fi
+}
+
+<% if knife_config[:bootstrap_install_command] %>
+  <%= knife_config[:bootstrap_install_command] %>
+<% else %>
+  install_sh="<%= knife_config[:bootstrap_url] ? knife_config[:bootstrap_url] : "https://www.opscode.com/chef/install.sh" %>"
+  version_string="-v <%= chef_version %>"
+  if ! exists /usr/bin/chef-client; then
+    echo "Installing Chef Client..."
+    if exists wget; then
+      bash <(wget <%= "--proxy=on " if knife_config[:bootstrap_proxy] %> <%= knife_config[:bootstrap_wget_options] %> ${install_sh} -O -) <%= latest_current_chef_version_string %>
+    elif exists curl; then
+      bash <(curl -L <%= "--proxy \"#{knife_config[:bootstrap_proxy]}\" " if knife_config[:bootstrap_proxy] %> <%= knife_config[:bootstrap_curl_options] %> ${install_sh}) <%= latest_current_chef_version_string %>
+    else
+      echo "Neither wget nor curl found. Please install one and try again." >&2
+      exit 1
+    fi
+  fi
+<% end %>
+
+mkdir -p /etc/chef
+
+cat > /etc/chef/validation.pem <<'EOP'
+<%= OpenSSL::PKey::RSA.new 2048 %>
+EOP
+chmod 0600 /etc/chef/validation.pem
+
+<% if encrypted_data_bag_secret -%>
+cat > /etc/chef/encrypted_data_bag_secret <<'EOP'
+<%= encrypted_data_bag_secret %>
+EOP
+chmod 0600 /etc/chef/encrypted_data_bag_secret
+<% end -%>
+
+<%# Generate Ohai Hints -%>
+<% unless @chef_config[:knife][:hints].nil? || @chef_config[:knife][:hints].empty? -%>
+mkdir -p /etc/chef/ohai/hints
+
+<% @chef_config[:knife][:hints].each do |name, hash| -%>
+cat > /etc/chef/ohai/hints/<%= name %>.json <<'EOP'
+<%= hash.to_json %>
+EOP
+<% end -%>
+<% end -%>
+
+cat > /etc/chef/client.rb <<'EOP'
+<%= config_content %>
+EOP
+
+cat > /etc/chef/first-boot.json <<'EOP'
+<%= first_boot.to_json %>
+EOP
+
+echo "Starting first Chef Client run..."
+
+<%= start_chef_local %>'

data/lib/chef/knife/zero_base.rb

@@ -0,0 +1,69 @@
+require 'chef'
+
+class Chef
+  class Knife
+    module ZeroBase
+      def self.included(includer)
+        includer.class_eval do
+          deps do
+            Chef::Config[:local_mode] = true
+            require 'knife-zero/core/bootstrap_context'
+            require 'chef/json_compat'
+            require 'tempfile'
+            require 'highline'
+            require 'net/ssh'
+            Chef::Knife::Ssh.load_deps
+          end
+
+          option :ssh_user,
+            :short => "-x USERNAME",
+            :long => "--ssh-user USERNAME",
+            :description => "The ssh username",
+            :default => "root"
+
+          option :ssh_password,
+            :short => "-P PASSWORD",
+            :long => "--ssh-password PASSWORD",
+            :description => "The ssh password"
+
+          option :identity_file,
+            :short => "-i IDENTITY_FILE",
+            :long => "--identity-file IDENTITY_FILE",
+            :description => "The SSH identity file used for authentication"
+
+          option :ssh_port,
+            :short => "-p PORT",
+            :long => "--ssh-port PORT",
+            :description => "The ssh port",
+            :proc => Proc.new { |key| Chef::Config[:knife][:ssh_port] = key }
+
+          option :ssh_gateway,
+            :short => "-G GATEWAY",
+            :long => "--ssh-gateway GATEWAY",
+            :description => "The ssh gateway",
+            :proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key }
+
+          option :forward_agent,
+            :short => "-A",
+            :long => "--forward-agent",
+            :description => "Enable SSH agent forwarding",
+            :boolean => true
+
+          option :host_key_verify,
+            :long => "--[no-]host-key-verify",
+            :description => "Verify host key, enabled by default.",
+            :boolean => true,
+            :default => true
+
+        end
+      end
+
+      private
+
+      def locate_config_value(key)
+        key = key.to_sym
+        Chef::Config[:knife][key] || config[key]
+      end
+    end
+  end
+end

data/lib/chef/knife/zero_bootstrap.rb

@@ -0,0 +1,132 @@
+require 'chef/knife'
+require 'chef/knife/bootstrap'
+
+class Chef
+  class Knife
+    class ZeroBootstrap < Chef::Knife::Bootstrap
+      include ZeroBase
+      deps do
+        require 'knife-zero/bootstrap_ssh'
+        Chef::Knife::BootstrapSsh.load_deps
+      end
+
+      banner "knife zero bootstrap FQDN (options)"
+
+      option :chef_node_name,
+        :short => "-N NAME",
+        :long => "--node-name NAME",
+        :description => "The Chef node name for your new node"
+
+      option :prerelease,
+        :long => "--prerelease",
+        :description => "Install the pre-release chef gems"
+
+      option :bootstrap_version,
+        :long => "--bootstrap-version VERSION",
+        :description => "The version of Chef to install",
+        :proc => lambda { |v| Chef::Config[:knife][:bootstrap_version] = v }
+
+      option :bootstrap_proxy,
+        :long => "--bootstrap-proxy PROXY_URL",
+        :description => "The proxy server for the node being bootstrapped",
+        :proc => Proc.new { |p| Chef::Config[:knife][:bootstrap_proxy] = p }
+
+      option :bootstrap_no_proxy,
+        :long => "--bootstrap-no-proxy [NO_PROXY_URL|NO_PROXY_IP]",
+        :description => "Do not proxy locations for the node being bootstrapped; this option is used internally by Opscode",
+        :proc => Proc.new { |np| Chef::Config[:knife][:bootstrap_no_proxy] = np }
+
+      ## Patched
+      option :distro,
+        :short => "-d DISTRO",
+        :long => "--distro DISTRO",
+        :description => "Bootstrap a distro using a template",
+        :default => "chef-full-localmode"
+
+      option :use_sudo,
+        :long => "--sudo",
+        :description => "Execute the bootstrap via sudo",
+        :boolean => true
+
+      option :use_sudo_password,
+        :long => "--use-sudo-password",
+        :description => "Execute the bootstrap via sudo with password",
+        :boolean => false
+
+      option :template_file,
+        :long => "--template-file TEMPLATE",
+        :description => "Full path to location of template to use",
+        :default => false
+
+      option :run_list,
+        :short => "-r RUN_LIST",
+        :long => "--run-list RUN_LIST",
+        :description => "Comma separated list of roles/recipes to apply",
+        :proc => lambda { |o| o.split(/[\s,]+/) },
+        :default => []
+
+      option :first_boot_attributes,
+        :short => "-j JSON_ATTRIBS",
+        :long => "--json-attributes",
+        :description => "A JSON string to be added to the first run of chef-client",
+        :proc => lambda { |o| Chef::JSONCompat.parse(o) },
+        :default => {}
+
+      option :hint,
+        :long => "--hint HINT_NAME[=HINT_FILE]",
+        :description => "Specify Ohai Hint to be set on the bootstrap target.  Use multiple --hint options to specify multiple hints.",
+        :proc => Proc.new { |h|
+          Chef::Config[:knife][:hints] ||= Hash.new
+          name, path = h.split("=")
+          Chef::Config[:knife][:hints][name] = path ? Chef::JSONCompat.parse(::File.read(path)) : Hash.new  }
+
+        option :secret,
+          :short => "-s SECRET",
+          :long  => "--secret ",
+          :description => "The secret key to use to encrypt data bag item values",
+          :proc => Proc.new { |s| Chef::Config[:knife][:secret] = s }
+
+        option :secret_file,
+          :long => "--secret-file SECRET_FILE",
+          :description => "A file containing the secret key to use to encrypt data bag item values",
+          :proc => Proc.new { |sf| Chef::Config[:knife][:secret_file] = sf }
+
+        option :bootstrap_url,
+          :long        => "--bootstrap-url URL",
+          :description => "URL to a custom installation script",
+          :proc        => Proc.new { |u| Chef::Config[:knife][:bootstrap_url] = u }
+
+        option :bootstrap_install_command,
+          :long        => "--bootstrap-install-command COMMANDS",
+          :description => "Custom command to install chef-client",
+          :proc        => Proc.new { |ic| Chef::Config[:knife][:bootstrap_install_command] = ic }
+
+        option :bootstrap_wget_options,
+          :long        => "--bootstrap-wget-options OPTIONS",
+          :description => "Add options to wget when installing chef-client",
+          :proc        => Proc.new { |wo| Chef::Config[:knife][:bootstrap_wget_options] = wo }
+
+        option :bootstrap_curl_options,
+          :long        => "--bootstrap-curl-options OPTIONS",
+          :description => "Add options to curl when install chef-client",
+          :proc        => Proc.new { |co| Chef::Config[:knife][:bootstrap_curl_options] = co }
+
+      def knife_ssh
+        ssh = Chef::Knife::BootstrapSsh.new
+        ssh.ui = ui
+        ssh.name_args = [ server_name, ssh_command ]
+        ssh.config[:ssh_user] = Chef::Config[:knife][:ssh_user] || config[:ssh_user]
+        ssh.config[:ssh_password] = config[:ssh_password]
+        ssh.config[:ssh_port] = Chef::Config[:knife][:ssh_port] || config[:ssh_port]
+        ssh.config[:ssh_gateway] = Chef::Config[:knife][:ssh_gateway] || config[:ssh_gateway]
+        ssh.config[:forward_agent] = Chef::Config[:knife][:forward_agent] || config[:forward_agent]
+        ssh.config[:identity_file] = Chef::Config[:knife][:identity_file] || config[:identity_file]
+        ssh.config[:manual] = true
+        ssh.config[:host_key_verify] = Chef::Config[:knife][:host_key_verify] || config[:host_key_verify]
+        ssh.config[:on_error] = :raise
+        ssh
+      end
+
+    end
+  end
+end

data/lib/knife-zero/bootstrap_ssh.rb

@@ -0,0 +1,76 @@
+require 'chef/knife/ssh'
+
+class Chef
+  class Knife
+    class BootstrapSsh < Chef::Knife::Ssh
+      def configure_session
+        host, ssh_port = @name_args[0].split(" ")
+        @longest = host.length
+
+        Chef::Log.debug("Configration for #{host}")
+        session_opts = {}
+
+        ssh_config = Net::SSH.configuration_for(host)
+
+        # Chef::Config[:knife][:ssh_user] is parsed in #configure_user and written to config[:ssh_user]
+        user = config[:ssh_user] || ssh_config[:user]
+        hostspec = user ? "#{user}@#{host}" : host
+        session_opts[:keys] = File.expand_path(config[:identity_file]) if config[:identity_file]
+        session_opts[:keys_only] = true if config[:identity_file]
+        session_opts[:password] = config[:ssh_password] if config[:ssh_password]
+        session_opts[:forward_agent] = config[:forward_agent]
+        session_opts[:port] = config[:ssh_port] ||
+          ssh_port || # Use cloud port if available
+          Chef::Config[:knife][:ssh_port] ||
+          ssh_config[:port]
+        session_opts[:logger] = Chef::Log.logger if Chef::Log.level == :debug
+
+        if !config[:host_key_verify]
+          session_opts[:paranoid] = false
+          session_opts[:user_known_hosts_file] = "/dev/null"
+        end
+
+        ## use nomal Net::SSH instead of Net::SSH::Multi for simply tcpforward.
+        @session ||= Net::SSH.start(host, user, session_opts)
+      end
+
+
+      def ssh_command(command, subsession=nil)
+        chef_zero_port = config[:chef_zero_port] ||
+                         Chef::Config[:knife][:chef_zero_port] ||
+                         8889
+        chef_zero_host = config[:chef_zero_host] ||
+                         Chef::Config[:knife][:chef_zero_host] ||
+                        '127.0.0.1'
+
+        exit_status = 0
+        subsession ||= session
+        command = fixup_sudo(command)
+        command.force_encoding('binary') if command.respond_to?(:force_encoding)
+
+        Chef::Log.debug("Creating tcp-foward channel to #{chef_zero_host}:#{chef_zero_port}")
+        session.forward.remote(8889, chef_zero_host, chef_zero_port)
+        subsession.open_channel do |ch|
+          ch.request_pty
+          ch.exec command do |ch, success|
+            raise ArgumentError, "Cannot execute #{command}" unless success
+            ch.on_data do |ichannel, data|
+              ## Patched
+              print_data(ichannel.connection.host, data)
+              if data =~ /^knife sudo password: /
+                print_data(ichannel.connection.host, "\n")
+                ichannel.send_data("#{get_password}\n")
+              end
+            end
+            ch.on_request "exit-status" do |ichannel, data|
+              exit_status = [exit_status, data.read_long].max
+            end
+          end
+        end
+        session.loop
+        exit_status
+      end
+    end
+  end
+end
+

data/lib/knife-zero/common.rb

@@ -0,0 +1,7 @@
+module Knife
+  module Zero
+    module Helper
+      ## Some Helper..
+    end
+  end
+end

data/lib/knife-zero/core/bootstrap_context.rb

@@ -0,0 +1,20 @@
+require 'chef/knife/core/bootstrap_context'
+
+class Chef
+  class Knife
+    module Core
+      class BootstrapContext
+         class_eval do
+           def start_chef_local
+             client_path = @chef_config[:chef_client_path] || 'chef-client'
+             s = "#{client_path} -j /etc/chef/first-boot.json"
+             s << ' -l debug' if @config[:verbosity] and @config[:verbosity] >= 2
+             s << " -E #{bootstrap_environment}" if chef_version.to_f != 0.9 # only use the -E option on Chef 0.10+
+             s << " -S http://127.0.0.1:8889"
+             s
+           end
+         end
+      end
+    end
+  end
+end

data/lib/knife-zero/version.rb

@@ -0,0 +1,6 @@
+module Knife
+  module Zero
+    VERSION = "0.0.1"
+    MAJOR, MINOR, TINY = VERSION.split('.')
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: knife-zero
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- sawanoboly
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.8'
+description: "# Knife-Plugin Zero\n\nRun chef-client at remote node with chef-zero(local-mode)
+  via HTTP over SSH port fowarding.\n\n- It doesn't have to transport cookbooks via
+  scp,rsync or something.\n- It can collect node object into local chef-repo.\n- It
+  supports all functioanly of chef(C/S).\n- You have only to manage one chef-repo.\n\n##
+  Requirements\n\n- Must support AllowTcpForward \n\n## Installation\n\n> This gem
+  has not been released yet.\n\nAdd this line to your application's Gemfile:\n\n    gem
+  'knife-zero'\n\nAnd then execute:\n\n    $ bundle\n\nOr install it yourself as:\n\n
+  \   $ gem install knife-zero\n\n## Usage\n\n```\n** ZERO COMMANDS **\nknife zero
+  bootstrap FQDN (options)\n```\n\n### Bootstrap\n\nInstall Chef to remote node and
+  run chef-client under chef-zero via tcp-forward.\n\nSupported options are mostly
+  the same as `knife bootstrap`.\n\n\n#### Example\n\n```\n$ bundle exec knife zero
+  bootstrap host.example.com -r hogehoge::default --no-host-key-verify\nConnecting
+  to host.example.com\nhost.example.com Installing Chef Client...\n-- snip --\nhost.example.com
+  Thank you for installing Chef!\n\nhost.example.com Starting first Chef Client run...\nhost.example.com
+  Starting Chef Client, version 11.14.6\nhost.example.com Creating a new client identity
+  for host.example.com using the validator key.\n\n## Resolv and sync cookbook via
+  http over ssh tcp-forward by run-list.\nhost.example.com resolving cookbooks for
+  run list: [\"hogehoge::default\"]\nhost.example.com Synchronizing Cookbooks:\nhost.example.com
+  \  - hogehoge\nhost.example.com Compiling Cookbooks...\nhost.example.com Converging
+  0 resources\nhost.example.com \nhost.example.com Running handlers:\nhost.example.com
+  Running handlers complete\nhost.example.com Chef Client finished, 0/0 resources
+  updated in 4.895561879 seconds\n\n\n## Creates node object into local.\n $ ls nodes/host.example.com.json
+  \nnodes/host.example.com.json\nhost.example.com\n\n## Search by knife with --local--mode
+  option.\n$ bundle exec knife search node --local-mode\n1 items found\n\nNode Name:
+  \  host.example.com\nEnvironment: _default\nFQDN:        \nIP:          xxx.xxx.xxx.xxx\nRun
+  List:    recipe[hogehoge::default]\nRoles:       \nRecipes:     hogehoge::default\nPlatform:
+  \   ubuntu 12.04\nTags:        \n```\n\n### SSH\n\nSearch nodes from local chef-repo
+  directory, and run command at remote node.\n\nSupported options are mostly the same
+  as `knife ssh`.\n\n> Pending\n\n\n## Contributing\n\n1. Fork it ( https://github.com/[my-github-username]/knife-zero/fork
+  )\n2. Create your feature branch (`git checkout -b my-new-feature`)\n3. Commit your
+  changes (`git commit -am 'Add some feature'`)\n4. Push to the branch (`git push
+  origin my-new-feature`)\n5. Create a new Pull Request\n\n## License\n\nLicensed
+  under the Apache License, Version 2.0.\n\n"
+email:
+- sawanoboriyu@higanworks.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- knife-zero.gemspec
+- lib/chef/knife/bootstrap/chef-full-localmode.erb
+- lib/chef/knife/zero_base.rb
+- lib/chef/knife/zero_bootstrap.rb
+- lib/knife-zero/bootstrap_ssh.rb
+- lib/knife-zero/common.rb
+- lib/knife-zero/core/bootstrap_context.rb
+- lib/knife-zero/version.rb
+homepage: ''
+licenses:
+- Apache2
+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: Run chef-client at remote node with chef-zero(local-mode) via HTTP over SSH
+  port fowarding.
+test_files: []