chef-metal-lxc 0.4 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99c02b50b618cb09fbab3b0dd350e97428669196
-  data.tar.gz: a4bfc8a2a18d5dc37b83397d414b8563cd6dfe5b
+  metadata.gz: 222f247414cedb23359fd5b9925b15a4264c8571
+  data.tar.gz: 3b857d0edcb88781b6106b467622d125d8d9c524
 SHA512:
-  metadata.gz: 28e9b881dc2782e2061b70d55a5f97cb68734f57bee784a08110c4c40a05fca05730534ff8bd273cc9add141111e08084b310cdee055798a4ce8e78acb0c02e2
-  data.tar.gz: 0cff384fcab3645a5b2d86f9b16eddea3af5552273d8c209e0594b2d46726c45c90693f9ad6c5560582bcf1464e22f1c001c1b85281a9e0e92360c5a39adac53
+  metadata.gz: 25cb466ac9b171b94dd9c13502000616298a7293557f6f4666ab06f0612b14647fac06c79b8e1650577b090ac9e70ff471972450022f400204562192e6126151
+  data.tar.gz: 6c43f9e2d61768220c81d9c74f0215a86b51eaf24c9ac0f26478eea35f259d892fcab0bca7552124b0d71cfb9c8bb1078cc31c456d54c3a4d37b52cad9280cb5

data/lib/chef_metal/driver_init/lxc.rb

@@ -0,0 +1,3 @@
+require 'chef_metal_lxc/lxc_driver'
+
+ChefMetal.register_driver_class('lxc', ChefMetalLXC::LXCDriver)

data/lib/chef_metal_lxc.rb

@@ -1,2 +1,2 @@
 require 'chef_metal'
-require 'chef_metal_lxc/lxc_provisioner'
+require 'chef_metal_lxc/lxc_driver'

data/lib/chef_metal_lxc/lxc_driver.rb

@@ -0,0 +1,166 @@
+require 'chef/mixin/shell_out'
+require 'chef_metal/driver'
+require 'chef_metal/machine/unix_machine'
+require 'chef_metal/convergence_strategy/install_cached'
+require 'chef_metal_lxc/lxc_transport'
+require 'chef_metal_lxc/version'
+require 'lxc'
+require 'shellwords'
+
+module ChefMetalLXC
+  # Provisions machines in lxc.
+  class LXCDriver < ChefMetal::Driver
+
+    include Chef::Mixin::ShellOut
+
+    # URL scheme:
+    # lxc:<path>
+    # <path> defaults to LXC config 'lxc.lxcpath'
+    # canonical URL calls realpath on <path>
+    def self.from_url(driver_url, config)
+      LXCDriver.new(driver_url, config)
+    end
+
+    def self.canonicalize_url(driver_url, config)
+      scheme, lxc_path = driver_url.split(':', 2)
+      if lxc_path.nil? || lxc_path == ':'
+        lxc_path = LXC.global_config_item('lxc.lxcpath')
+      end
+      lxc_path = File.realpath(lxc_path)
+      [ "lxc:#{lxc_path}", config ]
+    end
+
+    def initialize(driver_url, config)
+      super
+    end
+
+    def lxc_path
+      scheme, lxc_path = driver_url.split(':', 2)
+      lxc_path
+    end
+
+    # Valid machine options:
+    # :template - template name
+    # :template_options - additional arguments for templates
+    # :backingstore - backing storage (lvm, thinpools, btrfs etc)
+    # :config_file - <path> path to LXC  file a la https://wiki.archlinux.org/index.php/Linux_Containers#Configuration_file
+    # :extra_config - { 'key' => 'value', ... } a set of LXC config key/value pairs to individually set.  Merges with, and overrides any values in config_file.
+    def allocate_machine(action_handler, machine_spec, machine_options)
+      # Create the container if it does not exist
+      if machine_spec.location
+        ct = LXC::Container.new(machine_spec.location['name'], lxc_path)
+      else
+        ct = LXC::Container.new(machine_spec.name, lxc_path)
+        if ct.defined?
+          # Should this be a warning? Configurable, at least.
+          raise "container #{machine_spec.name} already exists and is not managed by this LXC driver."
+        end
+      end
+
+      unless ct.defined?
+        action_handler.perform_action "create lxc container #{ct.name}" do
+          #
+          # Set config
+          #
+          # TODO if config file changes, reload container?
+          if machine_options[:config_file]
+            ct.load_config(machine_options[:config_file])
+          end
+          if machine_options[:extra_config]
+            machine_options[:extra_config].each_pair do |key, value|
+              ct.set_config_item(key, value)
+            end
+          end
+
+          #
+          # Create the machine
+          #
+          ct.create(machine_options[:template], machine_options[:backingstore], machine_options[:devspecs], 0, machine_options[:template_options])
+
+          machine_spec.location = {
+            'driver_url' => driver_url,
+            'driver_version' => ChefMetalLXC::VERSION,
+            'name' => machine_spec.name,
+            'host_node' => action_handler.host_node,
+            'allocated_at' => Time.now.utc.to_s
+          }
+        end
+      end
+    end
+
+    def ready_machine(action_handler, machine_spec, machine_options)
+      ct = LXC::Container.new(machine_spec.location['name'], lxc_path)
+
+      # Unfreeze the frozen
+      if ct.state == :frozen
+        action_handler.perform_action "unfreeze lxc container #{machine_spec.location['name']} (state is #{ct.state})" do
+          ct.unfreeze
+        end
+      end
+
+      # Get stopped containers running
+      unless ct.running?
+        action_handler.perform_action "start lxc container #{machine_spec.location['name']} (state is #{ct.state})" do
+          # Have to shell out to lxc-start for now, ct.start holds server sockets open!
+          lxc_start = "lxc-start -d -n #{Shellwords.escape(machine_spec.location['name'])}"
+# TODO add ability to change options on start
+#          if machine_options[:config_file]
+#            lxc_start << " -f #{Shellwords.escape(machine_options[:config_file])}"
+#          end
+#          if machine_options[:extra_config]
+#            machine_options[:extra_config].each_pair do |key,value|
+#              lxc_start << " -s #{Shellwords.escape("#{key}=#{value}")}"
+#            end
+#          end
+          shell_out!(lxc_start)
+#          ct.start
+        end
+      end
+
+      # Create machine object for callers to use
+      machine_for(machine_spec, machine_options)
+    end
+
+    # Connect to machine without acquiring it
+    def connect_to_machine(machine_spec, machine_options)
+      machine_for(machine_spec, machine_options)
+    end
+
+    def destroy_machine(action_handler, machine_spec, machine_options)
+      if machine_spec.location
+        ct = LXC::Container.new(machine_spec.location['name'], lxc_path)
+        if ct.defined?
+          action_handler.perform_action "delete lxc container #{machine_spec.location['name']}" do
+            ct.destroy
+          end
+        end
+      end
+      convergence_strategy_for(machine_spec, machine_options).cleanup_convergence(action_handler, machine_spec)
+    end
+
+    def stop_machine(action_handler, node)
+      if machine_spec.location
+        ct = LXC::Container.new(machine_spec.location['name'], lxc_path)
+        if ct.running?
+          action_handler.perform_action "delete lxc container #{machine_spec.location['name']}" do
+            ct.stop
+          end
+        end
+      end
+    end
+
+    protected
+
+    def machine_for(machine_spec, machine_options)
+      ChefMetal::Machine::UnixMachine.new(machine_spec, transport_for(machine_spec), convergence_strategy_for(machine_spec, machine_options))
+    end
+
+    def convergence_strategy_for(machine_spec, machine_options)
+      ChefMetal::ConvergenceStrategy::InstallCached.new(machine_options[:convergence_options], config)
+    end
+
+    def transport_for(machine_spec)
+      ChefMetalLXC::LXCTransport.new(machine_spec.location['name'], lxc_path)
+    end
+  end
+end

data/lib/chef_metal_lxc/lxc_transport.rb

@@ -25,7 +25,7 @@ module ChefMetalLXC
       @options = options
       @name = name
       @lxc_path = lxc_path
-      @port_forwards = []
+      @port_forwards = {}
       @@active_transports << self
     end
 
@@ -43,7 +43,7 @@ module ChefMetalLXC
 
     def execute(command, options = {})
       Chef::Log.info("Executing #{command} on #{name}")
-      container.execute do
+      container.execute(:timeout => (execute_timeout(options) || 0)) do
         begin
           # TODO support streaming (shell out needs work)
           out = shell_out(command)
@@ -57,33 +57,37 @@ module ChefMetalLXC
     def make_url_available_to_remote(local_url)
       uri = URI(local_url)
       host = Socket.getaddrinfo(uri.host, uri.scheme, nil, :STREAM)[0][3]
-      if host == '127.0.0.1' || host == '[::1]'
-
-        Chef::Log.debug("Forwarding container port #{uri.port} to local port #{uri.port}")
-        # Create the channel that will let the container and the host talk to each other
-        channel = LXC::Extra::Channel.new
+      if host == '127.0.0.1' || host == '::1'
+        unless @port_forwards[uri.port]
+
+          Chef::Log.debug("Forwarding container port #{uri.port} to local port #{uri.port}")
+          # Create the channel that will let the container and the host talk to each other
+          channel = LXC::Extra::Channel.new
+
+          # Start the container side of the proxy, listening for client connections
+          pid = container.attach do
+            begin
+              server = TCPServer.new(host, uri.port)
+              proxy = LXC::Extra::ProxyClientSide.new(channel, server)
+              proxy.start
+            rescue
+              Chef::Log.error("ERROR in proxy (container side): #{$!}\n#{$!.backtrace.join("\n")}")
+              raise
+            end
+          end
 
-        # Start the container side of the proxy, listening for client connections
-        pid = container.attach do
-          begin
-            server = TCPServer.new('127.0.0.1', uri.port)
-            proxy = LXC::Extra::ProxyClientSide.new(channel, server)
+          # Start the host side of the proxy, which contacts the real server
+          thread = Thread.new do
+            proxy = LXC::Extra::ProxyServerSide.new(channel) do
+              TCPSocket.new(host, uri.port)
+            end
             proxy.start
-          rescue
-            Chef::Log.error("ERROR in proxy (container side): #{$!}\n#{$!.backtrace.join("\n")}")
-            raise
           end
-        end
 
-        # Start the host side of the proxy, which contacts the real server
-        thread = Thread.new do
-          proxy = LXC::Extra::ProxyServerSide.new(channel) do
-            TCPSocket.new('127.0.0.1', uri.port)
-          end
-          proxy.start
-        end
+          Chef::Log.debug("Forwarded #{uri.port} on container #{name} to local port #{uri.port}.  Container listener id PID #{pid}")
 
-        @port_forwards << [ pid, thread, channel ]
+          @port_forwards[uri.port] = [ pid, thread, channel ]
+        end
 
       end
       local_url
@@ -111,8 +115,10 @@ module ChefMetalLXC
     end
 
     def disconnect
-      @port_forwards.each do |pid, thread, channel|
+      @port_forwards.each_pair do |port, (pid, thread, channel)|
+        Chef::Log.debug("stopping port forward #{port} for container #{name}")
         begin
+          Chef::Log.debug("Killing PID #{pid}")
           Process.kill('KILL', pid)
         rescue
         end
@@ -121,7 +127,7 @@ module ChefMetalLXC
         rescue
         end
       end
-      @port_forwards = []
+      @port_forwards = {}
       @@active_transports.delete(self)
     end
 

data/lib/chef_metal_lxc/version.rb

@@ -1,3 +1,3 @@
 module ChefMetalLXC
-  VERSION = '0.4'
+  VERSION = '0.5'
 end

metadata

@@ -1,109 +1,103 @@
 --- !ruby/object:Gem::Specification
 name: chef-metal-lxc
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: '0.5'
 platform: ruby
 authors:
 - Ranjib Dey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-08 00:00:00.000000000 Z
+date: 2014-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
   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-metal
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.11'
 - !ruby/object:Gem::Dependency
   name: ruby-lxc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: lxc-extra
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.3
 - !ruby/object:Gem::Dependency
   name: rspec
   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: 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: Provisioner for creating LXC containers in Chef Metal.
@@ -114,13 +108,14 @@ extra_rdoc_files:
 - README.md
 - LICENSE
 files:
-- Rakefile
 - LICENSE
 - README.md
-- lib/chef_metal_lxc/lxc_provisioner.rb
+- Rakefile
+- lib/chef_metal/driver_init/lxc.rb
+- lib/chef_metal_lxc.rb
+- lib/chef_metal_lxc/lxc_driver.rb
 - lib/chef_metal_lxc/lxc_transport.rb
 - lib/chef_metal_lxc/version.rb
-- lib/chef_metal_lxc.rb
 homepage: https://github.com/opscode/chef-metal-lxc
 licenses: []
 metadata: {}
@@ -130,17 +125,17 @@ 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.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Provisioner for creating LXC containers in Chef Metal.

