chef-metal 0.2.1 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3002d430afde46610d70663bf72b42f7740b6b3b
-  data.tar.gz: b8f8311dc26ae7c0fa756704479169f170c6e47d
+  metadata.gz: b141298163e702535479301b6c88044960e65cc0
+  data.tar.gz: 64383c31616aa7fce1f7785d41134b6516d9b51d
 SHA512:
-  metadata.gz: 4f2e703168cdc5f97e35270a432f1ba88544f87cb0e5e4863bde5f81dff0ab5df96c5bfc790ec5f53743c616bb928ea73e7c0f29df48816f66028706089bb8e6
-  data.tar.gz: 04318115c38fe30f91fa386f0e5cc43791c474a4b442e0ad5e54f29780b338bde865c66f4d17ff0a2842ac65024e2599c197a1fcd2f4a9038d89272cd88c0951
+  metadata.gz: b86349e657a31e3594823b7036aac2c6fd2e5cf2e629da6d1db58a4069502a494bade45142d19db91533cfa66b698600c78f910955cf18a9d8ea0d5754c0e812
+  data.tar.gz: 2dbcb57bdfac12bea0e67c0da47b05a6f9cdc77415d14169820244f4c1ec3172ddc227e19a91f686ae39cc134394fbe11d82d66db9501a3ddbe5ee2b0b3fcba3

data/README.md

