hazetug 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 723a5d37ca91b5fde0e80ec539e3d6a94c1acfdf
-  data.tar.gz: 8a73f894d14f9c9a91387e0cde7fa1027d7b5a57
+  metadata.gz: ebdf9a9772962644f814c2215eb1a788e935a317
+  data.tar.gz: 5886036f41c10cc8a7efb87dbce4a3bc21c20d31
 SHA512:
-  metadata.gz: 5c3e424bc320a7c7d0fd03fc3ddb882e32b0b265ff682b5960a726c5c079f303d9afd9c67cb810ffe2ce82a8ccdbace8df7de95259c2a6bc2ab896a8cc62ca14
-  data.tar.gz: 7992188b72be3ea5a17224c443ba7ad71806b5736f37ab06c75d56af9c0b9f2749ee781f03c6a37be0287bbad179606d545d9ae86dfda64456c5fc503b7daf43
+  metadata.gz: fbf02d130984ad264c559f943be0b146e84a92ab5999d0390eafab9ff03de631cadf5cf367856c4d1fbb484bb0c547700ece2b5d8c2eeb81706002207acbd5fe
+  data.tar.gz: 5ba4e8ff097d31ec9d3e5685ce3a0bf9c6a8165e65bdb45ecef0f6dc1deb92dd46430e0af17e89bcf1e5bc8ed9e3dddb459570279d2e533f4eeab3fda1e825af

data/README.md

@@ -3,7 +3,8 @@
 Cloud provisioner and bootstrapper for DigitalOcean and Linode.
 Hazetug uses [fog cloud library](http://fog.io) to be able to easily append other cloud computes and *tugs* (bootstraps) hosts using:
 
-* Knife bootstrap.
+* Knife bootstrap for chef-client.
+* Knife bootstrap for chef-solo.
 
 ## Options
 
@@ -64,8 +65,6 @@ Hazetug uses [fog cloud library](http://fog.io) to be able to easily append othe
 
 ## Knife tug
 
-### Knife tug bootstrap options
-
 <table>
     <tr>
         <td><b>Option</b></td>
@@ -89,6 +88,27 @@ Hazetug uses [fog cloud library](http://fog.io) to be able to easily append othe
     </tr>
 </table>
 
+## Solo tug
+
+<table>
+    <tr>
+        <td><b>Option</b></td>
+        <td><b>Description</b></td>
+        <td><b>Default value</b></td>
+    </tr>
+    <tr>
+        <td><b><i>attributes_json</i></b></td>
+        <td>Hash of attributes prepared for chef-solo run. (It's merged with the run_list).</td>
+        <td><i>{}</i><td>
+    </tr>
+    <tr>
+        <td><b><i>berksfile</i></b></td>
+        <td>Path to Berksfile.</td>
+        <td></td>
+    </tr>
+</table>
+
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -151,7 +171,7 @@ All variables are merged using this 3-level priority.
 
 ### Bootstrap using knife
 
-Help for linode compute is given bellow:
+Help for the linode compute is given bellow:
 
 ```
 NAME
@@ -169,6 +189,40 @@ COMMAND OPTIONS
 
 All variables are passed to the bootstrap template and are available using the hazetug hash like - `hazetug[:variable_name]`. Amongst variables described here in the options sections, hazetug also passes useful variables such as ***compute_name***, ***public_ip_address***, ***private_ip_address*** if those are available.
 
+#### Client and Solo modes
+
+It's possible to use *chef-client* or *chef-solo* to bootstrap a node. The **solo** mode is almost identical with the **client** mode, but with the only difference that it uses **berkshelf** to assist during the bootstrap process. Cookbooks are packaged and uploaded to the remote node and can be used by chef
+
+You can initiate bootstrap in the solo mode, like the following:
+<pre>
+hazetug digitalocean bootstrap solo -b bootstrap.erb solo-task.yaml
+</pre>
+
+Solo bootstrap also uses bootstrap.erb, but there's no need to start client or use any data like **validation_key** or **start_chef** helper.
+
+When defining a task, there additional options **berksfile** and **attributes**
+
+```yaml
+...
+...
+bootstrap:
+  - name: solo-box
+    location: london
+    flavor:   1gb
+    image:    ubuntu-14.04-x64
+    run_list: ["role[api]"]
+    attributes: {
+      "mycookbook": {
+        "settings": {}
+      }
+    }
+```
+```
+
+Merged *attributes* with the *run_list* form the input data for running **chef-solo** they are available inside bootstrap.erb as `hazetug[:attributes_json]`. Berksfile can be set specifically  in the bootstrap task list or if it's not set local *Berksfile* is tried by default.
+
+Another important option which is also available in the *bootstrap.erb* file is `hazetug[:cookbooks_path]` which is path to an archive of cookbooks packaged by Berkshelf.
+
 #### Examples
 
 * Provisioning and bootstrapping 5 nodes, each 3 of them will be processed simultaneously:

data/examples/bootstrap-client.erb

@@ -0,0 +1,82 @@
+<% require 'json' -%>
+bash -c '
+
+mkdir -p /etc/chef
+
+cat > /etc/chef/validation.pem <<'EOP'
+<%= validation_key %>
+EOP
+
+chmod 0600 /etc/chef/validation.pem
+
+cat > /etc/chef/client.rb <<'EOP'
+<%= config_content %>
+EOP
+
+cat > /etc/chef/first-boot.json <<'EOP'
+{
+  "run_list": <%= (["role[bootstrap]"] + (hazetug[:bootstrap_list] || [])).to_json %>,
+  "bootstrap":  {
+    "set_run_list": <%= (hazetug[:run_list] || []).to_json %>,
+    "set_environment": "<%= hazetug[:chef_environment] %>"
+  }
+}
+EOP
+
+# --------------- Update ubuntu and Install packages
+
+export DEBIAN_FRONTEND=noninteractive
+apt-get update && apt-get upgrade -yq
+apt-get clean
+apt-get autoremove -yq
+
+apt-get -yq install curl build-essential
+
+
+# --------------- Set hostname
+
+HOSTNAME="<%= hazetug[:name] %>"
+echo "${HOSTNAME}" > /etc/hostname
+ip=`/sbin/ifconfig eth0   | grep "\<inet\>"  |  cut -d ":" -f2 | cut -d " " -f1`
+echo -e "\n# our own entry\n${ip} ${HOSTNAME} ${HOSTNAME%%.*}" >> /etc/hosts
+cp /etc/hosts /tmp/hosts.orig
+cat /tmp/hosts.orig | sed "s/127.0.0.1.*/127.0.0.1 localhost localhost.localdomain/" > /etc/hosts
+rm /tmp/hosts.orig
+hostname -F /etc/hostname
+
+# --------------- Set private network on Linode
+
+if [ "<%= hazetug[:compute_name] %>" = "linode" ]; then
+
+cat >> /etc/network/interfaces <<'EOP'
+
+auto eth0:0
+iface eth0:0 inet static
+  address <%= hazetug[:private_ip_address] %>
+  netmask 255.255.128.0
+EOP
+ifup eth0:0
+
+fi
+
+
+# --------------- Install Chef
+
+curl -L https://get.rvm.io | bash -s <%= hazetug[:rvm_version] || 'stable' %>
+source /etc/profile.d/rvm.sh
+
+rvm install <%= hazetug[:ruby_version] || "ruby-2.1.2" %> --autolibs=3
+rvm use <%= hazetug[:ruby_version] || "ruby-2.1.2" %> --default
+
+cat >/tmp/chef_gemfile<<EOF
+source "http://rubygems.org"
+gem "chef", "<%= hazetug[:chef_version] || "11.14.6" %>"
+EOF
+ 
+bundle install --gemfile /tmp/chef_gemfile
+rm /tmp/chef_gemfile
+
+# --------------- Start Chef (bootstrap run)
+
+echo "<%= start_chef %>"
+<%= start_chef %>'

data/examples/bootstrap-solo.erb

@@ -0,0 +1,64 @@
+<% require 'json' -%>
+bash -c '
+
+mkdir -p /etc/chef
+
+cat > /etc/chef/first-boot.json <<'EOP'
+<%= hazetug[:attributes_json] %>
+EOP
+
+# --------------- Update ubuntu and Install packages
+
+export DEBIAN_FRONTEND=noninteractive
+apt-get update && apt-get upgrade -yq
+apt-get clean
+apt-get autoremove -yq
+
+apt-get -yq install curl build-essential
+
+
+# --------------- Set hostname
+
+HOSTNAME="<%= hazetug[:name] %>"
+echo "${HOSTNAME}" > /etc/hostname
+ip=`/sbin/ifconfig eth0   | grep "\<inet\>"  |  cut -d ":" -f2 | cut -d " " -f1`
+echo -e "\n# our own entry\n${ip} ${HOSTNAME} ${HOSTNAME%%.*}" >> /etc/hosts
+cp /etc/hosts /tmp/hosts.orig
+cat /tmp/hosts.orig | sed "s/127.0.0.1.*/127.0.0.1 localhost localhost.localdomain/" > /etc/hosts
+rm /tmp/hosts.orig
+hostname -F /etc/hostname
+
+# --------------- Set private network on Linode
+
+if [ "<%= hazetug[:compute_name] %>" = "linode" ]; then
+
+cat >> /etc/network/interfaces <<'EOP'
+
+auto eth0:0
+iface eth0:0 inet static
+  address <%= hazetug[:private_ip_address] %>
+  netmask 255.255.128.0
+EOP
+ifup eth0:0
+
+fi
+
+# --------------- Install Chef
+
+curl -L https://get.rvm.io | bash -s <%= hazetug[:rvm_version] || 'stable' %>
+source /etc/profile.d/rvm.sh
+
+rvm install <%= hazetug[:ruby_version] || "ruby-2.1.2" %> --autolibs=3
+rvm use <%= hazetug[:ruby_version] || "ruby-2.1.2" %> --default
+
+cat >/tmp/chef_gemfile<<EOF
+source "http://rubygems.org"
+gem "chef", "<%= hazetug[:chef_version] || "11.14.6" %>"
+EOF
+ 
+bundle install --gemfile /tmp/chef_gemfile
+rm /tmp/chef_gemfile /tmp/chef_gemfile.lock
+
+# --------------- Start Chef in solo mode
+
+chef-solo -j /etc/chef/first-boot.json -r <%= hazetug[:cookbooks_file] %>'

data/hazetug.gemspec

@@ -7,9 +7,9 @@ Gem::Specification.new do |spec|
   spec.name          = "hazetug"
   spec.version       = Hazetug::VERSION
   spec.authors       = ["Denis Barishev"]
-  spec.email         = ["denz@twiket.com"]
+  spec.email         = ["dennybaa@gmail.com"]
   spec.summary       = %q{Cloud provisoner tool}
-  spec.description   = %q{Hazetug uses fog cloud library and he}
+  spec.description   = %q{Provisions and bootstraps nodes using knife}
   spec.homepage      = "https://github.com/dennybaa/hazetug"
   spec.license       = "MIT"
 
@@ -19,10 +19,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake"
-  spec.add_dependency "psych"
-  spec.add_dependency "fog"
-  spec.add_dependency "chef", ">= 11.10.0"
-  spec.add_dependency "gli"
-  spec.add_dependency "agent"
+  spec.add_development_dependency "rake", "~> 0"
+  spec.add_dependency "psych", "~> 0"
+  spec.add_dependency "fog", "~> 0"
+  spec.add_dependency "chef", "~> 11.0"
+  spec.add_dependency "gli",  "~> 2.0"
+  spec.add_dependency "agent", "~> 0"
+  spec.add_dependency "berkshelf", "~> 3.0"
 end

data/lib/hazetug/cli/bootstrap.rb

@@ -3,7 +3,6 @@ require 'hazetug/cli/action'
 require 'hazetug/tug'
 require 'hazetug/task'
 
-
 class Hazetug
   class CLI
     class Bootstrap < Action
@@ -26,11 +25,15 @@ class Hazetug
 
       def provision_and_bootstrap(haze, tug, channel, waitgroup)
         haze.provision
-        tug.bootstrap({
-          args:  data[:args],
-          opts:  data[:opts],
-          gopts: data[:gopts]
-        })
+        if haze.ready?
+          tug.load_haze_config(haze.config_for_tug)
+
+          tug.bootstrap({
+            args:  data[:args],
+            opts:  data[:opts],
+            gopts: data[:gopts]
+          })
+        end
       rescue
         # Exeception will be lost, since we run inside goproc,
         # ie. as soon as waitgroup is empty all process exit.
@@ -62,7 +65,7 @@ class Hazetug
               newconf[:ssh_password] = haze.config[:ssh_password]
             end
 
-            tug  = Hazetug::Tug[data[:tug_name]].new(newconf, haze)
+            tug  = Hazetug::Tug[data[:tug_name]].new(newconf)
             block.call(haze, tug)
           end
         end

data/lib/hazetug/cli.rb

@@ -29,40 +29,45 @@ class Hazetug
           compute_cmd.desc 'Provisions and bootstraps server'
           compute_cmd.command :bootstrap do |op|
 
-            op.desc 'Bootstraps server using Knife'
-            op.arg_name 'task.yaml'
-            op.command :knife do |tug|
-              tug.arg_name nil
-
-              tug.flag [:v, :variables], :must_match => Array,
-                :desc => 'Set variable or comma-seperated list of variables (var1_1=hello)'
-
-              tug.flag [:n, :number], :default_value => 1,
-                :desc => 'Set number of created nodes, value from yaml is honored'
-
-              tug.flag [:c, :concurrency], :default_value => 1,
-                :desc => 'Set concurrency value, i.e. number of hosts bootstraped simultaneously'
-
-              tug.flag [:b, :bootstrap], :default_value => 'bootstrap.erb',
-                :desc => 'Set path to knife bootstrap.erb file'
-
-              tug.action do |gopts, opts, args|
-
-                if args.empty?
-                  commands[:help].execute({},{},tug.name_for_help)
-                  exit 0
+            op.flag [:v, :variables], :must_match => Array,
+              :desc => 'Set variable or comma-seperated list of variables (var1_1=hello)'
+
+            op.flag [:n, :number], :default_value => 1,
+              :desc => 'Set number of created nodes, value from yaml is honored'
+
+            op.flag [:c, :concurrency], :default_value => 1,
+              :desc => 'Set concurrency value, i.e. number of hosts bootstraped simultaneously'
+
+            op.flag [:b, :bootstrap], :default_value => 'bootstrap.erb',
+              :desc => "Set path to knife bootstrap.erb file"
+
+            [:knife, :solo].each do |tug_cmd|
+              mode = "#{tug_cmd == :knife ? 'client' : 'solo'}"
+
+
+              op.desc "Bootstraps server using Knife in #{mode} mode"
+              op.arg_name '<task.yaml>'
+              op.command tug_cmd do |tug|
+              
+                tug.action do |gopts, opts, args|
+
+                  if args.empty?
+                    commands[:help].execute({},{},tug.name_for_help)
+                    exit 0
+                  end
+
+                  act = CLI::Action[:bootstrap].new
+                  act.pass(
+                    tug_name: tug_cmd,
+                    compute_name: compute,
+                    cli:   tug,
+                    gopts: gopts,
+                    opts:  opts,
+                    args:  args
+                  ).execute
                 end
-
-                act = CLI::Action[:bootstrap].new
-                act.pass(
-                  tug_name: :knife,
-                  compute_name: compute,
-                  cli:   tug,
-                  gopts: gopts,
-                  opts:  opts,
-                  args:  args
-                ).execute
               end
+
             end
 
           end
@@ -72,4 +77,4 @@ class Hazetug
     end
 
   end
-end
+end

data/lib/hazetug/haze/cloud_server.rb

@@ -15,11 +15,12 @@ class Hazetug
         ssh_options[:password] = ssh_opts[:ssh_password]
         ssh_options[:paranoid] = ssh_opts[:host_key_verify] || false
         ssh_options[:keys] = ssh_opts[:ssh_keys] || Hazetug.ssh_keys(compute_name)
-        server.username = ssh_opts[:ssh_user]
+        server.username = ssh_opts[:ssh_user] || 'root'
         server.ssh_port = ssh_opts[:ssh_port]
         server.ssh_options = ssh_options
         ui.info "[#{compute_name}] waiting for active ssh on #{server.ssh_ip_address}"
         server.wait_for(30) { sshable? }
+        @ready = true
       rescue Fog::Errors::TimeoutError
         ui.error "[#{compute_name}] ssh failed to #{config[:name]}, ip: #{server.ssh_ip_address}"
       end

data/lib/hazetug/haze/linode.rb

@@ -20,7 +20,7 @@ class Hazetug
         latest = /^Latest #{config[:bits]} bit/
         {
           # linode node name can't contain dots
-          :name => config[:name].gsub(/./,'-'),
+          :name => config[:name].gsub(/\./,'-'),
           :data_center => lookup(:location),
           :flavor => lookup(:flavor),
           :image  => lookup(:image),

data/lib/hazetug/haze.rb

@@ -16,7 +16,7 @@ class Hazetug
       @compute = Hazetug::Compute.const_get(compute_name).new
       @config  = configure(config)
       @server  = nil
-      @sshable = false
+      @ready   = false
     end
 
     def provision
@@ -28,6 +28,10 @@ class Hazetug
       exit(1)
     end
 
+    def ready?
+      @ready
+    end
+
     def configure(config)
       input = config.keys.map(&:to_sym)
       requires = self.class.requires
@@ -67,6 +71,14 @@ class Hazetug
     def private_ip_address
     end
 
+    def config_for_tug
+      {
+        compute_name: compute_name.downcase,
+        public_ip_address: (public_ip_address || server.ssh_ip_address rescue nil),
+        private_ip_address: private_ip_address
+      }
+    end
+
     protected
 
     def provision_server

data/lib/hazetug/tug/knife.rb

@@ -1,104 +1,26 @@
 require 'chef/knife/ssh'
 require 'chef/knife/bootstrap'
-require 'hazetug/tug'
-
-# Monkey Patch:)
-# Extend knife bootstrap context with our data
-class Chef::Knife::Core::BootstrapContext
-  def hazetug; @config[:hazetug]; end
-end
-
-class Chef::Knife::Ssh < Chef::Knife
-  def run
-    extend Chef::Mixin::Command
-    @longest = 0
-    configure_attribute
-    configure_user
-    configure_password
-    configure_identity_file
-    configure_gateway
-    configure_session
-    exit_status = ssh_command(@name_args[1..-1].join(" "))
-    session.close
-
-    exit_status
-  end
-end
+require 'hazetug/tug/knife_base'
 
 class Hazetug
   class Tug
-    class Knife < Tug
+    class Knife < KnifeBase
 
-      def bootstrap_server
-        [
-          :template_file,
-          :identity_file,
-          :ssh_user,
-          :ssh_password,
-          :host_key_verify
-        ].each do |opt|
-          kb.config[opt] = bootstrap_options[opt]
-        end
-        [
+      def initialize(config={}, haze=nil)
+        super
+        @chef_option_list = [
           :environment,
           :chef_server_url,
           :validation_key
-        ].each do |opt|
-          Chef::Config[opt] = bootstrap_options[opt]
-        end
-        kb.name_args = [haze.server.ssh_ip_address]
-        kb.run
-      rescue Hazetug::Exception => e
-        ui.error(e.message); 1
-      ensure  
-        @kb and @kb.ui.stdout.close
+        ]
       end
 
-      def kb
-        @kb ||= begin
-          lf = create_log_file
-          Chef::Knife::Bootstrap.load_deps
-          kb = Chef::Knife::Bootstrap.new
-          kb.config[:hazetug] = config
-          kb.ui = Chef::Knife::UI.new(lf, lf, lf, {verbosity: 2})
-          kb
-        end
-      end
-
-      def bootstrap_options
-        @bootstrap_options ||= begin
-          template = options[:opts][:bootstrap] || 'bootstrap.erb'
-          validation = config[:chef_validation_key] || 'validation.pem'
-
-          files = [template, validation].map {|f| File.expand_path(f)}
-          notfound = files.select {|f| !File.exist?(f)}
-          notfound.empty? or 
-            raise Hazetug::Exception, "File(s) not found: #{notfound.join(', ')}"
-
-          opts = {}
-          opts[:validation_key] = File.expand_path(validation)
-          opts[:template_file]  = File.expand_path(template)
-          opts[:ssh_user] = config[:ssh_user] || 'root'
-          opts[:ssh_password] = config[:ssh_password]
-          opts[:environment]  =  config[:chef_environment]
-          opts[:host_key_verify] = config[:host_key_verify] || false
-          opts[:chef_server_url] = config[:chef_server_url]
-          opts[:identity_file]   = preferred_ssh_identity if not opts[:ssh_password]
-          opts
-        end
-      end
-
-      def preferred_ssh_identity
-        @preferred_ssh_identity ||= begin
-          compute = Hazetug.leaf_klass_name(haze.class.name).downcase
-          identity = config[:identity_file]
-          key_path = (Hazetug::Config["#{compute}_ssh_keys"] || []).first
-          if identity.nil? && key_path.nil?
-            raise Hazetug::Exception, "identity file not specified, use #{compute}_ssh_keys or identity_file"
-          end
-          identity ||= File.expand_path(key_path)
-          identity
+      def bootstrap_config
+        super
+        @chef_option_list.each do |opt|
+          Chef::Config[opt] = bootstrap_options[opt]
         end
+        check_bootstrap_files! :validation_key, :template_file
       end
 
     end

data/lib/hazetug/tug/knife_base.rb

@@ -0,0 +1,164 @@
+require 'erubis'
+require 'chef/knife/ssh'
+require 'chef/knife/bootstrap'
+require 'chef/knife/core/bootstrap_context'
+require 'hazetug/tug'
+
+# Extend knife bootstrap context with our data.
+# It's monkey patching, yey :)
+class Chef::Knife::Bootstrap
+  def render_template(template=nil)
+    context = Chef::Knife::Core::BootstrapContext.new(config, config[:run_list], Chef::Config)
+    @extended_bootstrap_variables.each do |s, v|
+      context.instance_variable_set(s, v)
+    end
+    Erubis::Eruby.new(template).evaluate(context)
+  end
+
+  def add_variable_to_bootstrap_context(variable_sym, value)
+    @extended_bootstrap_variables ||= {}
+    @extended_bootstrap_variables[variable_sym] = value if value
+  end
+end
+
+class Chef::Knife::Core::BootstrapContext
+  def hazetug; @hazetug; end
+end
+
+class Chef::Knife::Ssh < Chef::Knife
+  def run
+    extend Chef::Mixin::Command
+    @longest = 0
+    configure_attribute
+    configure_user
+    configure_password
+    configure_identity_file
+    configure_gateway
+    configure_session
+    exit_status = ssh_command(@name_args[1..-1].join(" "))
+    session.close
+
+    exit_status
+  end
+end
+
+class Hazetug
+  class Tug
+    class KnifeBase < Tug
+
+      def initialize(config={})
+        super
+        @bootstrap_option_list = [
+          :template_file,
+          :identity_file,
+          :ssh_user,
+          :ssh_password,
+          :host_key_verify
+        ]
+      end
+
+      # Bootstraps the remote server using knife bootstrap.
+      def bootstrap_server
+        bootstrap_config
+
+        bootstrap_init
+        bootstrap_run
+        bootstrap_cleanup
+      rescue Hazetug::Exception => e
+        ui.error(e.message); 1
+      ensure  
+        knife and knife.ui.stdout.close
+      end
+
+      # Configures knife bootstrap by setting the necessary options.
+      def bootstrap_config
+        knife.add_variable_to_bootstrap_context(:@hazetug, config)
+
+        @bootstrap_option_list.each do |opt|
+          knife.config[opt] = bootstrap_options[opt]
+        end
+
+        # Check ssh identity
+        cred = [
+          hazetug_identity, bootstrap_options[:identity_file],
+          bootstrap_options[:ssh_password]
+        ]
+
+        if cred.all?(&:nil?)
+          msg = "No identity (inc. ssh_password) found. Check ssh_password," <<
+            " identity_file options or #{config[:compute_name]}_ssh_keys " <<
+            "hazetug parameter."
+
+          raise Hazetug::Exception, msg
+        end
+      end
+
+      # Pre knife bootstrap hook.
+      def bootstrap_init
+      end
+
+      # After knife bootstrap hook.
+      def bootstrap_cleanup
+      end
+
+      # Initiates knife bootstrap run.
+      def bootstrap_run
+        knife.name_args = [config[:public_ip_address]]
+        knife.run
+      end
+
+      # Initializes knife bootstrap, default output is redirected into file.
+      def knife
+        @knife ||= begin
+          lf = create_log_file
+          Chef::Knife::Bootstrap.load_deps
+          kb = Chef::Knife::Bootstrap.new
+          kb.ui = Chef::Knife::UI.new(lf, lf, lf, {verbosity: 2})
+          kb
+        end
+      end
+
+      # Extracts bootstrap options from the hazetug configuration.
+      def bootstrap_options
+        @bootstrap_options ||= begin
+          opts = {}
+
+          opts[:ssh_user] = config[:ssh_user] || 'root'
+          opts[:ssh_password] = config[:ssh_password]
+          if opts[:ssh_password].nil?
+            opts[:identity_file] = config[:identity_file] || hazetug_identity
+          end
+
+          template = options[:opts][:bootstrap] || 'bootstrap.erb'
+          validation = config[:chef_validation_key] || 'validation.pem'
+
+          opts[:validation_key] = File.expand_path(validation)
+          opts[:template_file]  = File.expand_path(template)
+          opts[:environment]  =  config[:chef_environment]
+          opts[:host_key_verify] = config[:host_key_verify] || false
+          opts[:chef_server_url] = config[:chef_server_url]
+          opts
+        end
+      end
+
+      # Lookup ssh identity key(s) in the hazetug configuration.
+      def hazetug_identity
+        @hazetug_identity ||= begin
+          compute = config[:compute_name]
+          key_path = (Hazetug::Config["#{compute}_ssh_keys"] || []).first
+          key_path and File.expand_path(key_path)       
+        end
+      end
+
+      # Check if files exist otherwise fail.
+      def check_bootstrap_files!(*list_of_opts)
+        list = list_of_opts.map {|k| bootstrap_options[k]}
+        files = list.map {|f| File.expand_path(f.to_s)}
+        notfound = files.select {|f| !File.exist?(f)}
+        notfound.empty? or 
+          raise Hazetug::Exception, "File(s) not found: #{notfound.join(', ')}"
+      end
+
+    end
+  end
+end

data/lib/hazetug/tug/solo.rb

@@ -0,0 +1,90 @@
+require 'chef/knife/ssh'
+require 'chef/knife/bootstrap'
+require 'berkshelf'
+require 'berkshelf/berksfile'
+require 'json'
+require 'hazetug/tug/knife_base'
+
+class Hazetug
+  class Tug
+    class Solo < KnifeBase
+
+      def initialize(config={})
+        super
+        @upload_dest = '/tmp/hazetug-cookbooks.tar.gz'
+      end
+
+      def bootstrap_config
+        super
+        config[:attributes_json] = json_attributes
+        config[:cookbooks_file] = @upload_dest
+
+        check_bootstrap_files! :template_file, :berksfile
+      end
+
+      def bootstrap_init
+        upload_berks_package
+      end
+
+      def bootstrap_cleanup
+        ssh = Fog::SSH.new(config[:public_ip_address], ssh_username, ssh_options)
+        ssh.run("test -f #{@upload_dest} && rm #{@upload_dest}")
+      end
+
+      def berks_package(&block)
+        berks = Berkshelf::Berksfile.from_file(bootstrap_options[:berksfile])
+
+        Dir::Tmpname.create('hazetug-cookbooks') do |path|
+          begin
+            berks.package(path)
+            block.call(path)
+          ensure
+            File.unlink(path) if File.exist?(path)
+          end
+        end
+      end
+
+      def upload_berks_package
+        berks_package do |path|
+          scp = Fog::SCP.new(config[:public_ip_address], ssh_username, ssh_options)
+          scp.upload(path, @upload_dest)
+        end
+      end
+
+      def bootstrap_options
+        @bootstrap_options ||= begin
+          opts = super
+          opts[:berksfile] = config[:berksfile] || 'Berksfile'
+          opts
+        end
+      end
+
+      def json_attributes
+        @json_attributes ||= begin
+          hash = config[:attributes] || {}
+          hash[:run_list] = config[:run_list] || []
+          JSON.pretty_generate(hash)
+        end
+      end
+
+      private
+
+      def ssh_options
+        @ssh_options ||= begin
+          ssh_options = {}
+          ssh_opts = Hazetug::Tug.ssh_options_from(config)
+          ssh_options[:password] = ssh_opts[:ssh_password]
+          ssh_options[:paranoid] = ssh_opts[:host_key_verify] || false
+          ssh_options[:keys] = ssh_opts[:ssh_keys] || Hazetug.ssh_keys(config[:compute_name])
+          ssh_options[:port] = ssh_opts[:ssh_port]
+          ssh_options
+        end
+      end
+
+      def ssh_username
+        config[:ssh_user] || 'root'
+      end
+
+    end
+  end
+end

data/lib/hazetug/tug.rb

@@ -1,4 +1,5 @@
 require 'hazetug/tug/knife'
+require 'hazetug/tug/solo'
 require 'hazetug/ui'
 require 'chef/mash'
 
@@ -12,10 +13,9 @@ class Hazetug
     ]
     LOGDIR = "#{Dir.pwd}/logs"
 
-    attr_reader :haze, :config, :options
+    attr_reader :config, :options
 
-    def initialize(config={}, haze=nil)
-      @haze = haze
+    def initialize(config={})
       @config = config
     end
 
@@ -24,22 +24,23 @@ class Hazetug
     end
 
     def bootstrap(options={})
-      if haze && haze.server && haze.server.sshable?
-        @options = options
-        haztug_set_variables
-        ip = config[:public_ip_address]
-        ui.msg "[#{tug_name}] bootstraping server #{haze.config[:name]}, ip: #{ip}"
-        exit_status = bootstrap_server
-        if exit_status.is_a?(Fixnum) && exit_status != 0
-          ui.error "[#{tug_name}] bootstraping server #{haze.config[:name]} failed."
-        else
-          ui.msg "[#{tug_name}] bootstraping server #{haze.config[:name]} done."
-        end
+      @options = options
+      ip = config[:public_ip_address]
+
+      ui.msg "[#{tug_name}] bootstraping server #{config[:name]}, ip: #{ip}"
+      exit_status = bootstrap_server
+
+      if exit_status.is_a?(Fixnum) && exit_status != 0
+        ui.error "[#{tug_name}] bootstraping server #{config[:name]} failed."
       else
-        ui.error "#{haze.compute_name} skipping bootstrap, server #{haze.config[:name]} not ready"
+        ui.msg "[#{tug_name}] bootstraping server #{config[:name]} done."
       end
     rescue Hazetug::Exception => e
-      ui.error "[#{haze.compute_name}] #{e.message}"
+      ui.error "[#{config[:compute_name]}] #{e.message}"
+    end
+
+    def load_haze_config(hash)
+      @config.merge!(hash)
     end
 
     class << self
@@ -58,25 +59,13 @@ class Hazetug
       end
     end
 
-    private
-
-    def haztug_set_variables
-      {
-        compute_name: haze.compute_name.downcase,
-        public_ip_address: (haze.public_ip_address || haze.server.ssh_ip_address rescue nil),
-        private_ip_address: haze.private_ip_address
-      }.each do |key, value|
-        config[key] = value if value
-      end
-    end
-
     protected
 
     def create_log_file
       unless File.directory?(LOGDIR)
         Dir.mkdir(LOGDIR)
       end
-      log = File.new("#{LOGDIR}/#{haze.config[:name]}", "w+")
+      log = File.new("#{LOGDIR}/#{config[:name]}", "w+")
       log.sync = true
       log
     end

data/lib/hazetug/version.rb

@@ -1,3 +1,3 @@
 class Hazetug
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hazetug
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Denis Barishev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-28 00:00:00.000000000 Z
+date: 2014-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,89 +28,103 @@ dependencies:
   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: psych
   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: fog
   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: chef
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 11.10.0
+        version: '11.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 11.10.0
+        version: '11.0'
 - !ruby/object:Gem::Dependency
   name: gli
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: agent
   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'
-description: Hazetug uses fog cloud library and he
+- !ruby/object:Gem::Dependency
+  name: berkshelf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Provisions and bootstraps nodes using knife
 email:
-- denz@twiket.com
+- dennybaa@gmail.com
 executables:
 - hazetug
 extensions: []
@@ -122,6 +136,8 @@ files:
 - README.md
 - Rakefile
 - bin/hazetug
+- examples/bootstrap-client.erb
+- examples/bootstrap-solo.erb
 - hazetug.gemspec
 - lib/hazetug.rb
 - lib/hazetug/cli.rb
@@ -137,6 +153,8 @@ files:
 - lib/hazetug/task.rb
 - lib/hazetug/tug.rb
 - lib/hazetug/tug/knife.rb
+- lib/hazetug/tug/knife_base.rb
+- lib/hazetug/tug/solo.rb
 - lib/hazetug/ui.rb
 - lib/hazetug/version.rb
 homepage: https://github.com/dennybaa/hazetug