chef-metal 0.14.2 → 0.15

data/lib/chef_metal/driver.rb

@@ -1,288 +1 @@
-module ChefMetal
-  #
-  # A Driver instance represents a place where machines can be created and found,
-  # and contains methods to create, delete, start, stop, and find them.
-  #
-  # For AWS, a Driver instance corresponds to a single account.
-  # For Vagrant, it is a directory where VM files are found.
-  #
-  # == How to Make a Driver
-  #
-  # To implement a Driver, you must implement the following methods:
-  #
-  # - initialize(driver_url) - create a new driver with the given URL
-  # - driver_url - a URL representing everything unique about your driver.
-  #                But NOT credentials.
-  # - allocate_machine - ask the driver to allocate a machine to you.
-  # - ready_machine - get the machine "ready" - wait for it to be booted and
-  #                   accessible (for example, accessible via SSH transport).
-  # - stop_machine - stop the machine.
-  # - destroy_machine - delete the machine.
-  # - connect_to_machine - connect to the given machine.
-  #
-  # Optionally, you can also implement:
-  # - allocate_machines - allocate an entire group of machines.
-  # - ready_machines - get a group of machines warm and booted.
-  # - stop_machines - stop a group of machines.
-  # - destroy_machines - delete a group of machines.
-  #
-  # Additionally, you must create a file named `chef_metal/driver_init/<scheme>.rb`,
-  # where <scheme> is the name of the scheme you chose for your driver_url. This
-  # file, when required, must call ChefMetal.add_registered_driver(<scheme>, <class>).
-  # The given <class>.from_url(url, config) will be called with a driver_url and
-  # configuration.
-  #
-  # All of these methods must be idempotent - if the work is already done, they
-  # just don't do anything.
-  #
-  class Driver
-    #
-    # Inflate a driver from a driver URL.
-    #
-    # == Parameters
-    # driver_url - the URL to inflate the driver
-    # config - a configuration hash.  See "config" for a list of known keys.
-    #
-    # == Returns
-    # A Driver representing the given driver_url.
-    #
-    def initialize(driver_url, config)
-      @driver_url = driver_url
-      @config = config
-    end
-
-    #
-    # Override this on specific driver classes
-    #
-    def self.from_url(driver_url, config)
-      ChefMetal.from_url(driver_url, config)
-    end
-
-    #
-    # A URL representing the driver and the place where machines come from.
-    # This will be stuffed in machine_spec.location['driver_url'] so that the
-    # machine can be reinflated.  URLs must have a unique scheme identifying the
-    # driver class, and enough information to identify the place where created
-    # machines can be found.  For AWS, this is the account number; for lxc and
-    # vagrant, it is the directory in which VMs and containers are.
-    #
-    # For example:
-    # - fog:AWS:123456789012
-    # - vagrant:/var/vms
-    # - lxc:
-    # - docker:
-    #
-    attr_reader :driver_url
-
-    # A configuration hash.  These keys may be present:
-    #   - :driver_options: a driver-defined object containing driver config.
-    #   - :private_keys: a hash of private keys, with a "name" and a "value".  Values are either strings (paths) or PrivateKey objects.
-    #   - :private_key_paths: a list of paths to directories containing private keys.
-    #   - :write_private_key_path: the path to which we write new keys by default.
-    #   - :log_level: :debug/:info/:warn/:error/:fatal
-    #   - :chef_server_url: url to chef server
-    #   - :node_name: username to talk to chef server
-    #   - :client_key: path to key used to talk to chef server
-    attr_reader :config
-
-    #
-    # Driver configuration. Equivalent to config[:driver_options] || {}
-    #
-    def driver_options
-      config[:driver_options] || {}
-    end
-
-    #
-    # Allocate a machine from the PXE/cloud/VM/container driver.  This method
-    # does not need to wait for the machine to boot or have an IP, but it must
-    # store enough information in machine_spec.location to find the machine
-    # later in ready_machine.
-    #
-    # If a machine is powered off or otherwise unusable, this method may start
-    # it, but does not need to wait until it is started.  The idea is to get the
-    # gears moving, but the job doesn't need to be done :)
-    #
-    # ## Parameters
-    # action_handler - the action_handler object that is calling this method; this
-    #        is generally a driver, but could be anything that can support the
-    #        interface (i.e., in the case of the test kitchen metal driver for
-    #        acquiring and destroying VMs).
-    #
-    # existing_machine - a MachineSpec representing the existing machine (if any).
-    #
-    # machine_options - a set of options representing the desired provisioning
-    #                   state of the machine (image name, bootstrap ssh credentials,
-    #                   etc.). This will NOT be stored in the machine_spec, and is
-    #                   ephemeral.
-    #
-    # ## Returns
-    #
-    # Modifies the passed-in machine_spec.  Anything in here will be saved
-    # back after allocate_machine completes.
-    #
-    def allocate_machine(action_handler, machine_spec, machine_options)
-      raise "#{self.class} does not implement allocate_machine"
-    end
-
-    #
-    # Ready a machine, to the point where it is running and accessible via a
-    # transport. This will NOT allocate a machine, but may kick it if it is down.
-    # This method waits for the machine to be usable, returning a Machine object
-    # pointing at the machine, allowing useful actions like setup, converge,
-    # execute, file and directory.
-    #
-    # ## Parameters
-    # action_handler - the action_handler object that is calling this method; this
-    #        is generally a driver, but could be anything that can support the
-    #        interface (i.e., in the case of the test kitchen metal driver for
-    #        acquiring and destroying VMs).
-    # machine_spec - MachineSpec representing this machine.
-    # machine_options - a set of options representing the desired provisioning
-    #                   state of the machine (image name, bootstrap ssh credentials,
-    #                   etc.). This will NOT be stored in the machine_spec, and is
-    #                   ephemeral.
-    #
-    # ## Returns
-    #
-    # Machine object pointing at the machine, allowing useful actions like setup,
-    # converge, execute, file and directory.
-    #
-    def ready_machine(action_handler, machine_spec, machine_options)
-      raise "#{self.class} does not implement ready_machine"
-    end
-
-    #
-    # Connect to a machine without allocating or readying it.  This method will
-    # NOT make any changes to anything, or attempt to wait.
-    #
-    # ## Parameters
-    # machine_spec - MachineSpec representing this machine.
-    #
-    # ## Returns
-    #
-    # Machine object pointing at the machine, allowing useful actions like setup,
-    # converge, execute, file and directory.
-    #
-    def connect_to_machine(machine_spec, machine_options)
-      raise "#{self.class} does not implement connect_to_machine"
-    end
-
-    #
-    # Delete the given machine (idempotent).  Should destroy the machine,
-    # returning things to the state before allocate_machine was called.
-    #
-    def destroy_machine(action_handler, machine_spec, machine_options)
-      raise "#{self.class} does not implement destroy_machine"
-    end
-
-    #
-    # Stop the given machine.
-    #
-    def stop_machine(action_handler, machine_spec, machine_options)
-      raise "#{self.class} does not implement stop_machine"
-    end
-
-    #
-    # Allocate an image. Returns quickly with an ID that tracks the image.
-    #
-    def allocate_image(action_handler, image_spec, image_options, machine_spec)
-      raise "#{self.class} does not implement create_image"
-    end
-
-    #
-    # Ready an image, waiting till the point where it is ready to be used.
-    #
-    def ready_image(action_handler, image_spec, image_options)
-      raise "#{self.class} does not implement ready_image"
-    end
-
-    #
-    # Destroy an image.
-    #
-    def destroy_image(action_handler, image_spec, image_options)
-      raise "#{self.class} does not implement destroy_image"
-    end
-
-    #
-    # Optional interface methods
-    #
-
-    #
-    # Allocate a set of machines.  This should have the same effect as running
-    # allocate_machine on all machine_specs.
-    #
-    # Drivers do not need to implement this; the default implementation
-    # calls acquire_machine in parallel.
-    #
-    # ## Parameters
-    # action_handler - the action_handler object that is calling this method; this
-    #        is generally a driver, but could be anything that can support the
-    #        interface (i.e., in the case of the test kitchen metal driver for
-    #        acquiring and destroying VMs).
-    # specs_and_options - a hash of machine_spec -> machine_options representing the
-    #                 machines to allocate.
-    # parallelizer - an object with a parallelize() method that works like this:
-    #
-    #   parallelizer.parallelize(specs_and_options) do |machine_spec|
-    #     allocate_machine(action_handler, machine_spec)
-    #   end.to_a
-    #   # The to_a at the end causes you to wait until the parallelization is done
-    #
-    # This object is shared among other chef-metal actions, ensuring that you do
-    # not go over parallelization limits set by the user.  Use of the parallelizer
-    # to parallelizer machines is not required.
-    #
-    # ## Block
-    #
-    # If you pass a block to this function, each machine will be yielded to you
-    # as it completes, and then the function will return when all machines are
-    # yielded.
-    #
-    #   allocate_machines(action_handler, specs_and_options, parallelizer) do |machine_spec|
-    #     ...
-    #   end
-    #
-    def allocate_machines(action_handler, specs_and_options, parallelizer)
-      parallelizer.parallelize(specs_and_options) do |machine_spec, machine_options|
-        allocate_machine(add_prefix(machine_spec, action_handler), machine_spec, machine_options)
-        yield machine_spec if block_given?
-        machine_spec
-      end.to_a
-    end
-
-    # Ready machines in batch, in parallel if possible.
-    def ready_machines(action_handler, specs_and_options, parallelizer)
-      parallelizer.parallelize(specs_and_options) do |machine_spec, machine_options|
-        machine = ready_machine(add_prefix(machine_spec, action_handler), machine_spec, machine_options)
-        yield machine if block_given?
-        machine
-      end.to_a
-    end
-
-    # Stop machines in batch, in parallel if possible.
-    def stop_machines(action_handler, specs_and_options, parallelizer)
-      parallelizer.parallelize(specs_and_options) do |machine_spec, machine_options|
-        stop_machine(add_prefix(machine_spec, action_handler), machine_spec, machine_options)
-        yield machine_spec if block_given?
-      end.to_a
-    end
-
-    # Delete machines in batch, in parallel if possible.
-    def destroy_machines(action_handler, specs_and_options, parallelizer)
-      parallelizer.parallelize(specs_and_options) do |machine_spec, machine_options|
-        destroy_machine(add_prefix(machine_spec, action_handler), machine_spec, machine_options)
-        yield machine_spec if block_given?
-      end.to_a
-    end
-
-    protected
-
-    def add_prefix(machine_spec, action_handler)
-      AddPrefixActionHandler.new(action_handler, "[#{machine_spec.name}] ")
-    end
-
-    def get_private_key(name)
-      Cheffish.get_private_key(name, config)
-    end
-  end
-end
+require "chef/provisioning/driver"

data/lib/chef_metal/image_spec.rb

@@ -1,70 +1 @@
-module ChefMetal
-  #
-  # Specification for a image. Sufficient information to find and contact it
-  # after it has been set up.
-  #
-  class ImageSpec
-    def initialize(image_data)
-      @image_data = image_data
-    end
-
-    attr_reader :image_data
-
-    #
-    # Globally unique identifier for this image. Does not depend on the image's
-    # location or existence.
-    #
-    def id
-      raise "id unimplemented"
-    end
-
-    #
-    # Name of the image. Corresponds to the name in "image 'name' do" ...
-    #
-    def name
-      image_data['id']
-    end
-
-    #
-    # Location of this image. This should be a freeform hash, with enough
-    # information for the driver to look it up and create a image object to
-    # access it.
-    #
-    # This MUST include a 'driver_url' attribute with the driver's URL in it.
-    #
-    # chef-metal will do its darnedest to not lose this information.
-    #
-    def location
-      image_data['location']
-    end
-
-    #
-    # Set the location for this image.
-    #
-    def location=(value)
-      image_data['location'] = value
-    end
-
-    def machine_options
-      image_data['machine_options']
-    end
-
-    def machine_options=(value)
-      image_data['machine_options'] = value
-    end
-
-    # URL to the driver.  Convenience for location['driver_url']
-    def driver_url
-      location ? location['driver_url'] : nil
-    end
-
-    #
-    # Save this image_data to the server.  If you have significant information that
-    # could be lost, you should do this as quickly as possible.  image_data will be
-    # saved automatically for you after allocate_image and ready_image.
-    #
-    def save(action_handler)
-      raise "save unimplemented"
-    end
-  end
-end
+require "chef/provisioning/image_spec"

data/lib/chef_metal/machine.rb

@@ -1,110 +1 @@
-module ChefMetal
-  class Machine
-    def initialize(machine_spec)
-      @machine_spec = machine_spec
-    end
-
-    attr_reader :machine_spec
-
-    def name
-      machine_spec.name
-    end
-
-    def node
-      machine_spec.node
-    end
-
-    # Sets up everything necessary for convergence to happen on the machine.
-    # The node MUST be saved as part of this procedure.  Other than that,
-    # nothing is guaranteed except that converge() will work when this is done.
-    def setup_convergence(action_handler)
-      raise "setup_convergence not overridden on #{self.class}"
-    end
-
-    def converge(action_handler)
-      raise "converge not overridden on #{self.class}"
-    end
-
-    def cleanup_convergence(action_handler)
-      raise "cleanup_convergence not overridden on #{self.class}"
-    end
-
-    def execute(action_handler, command, options = {})
-      raise "execute not overridden on #{self.class}"
-    end
-
-    def execute_always(command, options = {})
-      raise "execute_always not overridden on #{self.class}"
-    end
-
-    def read_file(path)
-      raise "read_file not overridden on #{self.class}"
-    end
-
-    def download_file(action_handler, path, local_path)
-      raise "read_file not overridden on #{self.class}"
-    end
-
-    def write_file(action_handler, path, content)
-      raise "write_file not overridden on #{self.class}"
-    end
-
-    def upload_file(action_handler, local_path, path)
-      raise "write_file not overridden on #{self.class}"
-    end
-
-    def create_dir(action_handler, path)
-      raise "create_dir not overridden on #{self.class}"
-    end
-
-    # Delete file
-    def delete_file(action_handler, path)
-      raise "delete_file not overridden on #{self.class}"
-    end
-
-    # Return true if directory, false/nil if not
-    def is_directory?(path)
-      raise "is_directory? not overridden on #{self.class}"
-    end
-
-    # Return true or false depending on whether file exists
-    def file_exists?(path)
-      raise "file_exists? not overridden on #{self.class}"
-    end
-
-    # Return true or false depending on whether remote file differs from local path or content
-    def files_different?(path, local_path, content=nil)
-      raise "file_different? not overridden on #{self.class}"
-    end
-
-    # Set file attributes { mode, :owner, :group }
-    def set_attributes(action_handler, path, attributes)
-      raise "set_attributes not overridden on #{self.class}"
-    end
-
-    # Get file attributes { :mode, :owner, :group }
-    def get_attributes(path)
-      raise "get_attributes not overridden on #{self.class}"
-    end
-
-    # Ensure the given URL can be reached by the remote side (possibly by port forwarding)
-    # Must return the URL that the remote side can use to reach the local_url
-    def make_url_available_to_remote(local_url)
-      raise "make_url_available_to_remote not overridden on #{self.class}"
-    end
-
-    def disconnect
-      raise "disconnect not overridden on #{self.class}"
-    end
-
-    # TODO get rid of the action_handler 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(action_handler)
-    # 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(action_handler)
-      raise "detect_os not overridden on #{self.class}"
-    end
-  end
-end
+require "chef/provisioning/machine"