@@ -120,10 +120,10 @@ chef-metal also comes with a [Fog](http://fog.io/) provisioner that handles prov
 Once your credentials are in, basic usage looks like this:
 
 ```
-chef-client -z -o myapp::vagrant,myapp::small
+chef-client -z -o myapp::ec2,myapp::small
 ```
 
-The provisioner definition in `myapp::vagrant` looks like this:
+The provisioner definition in `myapp::ec2` looks like this:
 
 ```ruby
 ec2testdir = File.expand_path('~/ec2test')

data/lib/chef_metal/convergence_strategy/install_cached.rb

@@ -0,0 +1,121 @@
+require 'chef_metal/convergence_strategy/precreate_chef_objects'
+require 'pathname'
+require 'fileutils'
+require 'digest/md5'
+require 'thread'
+
+module ChefMetal
+  class ConvergenceStrategy
+    class InstallCached < PrecreateChefObjects
+      def initialize(options = {})
+        @client_rb_path ||= '/etc/chef/client.rb'
+        @client_pem_path ||= '/etc/chef/client.pem'
+        @chef_version ||= options[:chef_version]
+        @prerelease ||= options[:prerelease]
+        @package_cache_path ||= options[:package_cache_path] || "#{ENV['HOME']}/.chef/package_cache"
+        @package_cache = {}
+        @tmp_dir = '/tmp'
+        FileUtils.mkdir_p(@package_cache_path)
+        @download_lock = Mutex.new
+      end
+
+      def setup_convergence(provider, machine, machine_resource)
+        super
+
+        # Install chef-client.  TODO check and update version if not latest / not desired
+        if machine.execute_always('chef-client -v').exitstatus != 0
+          platform, platform_version, machine_architecture = machine.detect_os(provider)
+          package_file = download_package_for_platform(provider, machine, platform, platform_version, machine_architecture)
+          remote_package_file = "#{@tmp_dir}/#{File.basename(package_file)}"
+          machine.upload_file(provider, package_file, remote_package_file)
+          install_package(provider, machine, remote_package_file)
+        end
+      end
+
+      def converge(provider, machine)
+        machine.execute(provider, 'chef-client')
+      end
+
+      private
+
+      def download_package_for_platform(provider, machine, platform, platform_version, machine_architecture)
+        @package_cache_lock.synchronize do
+          @package_cache ||= {}
+          @package_cache[platform] ||= {}
+          @package_cache[platform][platform_version] ||= {}
+          @package_cache[platform][platform_version][machine_architecture] ||= { :lock => Mutex.new }
+        end
+        @package_cache[platform][platform_version][machine_architecture][:lock].synchronize do
+          if !@package_cache[platform][platform_version][machine_architecture][:file]
+            #
+            # Grab metadata
+            #
+            metadata = download_metadata_for_platform(machine, platform, platform_version, machine_architecture)
+
+            # Download actual package desired by metadata
+            package_file = "#{@package_cache_path}/#{URI(metadata['url']).path.split('/')[-1]}"
+
+            ChefMetal.inline_resource(provider) do
+              remote_file package_file do
+                source metadata['url']
+                checksum metadata['sha256']
+              end
+            end
+
+            @package_cache[platform][platform_version][machine_architecture][:file] = package_file
+          end
+        end
+        @package_cache[platform][platform_version][machine_architecture][:file]
+      end
+
+      def download_metadata_for_platform(machine, platform, platform_version, machine_architecture)
+        #
+        # Figure out the URL to the metadata
+        #
+        metadata_url="https://www.opscode.com/chef/metadata"
+        metadata_url << "?v=#{@chef_version}"
+        metadata_url << "&prerelease=#{@prerelease ? 'true' : 'false'}"
+        metadata_url << "&p=#{platform}"
+        metadata_url << "&pv=#{platform_version}"
+        metadata_url << "&m=#{machine_architecture}"
+
+        # solaris 9 lacks openssl, solaris 10 lacks recent enough credentials - your base O/S is completely insecure, please upgrade
+        if platform == 'solaris2' && (platform_version == '5.9' || platform_version == '5.10')
+          metadata_url.sub(/^https/, 'http')
+        end
+
+        # Download and parse the metadata
+        Chef::Log.debug("Getting metadata for machine #{machine.node['name']}: #{metadata_url}")
+        metadata_str = Net::HTTP.get(URI(metadata_url))
+        metadata = {}
+        metadata_str.each_line do |line|
+          key, value = line.split("\t", 2)
+          metadata[key] = value
+        end
+        metadata
+      end
+
+      def install_package(provider, machine, remote_package_file)
+        extension = File.extname(remote_package_file)
+        result = case extension
+        when '.rpm'
+          machine.execute(provider, "rpm -Uvh --oldpackage --replacepkgs \"#{remote_package_file}\"")
+        when '.deb'
+          machine.execute(provider, "dpkg -i \"#{remote_package_file}\"")
+        when '.solaris'
+          machine.write_file(provider, "#{@tmp_dir}/nocheck", <<EOM)
+conflict=nocheck
+action=nocheck
+mail=
+EOM
+          machine.execute(provider, "pkgrm -a \"#{@tmp_dir}/nocheck\" -n chef")
+          machine.execute(provider, "pkgadd -n -d \"#{remote_package_file}\" -a \"#{@tmp_dir}/nocheck\" chef")
+        when '.sh'
+          machine.execute(provider, "sh \"#{remote_package_file}\"")
+        else
+          raise "Unknown package extension '#{extension}' for file #{remote_package_file}"
+        end
+      end
+    end
+  end
+end

data/lib/chef_metal/convergence_strategy/precreate_chef_objects.rb

@@ -68,7 +68,7 @@ module ChefMetal
           end
 
         else
-  
+
           # If the server does not already have keys, create them and upload
           Cheffish.inline_resource(provider) do
             private_key 'in_memory' do
@@ -109,13 +109,6 @@ module ChefMetal
       def create_chef_objects(provider, machine, machine_resource, public_key)
         # Save the node and create the client keys and client.
         ChefMetal.inline_resource(provider) do
-          # Create node
-          # TODO strip automatic attributes first so we don't race with "current state"
-          chef_node machine.node['name'] do
-            chef_server machine_resource.chef_server
-            raw_json machine.node
-          end
-
           # Create client
           chef_client machine.node['name'] do
             chef_server machine_resource.chef_server
@@ -125,6 +118,15 @@ module ChefMetal
             admin machine_resource.admin
             validator machine_resource.validator
           end
+
+          # Create node
+          # TODO strip automatic attributes first so we don't race with "current state"
+          chef_node machine.node['name'] do
+            chef_server machine_resource.chef_server
+            raw_json machine.node
+          end
+
+
         end
       end
 

data/lib/chef_metal/fog.rb

@@ -2,3 +2,15 @@ require 'chef_metal'
 require 'chef/resource/fog_key_pair'
 require 'chef/provider/fog_key_pair'
 require 'chef_metal/provisioner/fog_provisioner'
+
+class Chef
+  class Recipe
+    def with_fog_provisioner(options = {}, &block)
+      ChefMetal.with_provisioner(ChefMetal::Provisioner::FogProvisioner.new(options, &block))
+    end
+
+    def with_fog_ec2_provisioner(options = {}, &block)
+      with_fog_provisioner({ :provider => 'AWS' }.merge(options), &block)
+    end
+  end
+end

data/lib/chef_metal/machine.rb

@@ -75,5 +75,15 @@ module ChefMetal
     def disconnect
       raise "disconnect not overridden on #{self.class}"
     end
+
+    # TODO get rid of the provider attribute, that is ridiculous
+    # Detect the OS on the machine (assumes the machine is up)
+    # Returns a triplet:
+    #   platform, platform_version, machine_architecture = machine.detect_os(provider)
+    # This triplet is suitable for passing to the Chef metadata API:
+    # https://www.opscode.com/chef/metadata?p=#{platform}&pv=#{platform_version}&m=#{machine_architecture}
+    def detect_os(provider)
+      raise "detect_os not overridden on #{self.class}"
+    end
   end
 end

data/lib/chef_metal/machine/basic_machine.rb

@@ -76,4 +76,4 @@ module ChefMetal
       end
     end
   end
-end
+end

data/lib/chef_metal/machine/unix_machine.rb

@@ -6,6 +6,8 @@ module ChefMetal
     class UnixMachine < BasicMachine
       def initialize(node, transport, convergence_strategy)
         super
+
+        @tmp_dir = '/tmp'
       end
 
       # Options include:
@@ -104,5 +106,169 @@ module ChefMetal
         path.split('/')[0..-2].join('/')
       end
     end
+
+    def detect_os(provider)
+      #
+      # Use detect.sh to detect the operating system of the remote machine
+      #
+      # TODO do this in terms of commands rather than writing a shell script
+      self.write_file(provider, "#{@tmp_dir}/detect.sh", detect_sh)
+      detected = self.execute_always("sh #{@tmp_dir}/detect.sh")
+      if detected.exitstatus != 0
+        raise "detect.sh exited with nonzero exit status: #{detected.exitstatus}"
+      end
+      platform = nil
+      platform_version = nil
+      machine_architecture = nil
+      detected.stdout.each_line do |line|
+        if line =~ /^PLATFORM: (.+)/
+          platform = $1
+        elsif line =~ /^PLATFORM_VERSION: (.+)/
+          platform_version = $1
+        elsif line =~ /^MACHINE: (.+)/
+          machine_architecture = $1
+        end
+      end
+      [ platform, platform_version, machine_architecture ]
+    end
+
+    private
+
+    def detect_sh
+      result = <<EOM
+prerelease="false"
+
+project="chef"
+
+report_bug() {
+echo "Please file a bug report at http://tickets.opscode.com"
+echo "Project: Chef"
+echo "Component: Packages"
+echo "Label: Omnibus"
+echo "Version: $version"
+echo " "
+echo "Please detail your operating system type, version and any other relevant details"
+}
+
+
+machine=`uname -m`
+os=`uname -s`
+
+# Retrieve Platform and Platform Version
+if test -f "/etc/lsb-release" && grep -q DISTRIB_ID /etc/lsb-release; then
+platform=`grep DISTRIB_ID /etc/lsb-release | cut -d "=" -f 2 | tr '[A-Z]' '[a-z]'`
+platform_version=`grep DISTRIB_RELEASE /etc/lsb-release | cut -d "=" -f 2`
+elif test -f "/etc/debian_version"; then
+platform="debian"
+platform_version=`cat /etc/debian_version`
+elif test -f "/etc/redhat-release"; then
+platform=`sed 's/^\(.\+\) release.*/\1/' /etc/redhat-release | tr '[A-Z]' '[a-z]'`
+platform_version=`sed 's/^.\+ release \([.0-9]\+\).*/\1/' /etc/redhat-release`
+
+# If /etc/redhat-release exists, we act like RHEL by default
+if test "$platform" = "fedora"; then
+# Change platform version for use below.
+platform_version="6.0"
+fi
+platform="el"
+elif test -f "/etc/system-release"; then
+platform=`sed 's/^\(.\+\) release.\+/\1/' /etc/system-release | tr '[A-Z]' '[a-z]'`
+platform_version=`sed 's/^.\+ release \([.0-9]\+\).*/\1/' /etc/system-release | tr '[A-Z]' '[a-z]'`
+# amazon is built off of fedora, so act like RHEL
+if test "$platform" = "amazon linux ami"; then
+platform="el"
+platform_version="6.0"
+fi
+# Apple OS X
+elif test -f "/usr/bin/sw_vers"; then
+platform="mac_os_x"
+# Matching the tab-space with sed is error-prone
+platform_version=`sw_vers | awk '/^ProductVersion:/ { print $2 }'`
+
+major_version=`echo $platform_version | cut -d. -f1,2`
+case $major_version in
+"10.6") platform_version="10.6" ;;
+"10.7"|"10.8"|"10.9") platform_version="10.7" ;;
+*) echo "No builds for platform: $major_version"
+ report_bug
+ exit 1
+ ;;
+esac
+
+# x86_64 Apple hardware often runs 32-bit kernels (see OHAI-63)
+x86_64=`sysctl -n hw.optional.x86_64`
+if test $x86_64 -eq 1; then
+machine="x86_64"
+fi
+elif test -f "/etc/release"; then
+platform="solaris2"
+machine=`/usr/bin/uname -p`
+platform_version=`/usr/bin/uname -r`
+elif test -f "/etc/SuSE-release"; then
+if grep -q 'Enterprise' /etc/SuSE-release;
+then
+platform="sles"
+platform_version=`awk '/^VERSION/ {V = $3}; /^PATCHLEVEL/ {P = $3}; END {print V "." P}' /etc/SuSE-release`
+else
+platform="suse"
+platform_version=`awk '/^VERSION =/ { print $3 }' /etc/SuSE-release`
+fi
+elif test "x$os" = "xFreeBSD"; then
+platform="freebsd"
+platform_version=`uname -r | sed 's/-.*//'`
+elif test "x$os" = "xAIX"; then
+platform="aix"
+platform_version=`uname -v`
+machine="ppc"
+fi
+
+if test "x$platform" = "x"; then
+echo "Unable to determine platform version!"
+report_bug
+exit 1
+fi
+
+# Mangle $platform_version to pull the correct build
+# for various platforms
+major_version=`echo $platform_version | cut -d. -f1`
+case $platform in
+"el")
+platform_version=$major_version
+;;
+"debian")
+case $major_version in
+"5") platform_version="6";;
+"6") platform_version="6";;
+"7") platform_version="6";;
+esac
+;;
+"freebsd")
+platform_version=$major_version
+;;
+"sles")
+platform_version=$major_version
+;;
+"suse")
+platform_version=$major_version
+;;
+esac
+
+if test "x$platform_version" = "x"; then
+echo "Unable to determine platform version!"
+report_bug
+exit 1
+fi
+
+if test "x$platform" = "xsolaris2"; then
+# hack up the path on Solaris to find wget
+PATH=/usr/sfw/bin:$PATH
+export PATH
+fi
+
+echo "PLATFORM: $platform"
+echo "PLATFORM_VERSION: $platform_version"
+echo "MACHINE: $machine"
+EOM
+    end
   end
-end
+end

data/lib/chef_metal/provisioner/fog_provisioner.rb

@@ -213,7 +213,7 @@ module ChefMetal
       def delete_machine(provider, node)
         if node['normal']['provisioner_output'] && node['normal']['provisioner_output']['server_id']
           server = compute.servers.get(node['normal']['provisioner_output']['server_id'])
-          provider.converge_by "destroy machine #{node['name']} (#{server.id} at #{provisioner_url}" do
+          provider.converge_by "destroy machine #{node['name']} (#{node['normal']['provisioner_output']['server_id']} at #{provisioner_url})" do
             server.destroy
           end
           convergence_strategy_for(node).delete_chef_objects(provider, node)
@@ -345,11 +345,15 @@ module ChefMetal
 
       def convergence_strategy_for(node)
         if node['normal']['provisioner_options'] && node['normal']['provisioner_options']['is_windows']
-          require 'chef_metal/convergence_strategy/install_msi'
-          ChefMetal::ConvergenceStrategy::InstallMsi.new
+          @windows_convergence_strategy ||= begin
+            require 'chef_metal/convergence_strategy/install_msi'
+            ChefMetal::ConvergenceStrategy::InstallMsi.new
+          end
         else
-          require 'chef_metal/convergence_strategy/install_sh'
-          ChefMetal::ConvergenceStrategy::InstallSh.new
+          @unix_convergence_strategy ||= begin
+            require 'chef_metal/convergence_strategy/install_cached'
+            ChefMetal::ConvergenceStrategy::InstallCached.new
+          end
         end
       end
 
@@ -377,7 +381,7 @@ module ChefMetal
       def create_ssh_transport(server)
         require 'chef_metal/transport/ssh'
 
-        ssh_options, options = ssh_options_for(server)
+        ssh_options = ssh_options_for(server)
         # If we're on AWS, the default is to use ubuntu, not root
         if compute_options[:provider] == 'AWS'
           username = compute_options[:ssh_username] || 'ubuntu'

data/lib/chef_metal/provisioner/vagrant_provisioner.rb

@@ -221,11 +221,15 @@ module ChefMetal
 
       def convergence_strategy_for(node)
         if vagrant_option(node, 'vm.guest').to_s == 'windows'
-          require 'chef_metal/convergence_strategy/install_msi'
-          ChefMetal::ConvergenceStrategy::InstallMsi.new
+          @windows_convergence_strategy ||= begin
+            require 'chef_metal/convergence_strategy/install_msi'
+            ChefMetal::ConvergenceStrategy::InstallMsi.new
+          end
         else
-          require 'chef_metal/convergence_strategy/install_sh'
-          ChefMetal::ConvergenceStrategy::InstallSh.new
+          @unix_convergence_strategy ||= begin
+            require 'chef_metal/convergence_strategy/install_cached'
+            ChefMetal::ConvergenceStrategy::InstallCached.new
+          end
         end
       end
 
@@ -324,4 +328,4 @@ module ChefMetal
       end
     end
   end
-end
+end

data/lib/chef_metal/recipe_dsl.rb

@@ -1,5 +1,4 @@
 require 'chef_metal'
-require 'chef_metal/provisioner/fog_provisioner'
 
 class Chef
   class Recipe
@@ -10,21 +9,5 @@ class Chef
     def with_provisioner_options(provisioner_options, &block)
       ChefMetal.with_provisioner_options(provisioner_options, &block)
     end
-
-    def with_vagrant_cluster(cluster_path, &block)
-      ChefMetal.with_vagrant_cluster(cluster_path, &block)
-    end
-
-    def with_vagrant_box(box_name, vagrant_options = {}, &block)
-      ChefMetal.with_vagrant_box(box_name, vagrant_options, &block)
-    end
-
-    def with_fog_provisioner(options = {}, &block)
-      ChefMetal.with_provisioner(ChefMetal::Provisioner::FogProvisioner.new(options, &block))
-    end
-
-    def with_fog_ec2_provisioner(options = {}, &block)
-      with_fog_provisioner({ :provider => 'AWS' }.merge(options), &block)
-    end
   end
 end

data/lib/chef_metal/vagrant.rb

@@ -25,3 +25,15 @@ module ChefMetal
     with_provisioner_options(provisioner_options, &block)
   end
 end
+
+class Chef
+  class Recipe
+    def with_vagrant_cluster(cluster_path, &block)
+      ChefMetal.with_vagrant_cluster(cluster_path, &block)
+    end
+
+    def with_vagrant_box(box_name, vagrant_options = {}, &block)
+      ChefMetal.with_vagrant_box(box_name, vagrant_options, &block)
+    end
+  end
+end

data/lib/chef_metal/version.rb

@@ -1,3 +1,3 @@
 module ChefMetal
-  VERSION = '0.2.1'
+  VERSION = '0.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: '0.3'
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-07 00:00:00.000000000 Z
+date: 2014-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -130,6 +130,7 @@ files:
 - lib/chef/resource/vagrant_box.rb
 - lib/chef/resource/vagrant_cluster.rb
 - lib/chef_metal/aws_credentials.rb
+- lib/chef_metal/convergence_strategy/install_cached.rb
 - lib/chef_metal/convergence_strategy/install_msi.rb
 - lib/chef_metal/convergence_strategy/install_sh.rb
 - lib/chef_metal/convergence_strategy/precreate_chef_objects.rb
@@ -141,11 +142,9 @@ files:
 - lib/chef_metal/machine/windows_machine.rb
 - lib/chef_metal/machine.rb
 - lib/chef_metal/provisioner/fog_provisioner.rb
-- lib/chef_metal/provisioner/lxc_provisioner.rb
 - lib/chef_metal/provisioner/vagrant_provisioner.rb
 - lib/chef_metal/provisioner.rb
 - lib/chef_metal/recipe_dsl.rb
-- lib/chef_metal/transport/lxc.rb
 - lib/chef_metal/transport/ssh.rb
 - lib/chef_metal/transport/winrm.rb
 - lib/chef_metal/transport.rb

data/lib/chef_metal/provisioner/lxc_provisioner.rb

@@ -1,135 +0,0 @@
-require 'chef/mixin/shell_out'
-require 'chef_metal/provisioner'
-require 'lxc'
-
-module ChefMetal
-  class Provisioner
-
-    # Provisions machines in lxc.
-    class LXCProvisioner < Provisioner
-
-      include Chef::Mixin::ShellOut
-
-      #
-      # 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.  The Machine object will have a
-      # "node" property which must be saved to the server (if it is any
-      # different from the original node object).
-      #
-      # ## Parameters
-      # provider - the provider object that is calling this method.
-      # node - node object (deserialized json) representing this machine.  If
-      #        the node has a provisioner_options hash in it, these will be used
-      #        instead of options provided by the provisioner.  TODO compare and
-      #        fail if different?
-      #        node will have node['normal']['provisioner_options'] in it with any options.
-      #        It is a hash with this format:
-      #
-      #           -- provisioner_url: lxc:<lxc_path>
-      #           -- template: template name
-      #           -- template_options: additional arguments for templates
-      #           -- backingstore: backing storage (lvm, thinpools, btrfs etc)
-      #
-      #        node['normal']['provisioner_output'] will be populated with information
-      #        about the created machine.  For lxc, it is a hash with this
-      #        format:
-      #
-      #           -- provisioner_url: lxc://<lxc_path>
-      #           -- lxc_path: path to lxc root
-      #           -- name: container name
-      #
-      def acquire_machine(provider, node)
-        # TODO verify that the existing provisioner_url in the node is the same as ours
-
-        # Set up the modified node data
-        provisioner_options = node['normal']['provisioner_options']
-        provisioner_output = node['normal']['provisioner_output'] || {
-          'provisioner_url' =>   "lxc://#{lxc_path_for(node)}",
-          'name' => node['name']
-        }
-
-
-        # Create the container if it does not exist
-        ct = LXC::Container.new(provisioner_output['name'], lxc_path_for(node))
-        unless ct.defined?
-          provider.converge_by "create lxc container #{provisioner_output['name']}" do
-            ct.create(provisioner_options['template'], provisioner_options['backingstore'], 0, provisioner_options['template_options'])
-          end
-        end
-        unless ct.running?
-          provider.converge_by "start lxc container #{provisioner_output['name']}" do
-            ct.start
-            while ct.ip_addresses.empty?
-              sleep 1 # wait till dhcp ip allocation is done
-            end
-          end
-        end
-
-        if true # do a check on whether sshd is installed.  This is idempotency!
-          provider.converge_by "install ssh into container #{provisioner_output['name']}" do
-          end
-        end
-
-        node['normal']['provisioner_output'] = provisioner_output
-
-        # Create machine object for callers to use
-        machine_for(node)
-      end
-
-      # Connect to machine without acquiring it
-      def connect_to_machine(node)
-        machine_for(node)
-      end
-
-      def delete_machine(provider, node)
-        if node['normal'] && node['normal']['provisioner_output']
-          provisioner_output = node['normal']['provisioner_output']
-          ct = LXC::Container.new(provisioner_output['name'], lxc_path_for(node))
-          if ct.defined?
-            provider.converge_by "delete lxc container #{provisioner_output['name']}" do
-              ct.destroy
-            end
-          end
-        end
-        convergence_strategy_for(node).delete_chef_objects(provider, node)
-      end
-
-      def stop_machine(provider, node)
-        provisioner_options = node['normal']['provisioner_options']
-        if node['normal'] && node['normal']['provisioner_output']
-          provisioner_output = node['normal']['provisioner_output']
-          ct = LXC::Container.new(provisioner_output['name'], lxc_path_for(node))
-          if ct.running?
-            provider.converge_by "delete lxc container #{provisioner_output['name']}" do
-              ct.stop
-            end
-          end
-        end
-      end
-
-      protected
-
-      def lxc_path_for(node)
-        provisioner_options = node['normal']['provisioner_options']
-        provisioner_options['lxc_path']  || LXC.global_config_item('lxc.lxcpath')
-      end
-
-      def machine_for(node)
-        require 'chef_metal/machine/unix_machine'
-        ChefMetal::Machine::UnixMachine.new(node, transport_for(node), convergence_strategy_for(node))
-      end
-
-      def convergence_strategy_for(node)
-        require 'chef_metal/convergence_strategy/install_sh'
-        ChefMetal::ConvergenceStrategy::InstallSh.new
-      end
-
-      def transport_for(node)
-        require 'chef_metal/transport/lxc'
-        provisioner_output = node['normal']['provisioner_output']
-        ChefMetal::Transport::LXCTransport.new(provisioner_output['name'], lxc_path_for(node))
-      end
-    end
-  end
-end

data/lib/chef_metal/transport/lxc.rb

@@ -1,90 +0,0 @@
-require 'chef_metal/transport'
-require 'lxc/extra'
-require 'chef/mixin/shell_out'
-
-module ChefMetal
-  class Transport
-    class LXCTransport < Transport
-
-      class LXCExecuteResult < Struct.new(:stdout, :stderr, :exitstatus)
-        def error!
-          raise "Error: code #{exitstatus}.\nSTDOUT:#{stdout}\nSTDERR:#{stderr}" if exitstatus != 0
-        end
-      end
-
-      attr_reader :name, :options, :lxc_path
-
-      include Chef::Mixin::ShellOut
-
-      def initialize(name, lxc_path, options={})
-        @options = options
-        @name = name
-        @lxc_path = lxc_path
-      end
-
-      def ct
-        @container ||= LXC::Container.new(name, lxc_path)
-      end
-
-      def rootfs
-        ct.config_item('lxc.rootfs')
-      end
-
-      def ct_path(path)
-        File.join(rootfs, path)
-      end
-
-      def execute(command)
-        Chef::Log.info("Executing #{command} on #{name}")
-        res = ct.execute do
-                begin
-                  out = shell_out(command)
-                  LXCExecuteResult.new(out.stdout,out.stderr, out.exitstatus)
-                rescue Exception => e
-                  LXCExecuteResult.new('', e.message, -1)
-                end
-              end
-        res
-      end
-
-      def forward_remote_port_to_local(remote_port, local_port)
-        warn 'Port forwarding is not implemented in lxc transport'
-        warn "You can do this on host using:"
-        warn "   'iptables -t nat -A PREROUTING -p tcp --dport #{remote_port} -j DNAT --to #{ct.ip_addresses.first}:#{local_port}'"
-      end
-
-      def read_file(path)
-        if File.exists?(ct_path(path))
-          File.read(ct_path(path))
-        end
-      end
-
-      def download_file(path, local_path)
-        Chef::Log.debug("Copying file #{path} from #{name} to local #{local_path}")
-        FileUtils.cp_r(ct_path(path), local_path)
-      end
-
-      def write_file(path, content)
-        File.open(ct_path(path), 'w') do |f|
-          f.write(content)
-        end
-      end
-
-      def upload_file(local_path, path)
-        FileUtils.cp_r(local_path, ct_path(path))
-      end
-
-      def disconnect
-      end
-
-      def available?
-        begin
-          execute('pwd')
-          true
-        rescue Exception =>e
-          false
-        end
-      end
-    end
-  end
-end