data/lib/chef_metal_lxc/lxc_provisioner.rb

@@ -1,164 +0,0 @@
-require 'chef/mixin/shell_out'
-require 'chef_metal/provisioner'
-require 'chef_metal/machine/unix_machine'
-require 'chef_metal/convergence_strategy/install_cached'
-require 'chef_metal_lxc/lxc_transport'
-require 'lxc'
-require 'shellwords'
-
-module ChefMetalLXC
-  # Provisions machines in lxc.
-  class LXCProvisioner < ChefMetal::Provisioner
-
-    include Chef::Mixin::ShellOut
-
-    def initialize(lxc_path = nil)
-      @lxc_path = lxc_path || LXC.global_config_item('lxc.lxcpath')
-    end
-
-    attr_reader :lxc_path
-
-    #
-    # 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
-    # action_handler - the action_handler object that provides context.
-    # 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)
-    #           -- config_file: <path> path to LXC  file a la https://wiki.archlinux.org/index.php/Linux_Containers#Configuration_file
-    #           -- extra_config: { 'key' => 'value', ... } a set of LXC config key/value pairs to individually set.  Merges with, and overrides any values in config_file.
-    #
-    #        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>
-    #           -- name: container name
-    #
-    def acquire_machine(action_handler, 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}",
-        'name' => node['name']
-      }
-
-      # Create the container if it does not exist
-      ct = LXC::Container.new(provisioner_output['name'], lxc_path)
-      unless ct.defined?
-        action_handler.perform_action "create lxc container #{provisioner_output['name']}" do
-          #
-          # Set config
-          #
-          # TODO if config file changes, reload container?
-          if provisioner_options['config_file']
-            ct.load_config(provisioner_options['config_file'])
-          end
-          if provisioner_options['extra_config']
-            provisioner_options['extra_config'].each_pair do |key, value|
-              ct.set_config_item(key, value)
-            end
-          end
-
-          #
-          # Create the machine
-          #
-          ct.create(provisioner_options['template'], provisioner_options['backingstore'], 0, provisioner_options['template_options'])
-        end
-      end
-
-      # Unfreeze the frozen
-      if ct.state == :frozen
-        action_handler.perform_action "unfreeze lxc container #{provisioner_output['name']} (state is #{ct.state})" do
-          ct.unfreeze
-        end
-      end
-
-      # Get stopped containers running
-      unless ct.running?
-        action_handler.perform_action "start lxc container #{provisioner_output['name']} (state is #{ct.state})" do
-          # Have to shell out to lxc-start for now, ct.start holds server sockets open!
-          lxc_start = "lxc-start -d -n #{Shellwords.escape(provisioner_output['name'])}"
-# TODO add ability to change options on start
-#          if provisioner_options['config_file']
-#            lxc_start << " -f #{Shellwords.escape(provisioner_options['config_file'])}"
-#          end
-#          if provisioner_options['extra_config']
-#            provisioner_options['extra_config'].each_pair do |key,value|
-#              lxc_start << " -s #{Shellwords.escape("#{key}=#{value}")}"
-#            end
-#          end
-          shell_out!(lxc_start)
-#          ct.start
-        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(action_handler, node)
-      if node['normal'] && node['normal']['provisioner_output']
-        provisioner_output = node['normal']['provisioner_output']
-        ct = LXC::Container.new(provisioner_output['name'], lxc_path)
-        if ct.defined?
-          action_handler.perform_action "delete lxc container #{provisioner_output['name']}" do
-            ct.destroy
-          end
-        end
-      end
-      convergence_strategy_for(node).delete_chef_objects(action_handler, node)
-    end
-
-    def stop_machine(action_handler, 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)
-        if ct.running?
-          action_handler.perform_action "delete lxc container #{provisioner_output['name']}" do
-            ct.stop
-          end
-        end
-      end
-    end
-
-    protected
-
-    def machine_for(node)
-      ChefMetal::Machine::UnixMachine.new(node, transport_for(node), convergence_strategy_for(node))
-    end
-
-    def convergence_strategy_for(node)
-      @convergence_strategy ||= begin
-        ChefMetal::ConvergenceStrategy::InstallCached.new
-      end
-    end
-
-    def transport_for(node)
-      provisioner_output = node['normal']['provisioner_output']
-      ChefMetalLXC::LXCTransport.new(provisioner_output['name'], lxc_path)
-    end
-  end
-end