chef-provisioning-crowbar 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 749999debb44d64aaa65360b79ba838692756f80
+  data.tar.gz: 48a387ef467e1786ecf054e0b458923004f80216
+SHA512:
+  metadata.gz: e24a4d37cef67b30a675bbeb9f32e4a2d4336de5d561ab9c6eb348e56c3cb8c8484241da35199a2ea7074433c8fdf99935f6f6207ddfdd39e25b7cf52a2c2e12
+  data.tar.gz: 440d09ad30356e528eee54d1cf70659f03276d8fdca9e47c9de2e7160b2945339860a64e1208bc14306a90624f43c96c5c93b3959b2de11dc8637af605fa2d77

data/LICENSE

@@ -0,0 +1,23 @@
+# Apache 2
+
+This submodule of OpenCrowbar is Apache 2 licensed.
+
+## Copyright 2014, Rob Hirschfeld
+## Copyright 2015, Judd Maltin
+
+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. 
+
+
+## For details
+
+See [[doc/licenses/README.md]]

data/README.md

@@ -0,0 +1,136 @@
+# OpenCrowbar for Chef-Provisioning
+
+**Chef Provisioning with Crowbar to treat your metal like a cloud**
+
+This repo contains the interface between Chef Provisioning (https://github.com/opscode/chef-provisioning/) and OpenCrowbar.
+
+> make sure you are running Ruby 1.9 and related gems for this tool.  check `ruby -v` to verify.
+
+> Better yet: *use chef-dk* - it now has chef-provisioning gems included.
+
+## Background
+
+Crowbar discovers and manages your gear - preferably hardware nodes.  The typical model would be to get Crowbar running on your admin network, and start booting up your gear.  Crowbar will discover and inventory your gear automatically.  You can then use Chef Provisioning to tell Crowbar to do all those things it's good at: install the OS you want, configure the BIOS, RAID, networking, and manage the power states of the gear.  You can keep using Chef-Provisioning and Crowbar when you want to power down or re-image those nodes.
+
+Crowbar manages nodes in groups of "deployments." All nodes start and spend their lives in the foundational "system" deployment. They're then added to deployments you create to effect change on them.  By creating a new deployment and adding nodes to it, all the roles you defined as belonging to that deployment get run on the gear.   
+
+When you write a recipe with Chef Provisioning and Crowbar, Chef Provisioning requests from Crowbar to "allocate_machine."  Crowbar then looks in its inventory for a node that is "alive" according to Crowbar (Crowbar can power it on and ssh into it,) but not used in any other deployments than "system."  Once Crowbar finds an appropriate node, it adds the node to the "ready" deployment (default name, and will create it if necessary.) This will start Crowbar configuring the hardware, OS, network, etc.  Chef Provisioning waits patiently for all this to get finished, so it can consider the node "ready."
+
+A Chef Provisioning "ready" machine is a Crowbar node which has completed the tasks in the proper deployment ("ready"), and Crowbar has given up managing it until further notice.  In Crowbar terms, that means that the milestone noderole for the deployment is 'active', and the node is marked in Crowbar as node["available"]:false so the annealer will not manage the node's noderoles.  
+
+## Example
+
+Chef Provisioning with Crowbar will treat your gear like a cloud! 
+
+Example Session:
+
+See the nodes available from Crowbar:
+
+```bash
+bash-4.1# crowbar deployments nodes "system" | grep '"alias"'
+    "alias": "d52-54-32-f9-00-00",
+    "alias": "d52-54-32-f8-00-00",
+    "alias": "d52-54-32-f5-00-00",
+    "alias": "d52-54-32-f6-00-00",
+    "alias": "d52-54-32-f7-00-00",
+    "alias": "be727e682d0d",
+bash-4.1# 
+```
+
+And you can see them with `knife` against the chef server in Crowbar:
+
+```bash
+$ knife node list -s http://192.168.124.10
+be727e682d0d.crowbar.org
+d52-54-32-f5-00-00.crowbar.org
+d52-54-32-f6-00-00.crowbar.org
+d52-54-32-f7-00-00.crowbar.org
+d52-54-32-f8-00-00.crowbar.org
+d52-54-32-f9-00-00.crowbar.org
+```
+
+So, to provision one of these, run the example recipe:
+
+Example Recipe:
+
+```ruby
+require 'chef/provisioning'
+with_driver 'crowbar'
+
+# Here I indicate the chef server running inside Crowbar.  If you like, use your own Chef Server, or just
+# use Chef Zero by calling chef-client -z <recipe_name>.
+
+with_chef_server 'https://192.168.124.10',
+                 :client_name => 'metal',
+                 :signing_key_filename => '/home/metal/.chef/metal.pem'
+
+machine "chef-provisioning-#{rand(1000)}" do
+  machine_options :crowbar_options => { 'provisioner-target_os' => 'centos-7.0' }
+end
+```
+
+Example chef-client Invocation:
+
+```bash
+$ chef-client ./crowbar_test.rb 
+```
+
+and you will see the new node being allocated and made ready.  Here's a few nodes in the "ready"
+deployment.
+
+```bash
+# crowbar deployments nodes "ready" | grep '"alias"'
+    "alias": "chef-provisioning-another-brother-42",
+    "alias": "chef-provisioning-another-brother-97",
+    "alias": "chef-provisioning-example-56",
+    "alias": "chef-provisioning-another-brother-80",
+```
+
+
+Real world use would have you put a run-list in the `machine` resource, so chef can use the nodes to actually do things.
+
+## Setup
+
+### Networking
+
+Before you start, your chef-provisioning box must be on the crowbar administration network, so it can ssh into the slave nodes and do its cheffy thing.  In our typical development environments, that's simply a matter of setting your host OSs network as follows:
+
+```bash
+$ sudo ip a add 192.168.124.2/24 dev docker0
+```
+
+### Chef
+
+#### Chef-DK
+
+I use the chef-dk, which now has Chef Provisioning built in.  Get your `knife` and `chef-client` all setup for development work.
+
+#### Gems, no Chef-DK
+
+Or you can use Chef gems.
+
+*Gem dependencies* You also need the HTTParty, Chef and Chef-Metal gems: `sudo gem install httparty chef chef-metal`
+
+## Example gem build script and test run
+
+This is an example file to run and build chef provisioning crowbar.
+
+All the exciting stuff is happening in chef-provisioning-crowbar/cookbooks/app/recipes/crowbar-test.rb
+
+/$HOME/build_and_test_chef-provisioning-crowbar.sh
+
+```bash
+# source the chef-dk env
+. $HOME/.bash_profile
+CPC_REPO_PATH=<path to chef-provisioning-crowbar git repo>
+cd ${CPC_REPO_PATH}
+gem build chef-provisioning-crowbar.gemspec 
+gem install --ignore-dependencies --no-ri --no-rdoc chef-provisioning-crowbar-0.0.2.gem
+cd ${CPC_REPO_PATH}/cookbooks/app/recipes/
+# run with debugging..
+#chef-client -l debug -z crowbar_test.rb
+# or not
+#chef-client -z crowbar_test.rb
+# or omit -z to use a chef server indicated elsewhere
+chef-client ./crowbar_test.rb
+```

data/Rakefile

@@ -0,0 +1,22 @@
+#!/bin/bash
+# Copyright 2014, Rob Hirschfeld
+#
+# 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.
+
+require 'bundler'
+require 'bundler'
+require 'bundler/gem_tasks'
+
+task :spec do
+  require File.expand_path('spec/run')
+end

data/lib/chef/provisioning/crowbar_driver/driver.rb

@@ -0,0 +1,280 @@
+# Copyright 2014, Rob Hirschfeld
+#
+# 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.
+
+#require 'chef/mixin/shell_out'
+require 'chef/provisioning/driver'
+require 'chef/provisioning/machine/unix_machine'
+require 'chef/provisioning/machine_spec'
+require 'chef/provisioning/convergence_strategy/install_cached'
+require 'chef/provisioning/transport/ssh'
+require 'chef/provisioning/crowbar_driver/version'
+require 'etc'
+require 'time'
+#require 'cheffish/merged_config'
+require 'crowbar/core'
+
+class Chef
+module Provisioning
+module CrowbarDriver
+
+  class Driver < Chef::Provisioning::Driver
+
+
+    ALLOCATE_DEPLOYMENT   = 'system'
+    READY_DEPLOYMENT      = 'ready'
+    TARGET_NODE_ROLE      = "crowbar-installed-node"
+    API_BASE              = "/api/v2"
+
+    def initialize(driver_url, config)
+      super(driver_url, config)
+      @crowbar = Crowbar.new
+      #config[:private_key_paths] = [ "$HOME/.ssh/id_rsa" ]
+      #config[:log_level] = :debug
+    end
+    
+    # Passed in a driver_url, and a config in the format of Driver.config.
+    def self.from_url(driver_url, config)
+      Driver.new(driver_url, config)
+    end
+
+    def self.canonicalize_url(driver_url, config)
+      [ driver_url, config ]
+    end
+
+    # Acquire a machine, generally by provisioning it.  Returns a Machine
+    # object pointing at the machine, allowing useful actions like setup,
+    # converge, execute, file and directory.
+
+    def allocate_machine(action_handler, machine_spec, machine_options)
+
+      @crowbar.log_level(config[:log_level])
+      
+      if machine_spec.location
+        if !@crowbar.node_exists?(machine_spec.location['server_id'])
+          # It doesn't really exist
+          action_handler.perform_action "Machine #{machine_spec.location['server_id']} does not really exist.  Recreating ..." do
+            machine_spec.location = nil
+          end
+        end
+      end
+
+      if !machine_spec.location
+        action_handler.perform_action "Crowbar: #{@crowbar} Creating server #{machine_spec.name} with options #{machine_options}" do
+          # TODO: Make sure SSH keys are found locally here?  Or in allocate_node?
+          # get ssh pubkey from current user
+          #result = shell_out("cat ~/.ssh/id_rsa.pub", :cwd => '$HOME')
+          #sshkey = result.stdout
+          #action_handler.report_progress "sshpubkey on admin server #{sshkey}\n"
+          # put it on the crowbar server provisioner
+          #@crowbar.add_sshkey(result.stdout)
+          
+          server = allocate_node(machine_spec.name, machine_options, action_handler)
+          server_id = server["id"]
+          debug "allocate server_id = #{server_id}"
+          machine_spec.location = {
+            'driver_url' => driver_url,
+            'driver_version' => Chef::Provisioning::CrowbarDriver::VERSION,
+            'server_id' => server_id,
+            'node_role_id' => server["node_role_id"]
+           # 'bootstrap_key' => sshkey
+          }
+        end
+      end
+    end
+
+    # Ready a machine moves the machine from the System deployment
+    # to the Ready deployment.  Default Ready deployment is named 'ready'
+    # but will pick up machine_configs that match
+    def ready_machine(action_handler, machine_spec, machine_options)
+      debug machine_spec.location
+ 
+      server_id = machine_spec.location['server_id']
+      unless @crowbar.node_alive?(server_id)
+        action_handler.perform_action "Powering up machine #{server_id}" do
+          @crowbar.power(server_id, "on")
+        end
+      end
+
+      nr_id = machine_spec.location['node_role_id']
+
+      action_handler.report_progress "Awaiting ready machine..."
+      action_handler.perform_action "done waiting for machine id: #{server_id}" do
+        loop do 
+          break if @crowbar.node_ready(server_id,nr_id)
+          sleep 5
+        end 
+        action_handler.report_progress "waited for machine - machine is ready. machine id: #{server_id}" 
+      end
+
+      # set the machine to "reserved" to take control away from Crowbar
+      node = @crowbar.node(server_id)
+      node['available'] = false
+      @crowbar.set_node(server_id, node)
+
+      # Return the Machine object
+      machine_for(machine_spec, machine_options)
+    end
+
+    def machine_for(machine_spec, machine_options)
+      ssh_options = {
+        :auth_methods => ['publickey'],
+      }
+      server_id = machine_spec.location['server_id']
+      node_admin_addresses = @crowbar.node_attrib(server_id, 'network-admin_addresses')
+      node_ipv4_admin_net_ip = node_admin_addresses['value'][0].split('/')[0]
+      node_ipv4_admin_net_ip = node_admin_addresses['value'][0].split('/')[0]
+      #node_ipv6_admin_net_ip = node_admin_addresses['value'][1]
+      
+      transport = Chef::Provisioning::Transport::SSH.new(node_ipv4_admin_net_ip, 'root', ssh_options, {}, config)
+      convergence_strategy = Chef::Provisioning::ConvergenceStrategy::InstallCached.new(machine_options[:convergence_options], config)
+      Chef::Provisioning::Machine::UnixMachine.new(machine_spec, transport, convergence_strategy)
+    end
+
+    def create_ssh_transport(machine_spec)
+      crowbar_ssh_config = crowbar_ssh_config_for(machine_spec)
+      hostname = crowbar_ssh_config['HostName']
+      username = crowbar_ssh_config['User']
+      ssh_options = {
+        :port => '22',
+        :auth_methods => ['publickey'],
+        #:user_known_hosts_file => crowbar_ssh_config['UserKnownHostsFile'],
+        :paranoid => false, #yes_or_no(vagrant_ssh_config['StrictHostKeyChecking']),
+        :keys => [ '$HOME/.ssh/id_rsa' ],
+        :keys_only => true
+      }
+      Chef::Provisioning::Transport::SSH.new(hostname, username, ssh_options, options, config) end
+
+    def ensure_deployment(to_deployment)
+      unless @crowbar.deployment_exists?(to_deployment)
+          @crowbar.deployment_create(to_deployment)
+          debug("Crowbar deployment '#{to_deployment}' does not exist... creating...")
+      end
+    end
+
+    def get_non_admin_nodes(names=[])
+      # get available nodes
+      from_deployment = ALLOCATE_DEPLOYMENT
+      pool = @crowbar.non_admin_nodes_in_deployment(from_deployment)
+      raise "No available non-admin nodes in pool '#{from_deployment}'" if !pool || pool.size == 0
+      #action_handler.report_progress "Pool size: #{pool.size}"
+      # make sure node name isn't taken
+      good_nodes = []
+      names.each do |name|
+        pool.each do |node|
+          if node['alias'] == name
+            debug "Node #{name} already exists, skipping."
+            break
+          end
+          good_nodes << node
+        end
+      end
+      return good_nodes
+    end
+
+
+    def set_node_and_bind_noderole(node,name,role,to_deployment,crowbar_options={})
+      debug("set_node_foundling #{node}")
+      node["alias"] = name
+      node["deployment"] = to_deployment
+      raise "Setting node #{node["alias"]} to deployment \"#{to_deployment}\" failed." unless @crowbar.set_node(node["id"], node)
+      #action_handler.report_progress "Crowbar node\'s deployment attirbute set to \"#{to_deployment}\"\n"
+      
+
+      # bind the NodeRole if missing (eventually set the OS property)
+      bind = {:node=>node["id"], :role=>role, :deployment=>to_deployment}
+      # blindly add node role > we need to make this smarter and skip if unneeded
+      # query node for all its noderoles and skip if noderole is in finished state
+      node["node_role_id"] = @crowbar.bind_node_role(bind)
+      #action_handler.report_progress "Crowbar node #{node["id"]} noderole bound to #{TARGET_NODE_ROLE} deployment #{to_deployment} as noderole #{node["node_role_id"]}\n"
+
+      # set crowbar_options.  they're attribs in crowbar
+      crowbar_options.each do |attrib, value|
+        #attribs = {  "provisioner-target_os" => machine_options[:crowbar_options]['provisioner-target_os'] }
+        @crowbar.set_node_attrib( node["id"], attrib, value )
+      end
+      node
+    end
+    
+    # debug messages
+    def debug(msg)
+      Chef::Log.debug msg
+    end
+
+    # Allocate many machines simultaneously
+    def allocate_machines(action_handler, specs_and_options, parallelizer)
+      to_deployment = READY_DEPLOYMENT
+
+      # check for ready deployment
+      ensure_deployment(to_deployment)
+      # can the deployment be set to proposed?
+      @crowbar.propose_deployment(to_deployment)
+
+      #private_key = get_private_key('bootstrapkey')
+      servers = []
+      server_names = []
+      specs_and_options.each do |machine_spec, machine_options|
+        if !machine_spec.location
+          servers << [ machine_spec.name, machine_options ]
+          server_names << machine_spec.name
+          # skip name collisions
+          # add nodes to ready deployment
+          # Tell the cloud API to spin them all up at once
+          action_handler.perform_action "Allocating servers #{server_names.join(',')} from the cloud" do
+            role = TARGET_NODE_ROLE
+            node = get_non_admin_nodes([machine_spec.name])[0]
+            server = set_node_and_bind_noderole(node,machine_spec.name,role,to_deployment,machine_options[:crowbar_options])
+            server_id = server["id"]
+            debug "allocate server_id = #{server_id}"
+            machine_spec.location = {
+              'driver_url' => driver_url,
+              'driver_version' => Chef::Provisioning::CrowbarDriver::VERSION,
+              'server_id' => server_id,
+              'node_role_id' => server["node_role_id"]
+            }
+          end
+        end
+      end
+
+        
+      # commit deployment
+      @crowbar.commit_deployment(to_deployment) 
+    end
+
+    # follow getready process to allocate nodes
+    def allocate_node(name, machine_options, action_handler)
+
+      role = TARGET_NODE_ROLE
+      to_deployment = READY_DEPLOYMENT
+      
+      ensure_deployment(to_deployment)
+
+      @crowbar.propose_deployment(to_deployment)
+
+      my_node = get_non_admin_nodes([name])[0]
+      #puts(my_node)
+      set_node_and_bind_noderole(my_node,name,role,to_deployment,machine_options[:crowbar_options])
+
+      @crowbar.commit_deployment(to_deployment)
+
+      # at this point Crowbar will bring up the node in the background
+      # we can return the node handle to the user
+      my_node
+
+    end
+    private
+
+  end # Class
+end
+end # Module
+end

data/lib/chef/provisioning/crowbar_driver/version.rb

@@ -0,0 +1,21 @@
+# Copyright 2014, Rob Hirschfeld
+#
+# 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.
+
+class Chef
+module Provisioning
+module CrowbarDriver
+  VERSION = '0.1.0'
+end
+end
+end

data/lib/chef/provisioning/driver_init/crowbar.rb

@@ -0,0 +1,17 @@
+# Copyright 2014, Rob Hirschfeld
+#
+# 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.
+
+require 'chef/provisioning/crowbar_driver/driver'
+
+Chef::Provisioning.register_driver_class("crowbar", Chef::Provisioning::CrowbarDriver::Driver)

data/lib/crowbar/core.rb

@@ -0,0 +1,280 @@
+# Copyright 2014, Rob Hirschfeld
+#
+# 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.
+
+require 'rubygems'
+require 'httparty'
+require 'json'
+
+
+class Crowbar
+  include HTTParty
+
+  API_BASE = '/api/v2'
+
+
+
+  def initialize(url = "http://127.0.0.1:3000", u = "crowbar", p = "crowbar")
+      @url = url + API_BASE
+      self.class.digest_auth u, p
+      self.class.base_uri @url
+      debug "initialize #{@url}"
+  end
+
+  @llevel = :info
+  def log_level(level)
+    @llevel = level
+    debug("incoming #{level} instance #{@llevel}")
+  end
+
+  def debug(msg)
+    puts "\nCROWBAR #{@llevel}: #{msg}" if @llevel == :debug
+  end
+
+#  debug_output $stderr
+  format :json
+
+  #http://192.168.222.6:3000/api/v2/nodes/1/attribs/provisioner-access_keys
+  def add_sshkey(sshkey)
+    res = self.class.get("/nodes/1/attribs/provisioner-access_keys")
+    if res.code != 200
+      raise("Could not get sshkey on admin node #{res.code} #{res.message}")
+    end
+    debug res
+    res = self.class.put("/nodes/1/attribs/provisioner-access_keys", :body => sshkey)
+    if res.code != 200
+      raise("Could not put sshkey on admin node #{res.code} #{res.message}")
+    end
+    return res
+  end
+
+  def deployment_create(name, parent_id=1)
+    data = { :name => name, :parent_id => parent_id }
+    res = self.class.post("/deployments", :body => data)
+    if res.code != 200
+      raise("Could not create deployment #{name}. #{res.code} #{res.message}")
+    end
+    res
+  end
+
+  def commit_deployment(name)
+    deployment_set(name,"commit")
+  end
+
+  def propose_deployment(name)
+    deployment_set(name,"propose")
+  end
+
+  def deployment_set(name,state)
+    res = self.class.put("/deployments/#{name}/#{state}")
+    if res.code != 200
+      raise("Could not set deployment #{name} to #{state}. #{res.code} #{res.message}")
+    end
+    return res
+  end
+
+  def deployment_exists?(name)
+    res = self.class.get("/deployments/#{name}")
+    debug("res code deployment exists #{res.code}")
+    return false unless res.code == 200
+    true
+  end
+
+  def node_exists?(name)
+    res = self.class.get("/nodes/#{name}")
+    debug("res code node exists #{res.code}")
+    return false unless res.code == 200
+    true
+  end
+
+  def non_admin_nodes_in_deployment(name, attrs={})
+    #attrs = {'x-return-attributes' => '["admin"]' } 
+    n = nodes_in_deployment(name,attrs)
+    n.reject{ |e| e["admin"] == true } || []
+  end
+
+
+  def find_node_in_deployment(node,deployment,attrs=[])
+    res = self.class.get("/deployments/#{deployment}/nodes", :headers => {'x-return-attributes' => "#{attrs.to_json}" } )
+    res.index{|e|e["name"] == node || e["id"] == node} 
+  end
+
+  def nodes_in_deployment(name,attrs={})
+    self.class.get("/deployments/#{name}/nodes", :headers => attrs )
+  end
+
+  def set_deployment_to_proposed(name)
+    self.class.put("/deployments/#{name}/propose")
+  end
+
+  def ssh_private_key(name)
+    res = self.class.get("nodes/#{name}/attribs/#{attrib}")
+    if res.code != 200
+      raise("Could not get node \"#{name}\" ssh keys")
+    end
+    res
+  end
+
+  def node_status(id)
+    res = self.class.get("http://127.0.0.1:3000/api/status/nodes/#{id}" )
+    if res.code != 200
+      raise("Could not get node status #{res.code} #{res.message}")
+    end
+    res
+  end
+
+  def node_alive?(node_id)
+    n = node(node_id, ['alive'])
+    n["alive"]
+  end 
+
+  def node_ready(node_id,node_role_id)
+    # get noderole state == 0 and runcount >= 1
+    # get node alive = true
+    nr = self.class.get("/node_roles/#{node_role_id}")
+    if nr["state"] == 0 && nr["run_count"] >= 1 && node_alive?(node_id)
+      return true
+    else
+      return false
+    end
+  end
+
+  def set_node(id, data)
+    res = self.class.put("/nodes/#{id}", :body => data)
+    if res.code != 200
+      raise("Could not update node #{res.code} #{res.message}")
+    end
+    return res
+  end
+
+  def node(id,attrs=[])
+    my_head = {}
+    attrs.size > 0 && my_head = { :headers => {'x-return-attributes' => attrs.to_json }  }
+    res = self.class.get("/nodes/#{id}", my_head )
+    if res.code != 200
+      raise("Could not get node \"#{id}\" #{res.code} #{res.message}")
+    end
+    res
+  end
+
+  def node_attrib(id,attrib)
+    res = self.class.get("/nodes/#{id}/attribs/#{attrib}")
+    if res.code != 200
+      raise("Could not get node \"#{id}\" attrib #{attrib} - #{res.code} #{res.message}")
+    end
+    return res
+  end
+
+  def deployment(id,attrs={})
+    res = self.class.get("/deployments/#{id}", :headers => attrs )
+    if res.code != 200
+      raise("Could not get deployment \"#{id}\" #{res.code} #{res.message}")
+    end
+    return res
+  end
+
+  def power(name,action)
+    res = self.class.put("/nodes/#{name}/power?poweraction=#{action}")
+    if res.code != 200
+      raise("Could not power #{action} node #{name}")
+    end
+  end
+
+  def set_node_role_attrib(nr_id, attrib, value)
+    res = self.class.put("/node_roles/#{nr_id}/attribs/#{attrib}", :body => { :value => "#{value}" } )
+    if res.code != 200
+      raise("Could not set node_role #{nr_id} attrib #{attrib} to value #{value}")
+    end
+    res
+  end
+
+  def set_node_attrib(n_id, attrib, value)
+    res = self.class.put("/nodes/#{n_id}/attribs/#{attrib}", :body => { :value => "#{value}" } )
+    if res.code != 200
+      raise("Could not set node #{n_id} attrib #{attrib} to value #{value}: code #{res.code} #{res.message}")
+    end
+    res
+  end
+
+  def bind_node_role(data)
+    raise("Count not bind role to node. #{data}") unless
+      res = self.class.post("/node_roles", :body => data)
+    res['id']
+  end
+
+
+  private
+
+
+#  # connect to the Crowbar API
+#  # this currently AUTHS every call, we need to optimize that so that we can reuse the auth tokens
+#  def authenticate(req,uri,data=nil)
+#    
+#      # build request
+#      request_headers={
+#        "Accept" => "application/json",
+#        "Content-Type" => "application/json"}
+#      #request_headers['x-return-attributes']=$attributes if $attributes
+#      # build URL
+#      uri = URI.parse(@url)
+#      uri.user= @username
+#      uri.password= @password
+#      # starting HTTP session
+#      res=nil
+#      Net::HTTP.start(uri.host, uri.port) {|http|
+#        http.read_timeout = 500
+#        r = http.new(uri.request_uri,request_headers)
+#        r.body = data if data
+#        res = http.request r
+#        debug "(a) return code: #{res.code}"
+#        debug "(a) return body: #{res.body}"
+#        debug "(a) return headers:"
+#        res.each_header do |h, v|
+#          debug "#{h}: #{v}"
+#        end
+#
+#        if res['www-authenticate']
+#          debug "(a) uri: #{uri}"
+#          debug "(a) www-authenticate: #{res['www-authenticate']}"
+#          debug "(a) req-method: #{req::METHOD}"
+#          auth=Net::HTTP::DigestAuth.new.auth_header(uri,
+#                                                     res['www-authenticate'],
+#                                                     req::METHOD)
+#          r.add_field 'Authorization', auth
+#          res = http.request r
+#        end
+#      }
+#    res
+#  end
+#
+#   # Common data and debug handling.
+#  def go(verb,path,data=nil)
+#    uri = URI.parse(@url + API_BASE + path)
+#    # We want to give valid JSON to the API, so if we were
+#    # handed an array or a hash as the data to be messed with,
+#    # turn it into a blob of JSON.
+#    data = data.to_json if data.is_a?(Array) || data.is_a?(Hash)
+#    res = authenticate(verb,uri,data)
+#    debug "(#{verb}) hostname: #{uri.host}:#{uri.port}"
+#    debug "(#{verb}) request: #{uri.path}"
+#    debug "(#{verb}) data: #{data}"
+#    debug "(#{verb}) return code: #{res.code}"
+#    debug "(#{verb}) return body: #{res.body}"
+#    [ JSON.parse(res.body), res.code.to_i ]
+#  end
+#
+#
+
+
+end
+

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: chef-provisioning-crowbar
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Judd Maltin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: chef-provisioning
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  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: 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'
+description: Crowbar is an open-source, multi-purpose node deployment tool.
+email: judd@newgoliath.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/chef/provisioning/crowbar_driver/driver.rb
+- lib/chef/provisioning/crowbar_driver/version.rb
+- lib/chef/provisioning/driver_init/crowbar.rb
+- lib/crowbar/core.rb
+homepage: https://github.com/newgoliath/chef-provisioning-crowbar
+licenses:
+- Apache 2
+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.4.1
+signing_key: 
+specification_version: 4
+summary: Driver for creating Crowbar servers in Chef Provisioning.
+test_files: []
+has_rdoc: