cm 0.1.4 → 0.1.6

data/lib/core/plugin/batch.rb

@@ -1,11 +1,7 @@
 
-nucleon_require(File.dirname(__FILE__), :parallel_base)
-
-#---
-
 module CM
 module Plugin
-class Batch < Nucleon.plugin_class(:nucleon, :parallel_base)
+class Batch < Nucleon.plugin_class(:nucleon, :base)
 
   #-----------------------------------------------------------------------------
   # Plugin interface
@@ -13,24 +9,24 @@ class Batch < Nucleon.plugin_class(:nucleon, :parallel_base)
   def normalize(reload)
     super
 
-    @sequence = delete(:sequence, nil)
+    @plan = delete(:plan, nil) unless reload
 
-    init_jobs
+    init_resources
     yield if block_given?
   end
 
   #---
 
-  def init_jobs
-    @jobs = []
-    get_array(:jobs).each do |job_config|
-      if job_config.has_key?(:sequence) # Array
-        @jobs << sequence.create_sequence(job_config[:sequence])
+  def init_resources
+    @resources = []
+    get_array(:resources).each do |resource_config|
+      if resource_config.has_key?(:sequence) # Array
+        @resources << plan.create_sequence(resource_config[:sequence])
       else # Atomic
-        @jobs << sequence.create_job(job_config)
+        @resources << plan.create_resource(resource_config)
       end
     end
-    @jobs
+    @resources
   end
 
   #-----------------------------------------------------------------------------
@@ -43,30 +39,30 @@ class Batch < Nucleon.plugin_class(:nucleon, :parallel_base)
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
 
-  def sequence
-    @sequence
+  def plan
+    @plan
   end
 
   #---
 
-  def jobs
-    @jobs
+  def resources
+    @resources
   end
 
-  def jobs=jobs
-    set(:jobs, array(jobs))
-    init_jobs
+  def resources=resources
+    set(:resources, array(resources))
+    init_resources
   end
 
   #-----------------------------------------------------------------------------
   # Operations
 
-  def execute
+  def execute(operation)
     if initialized?
       if Nucleon.parallel?
-        success = execute_parallel
+        success = execute_parallel(operation)
       else
-        success = execute_sequence
+        success = execute_sequence(operation)
       end
     else
       success = false
@@ -77,17 +73,17 @@ class Batch < Nucleon.plugin_class(:nucleon, :parallel_base)
   #-----------------------------------------------------------------------------
   # Utilities
 
-  def execute_parallel
+  def execute_parallel(operation)
     false # Override me!!
   end
 
   #---
 
-  def execute_sequence
+  def execute_sequence(operation)
     success = true
-    jobs.each do |job|
-      success = false unless job.execute
-      break if sequence.trap && sequence.step
+    resources.each do |resource|
+      success = false unless resource.execute(operation)
+      break if plan.trap && plan.step
     end
     success
   end

data/lib/core/plugin/configuration.rb

@@ -1,11 +1,7 @@
 
-nucleon_require(File.dirname(__FILE__), :parallel_base)
-
-#---
-
 module CM
 module Plugin
-class Configuration < Nucleon.plugin_class(:nucleon, :parallel_base)
+class Configuration < Nucleon.plugin_class(:nucleon, :base)
 
   include Nucleon::Mixin::SubConfig
 

data/lib/core/plugin/docker_resource.rb

@@ -0,0 +1,315 @@
+
+nucleon_require(File.dirname(__FILE__), :resource)
+
+#---
+
+module CM
+module Plugin
+class DockerResource < Nucleon.plugin_class(:CM, :resource)
+
+  #-----------------------------------------------------------------------------
+  # Plugin interface
+
+  def normalize(reload)
+    require 'docker'
+    super
+
+    codes :docker_exec_failed
+
+    settings[:docker_protocol] ||= 'unix'
+    settings[:docker_sock] ||= '/var/run/docker.sock'
+    settings[:docker_host] ||= nil
+    settings[:docker_port] ||= '127.0.0.1'
+    settings[:docker_image] ||= 'awebb/cm'
+
+    if settings[:docker_host].nil?
+      Docker.url = "#{settings[:docker_protocol]}://#{settings[:docker_sock]}"
+    else
+      Docker.url = "#{settings[:docker_protocol]}://#{settings[:docker_host]}:#{settings[:docker_port]}"
+    end
+
+    yield if block_given?
+  end
+
+  #---
+
+  def remove_plugin
+    destroy_container(plugin_instance_name)
+  end
+
+  #-----------------------------------------------------------------------------
+  # Checks
+
+  def initialized?(options = {})
+    true
+  end
+
+  #---
+
+  def internal?
+    File.exist?('/.dockerinit')
+  end
+
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+
+  def image
+    get(:image, 'awebb/cm').to_s
+  end
+
+  #---
+
+  def startup_commands
+    get(:startup_commands, ['bash'])
+  end
+
+  #---
+
+  def container
+    @container
+  end
+
+  #---
+
+  def plan_directory
+    get(:plan_directory, '/opt/cm/volumes/plan')
+  end
+
+  def key_directory
+    get(:key_directory, '/opt/cm/volumes/keys')
+  end
+
+  #---
+
+  def host_input_directory
+    get(:host_input_directory, "/tmp/cm/input/#{plugin_instance_name}")
+  end
+
+  def input_directory
+    get(:input_directory, '/opt/cm/volumes/input')
+  end
+
+  #---
+
+  def host_output_directory
+    get(:host_output_directory, "/tmp/cm/output/#{plugin_instance_name}")
+  end
+
+  def output_directory
+    get(:output_directory, '/opt/cm/volumes/output')
+  end
+
+  #-----------------------------------------------------------------------------
+  # Operations
+
+  def operation_deploy
+    super do
+      data = nil
+
+      # A fork in the road!
+      if internal?
+        data = yield if block_given?
+      else
+        data = action(plugin_provider, :deploy)
+        myself.status = code.docker_exec_failed unless data
+      end
+      myself.data = data
+      myself.status == code.success
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Docker resource operation execution
+
+  def exec(command)
+    data = nil
+
+    create_container
+
+    results = container.exec(['bash', '-l', '-c', command]) do |stream, message|
+      unless message.match(/stdin\:\s+is not a tty/)
+        render_docker_message(stream, message)
+        yield(stream, message) if block_given?
+      end
+    end
+
+    if results[2] == 0
+      if output_config = CM.configuration(extended_config(:resource_results, {
+        :provider => get(:resource_result_provider, :directory),
+        :path => host_output_directory
+      }))
+        data = Nucleon::Util::Data.clone(output_config.export)
+        Nucleon.remove_plugin(output_config)
+      end
+    end
+
+    destroy_container
+    data
+  end
+
+  #---
+
+  def command(command, options = {})
+    config         = Nucleon::Config.ensure(options)
+    remove_command = false
+
+    unless command.is_a?(Nucleon::Plugin::Command)
+      command        = Nucleon.command(Nucleon::Config.new({ :command => command }, {}, true, false).import(config), :bash)
+      remove_command = true
+    end
+
+    data = exec(command.to_s.strip) do |stream, message|
+      yield(stream, message) if block_given?
+    end
+
+    Nucleon.remove_plugin(command) if remove_command
+    data
+  end
+
+  #---
+
+  def action(provider, operation)
+    FileUtils.mkdir_p(host_input_directory)
+    FileUtils.mkdir_p(host_output_directory)
+
+    action_settings = Nucleon::Util::Data.clean(plan.action_settings)
+    initialize_remote_config(action_settings)
+
+    encoded_config = Nucleon::Util::CLI.encode(action_settings)
+    action_config  = extended_config(:action, {
+      :command => 'resource run',
+      :data    => { :encoded  => encoded_config },
+      :args    => [ provider, operation ]
+    })
+    action_config[:data][:log_level] = Nucleon.log_level if Nucleon.log_level
+
+    data = command('cm', Nucleon::Util::Data.clean({
+      :subcommand => action_config,
+      :quiet      => Nucleon::Util::Console.quiet
+    })) do |stream, message|
+      yield(stream, message) if block_given?
+    end
+
+    FileUtils.rm_rf(host_input_directory)
+    FileUtils.rm_rf(host_output_directory)
+    data
+  end
+
+  #-----------------------------------------------------------------------------
+  # Utilities
+
+  def create_container
+    container = nil
+
+    destroy_container
+
+    container_env = []
+    container_env << "NUCLEON_NO_PARALLEL=1" unless Nucleon.parallel?
+    container_env << "NUCLEON_NO_COLOR=1" unless Nucleon::Util::Console.use_colors
+
+    @container = Docker::Container.create({
+      'name' => plugin_instance_name,
+      'Image' => image,
+      'Cmd' => array(startup_commands),
+      'Tty' => true,
+      'Env' => container_env,
+      'Volumes' => {
+        plan_directory => {},
+        key_directory => {},
+        input_directory => {},
+        output_directory => {}
+      },
+      'HostConfig' => {
+        'Binds' => [
+          "#{plan.path}:#{plan_directory}:ro",
+          "#{plan.key_directory}:#{key_directory}:rw",
+          "#{host_input_directory}:#{input_directory}:ro", # config.yaml and tokens.json
+          "#{host_output_directory}:#{output_directory}:rw" # ??.yaml and/or ??.json
+        ]
+      }
+    })
+
+    if @container
+      @container.start!
+    else
+      error('cm.resource.docker.error.container_failed', {
+        :image => image
+      })
+    end
+  end
+  protected :create_container
+
+  #---
+
+  def initialize_remote_config(action_settings)
+    # Generate action settings file
+    settings = CM.configuration(extended_config(:container_input_settings_data, {
+      :provider => get(:container_input_settings_provider, :file),
+      :path => "#{host_input_directory}/action_settings.json"
+    }))
+    settings.import(action_settings)
+    settings.save
+
+    Nucleon.remove_plugin(settings)
+
+    # Generate and store plan configuration in local input directory
+    config = CM.configuration(extended_config(:container_input_config_data, {
+      :provider => get(:container_input_config_provider, :file),
+      :path => "#{host_input_directory}/config.json"
+    }))
+    config.import(plan.manifest_config)
+    config.save
+
+    Nucleon.remove_plugin(config)
+
+    # Generate and store plan tokens in local input directory
+    tokens = CM.configuration(extended_config(:container_input_token_data, {
+      :provider => get(:container_input_token_provider, :file),
+      :path => "#{host_output_directory}/tokens.json"
+    }))
+    tokens.import(plan.tokens)
+    tokens.save
+
+    Nucleon.remove_plugin(tokens)
+
+    # Customize action settings
+    action_settings[:resource_config] = myself.settings
+    action_settings[:settings_path] = "#{input_directory}/action_settings.json"
+    action_settings[:plan_path] = plan_directory
+    action_settings[:config_provider] = 'file'
+    action_settings[:config_path] = "#{input_directory}/config.json"
+    action_settings[:token_provider] = 'file'
+    action_settings[:token_path] = output_directory
+    action_settings[:token_file] = 'tokens.json'
+    action_settings[:key_path] = key_directory
+  end
+  protected :initialize_remote_config
+
+
+  #---
+
+  def destroy_container
+    containers = Docker::Container.all({ :all => 1 })
+
+    containers.each do |cont|
+      if cont.info.key?('Names') && cont.info['Names'].include?("/#{plugin_instance_name}")
+        cont.kill!
+        cont.remove
+      end
+    end
+    @container = nil
+  end
+  protected :destroy_container
+
+  #---
+
+  def render_docker_message(stream, message)
+    if stream == 'stderr'
+      puts message
+    else
+      puts message
+    end
+  end
+end
+end
+end

data/lib/core/plugin/plan.rb

@@ -7,6 +7,10 @@ module CM
 module Plugin
 class Plan < Nucleon.plugin_class(:CM, :disk_configuration)
 
+  include Nucleon::Parallel  # All sub providers are parallel capable
+
+  #---
+
   def self.register_ids
     [ :directory, :revision ]
   end
@@ -17,50 +21,67 @@ class Plan < Nucleon.plugin_class(:CM, :disk_configuration)
   def normalize(reload)
     super
 
-    @project = Nucleon.project(extended_config(:plan_project, {
-      :provider       => _get(:project_provider, Nucleon.type_default(:nucleon, :project)),
-      :directory      => _get(:path, Dir.pwd),
-      :url            => _get(:url),
-      :revision       => _get(:revision, :master),
-      :create         => true,
-      :pull           => true,
-      :nucleon_resave => false,
-      :nucleon_cache  => false,
-      :nucleon_file   => false
-    }))
-
-    if project && !reload
+    if !reload
       @loaded_config = CM.configuration(extended_config(:config_data, {
         :provider => _get(:config_provider, :directory),
-        :path => config_directory
+        :path => config_path
+      }))
+
+      @tokens = CM.configuration(extended_config(:token_data, {
+        :provider => _get(:token_provider, :file),
+        :path => token_path
       }))
 
       yield if block_given?
     end
   end
 
+  #---
+
+  def init_tokens
+    clear_tokens
+
+    collect_tokens = lambda do |local_settings, token|
+      local_settings.each do |name, value|
+        setting_token = [ array(token), name ].flatten
+
+        if value.is_a?(Hash)
+          collect_tokens.call(value, setting_token)
+        else
+          token_base = setting_token.shift
+          set_token(token_base, setting_token, value)
+        end
+      end
+    end
+
+    # Generate config tokens
+    collect_tokens.call(manifest_config, 'config')
+  end
+
   #-----------------------------------------------------------------------------
   # Checks
 
   def initialized?(options = {})
-    project && loaded_config
+    loaded_config
   end
 
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
 
-  def project
-    @project
-  end
-
   def loaded_config
     @loaded_config
   end
 
   #---
 
+  def action_settings
+    _get(:action_settings, {})
+  end
+
+  #---
+
   def path
-    project.directory
+    _get(:path, Dir.pwd)
   end
 
   def key_directory
@@ -85,39 +106,60 @@ class Plan < Nucleon.plugin_class(:CM, :disk_configuration)
     get_hash(:config)
   end
 
-  def manifest_jobs
-    get_array(:jobs)
+  def manifest_resources
+    get_array(:resources)
+  end
+
+  #---
+
+  def config_path
+    _get(:config_path, path)
   end
 
   #---
 
-  def config_directory
-    _get(:config_directory, path)
+  def sequence
+    @sequence
   end
 
-  def output_file
-    _get(:output_file, "rendered.#{manifest_file.gsub(/#{File::SEPARATOR}+/, '.')}")
+  #---
+
+  def token_directory
+    _get(:token_directory, config_path)
   end
 
-  def target_path
-    ::File.join(config_directory, output_file)
+  def token_file
+    _get(:token_file, 'tokens.json')
   end
 
+  def token_path
+    ::File.join(token_directory, token_file)
+  end
 
   #---
 
-  def url
-    project.url
+  def tokens
+    @tokens.parse
   end
 
-  def revision
-    project.revision
+  def set_token(id, location, value)
+    @tokens["#{id}:#{array(location).join('.')}"] = value
+    @tokens.save
+  end
+
+  def remove_token(id, location)
+    @tokens.delete("#{id}:#{array(location).join('.')}")
+    @tokens.save
+  end
+
+  def clear_tokens
+    @tokens.wipe
   end
 
   #---
 
-  def sequence
-    @sequence
+  def trap
+    _get(:trap, false)
   end
 
   #-----------------------------------------------------------------------------
@@ -127,7 +169,7 @@ class Plan < Nucleon.plugin_class(:CM, :disk_configuration)
     success = true
 
     if initialized?
-      # Initialize plan manifest (default config and jobs)
+      # Initialize plan manifest (default config and resources)
       wipe
       import(CM.configuration(extended_config(:manifest_data, {
         :provider => _get(:manifest_provider, :file),
@@ -137,12 +179,8 @@ class Plan < Nucleon.plugin_class(:CM, :disk_configuration)
       # Merge in configuration overlay (private config)
       override(loaded_config.get_hash(:config), :config)
 
-      # Initialize job sequence
-      @sequence = CM.sequence({
-        :jobs => manifest_jobs,
-        :settings => manifest_config,
-        :trap => _get(:trap, false)
-      }, _get(:sequence_provider, :default))
+      # Initializeresource sequence
+      @sequence = create_sequence(manifest_resources)
 
       yield if block_given?
     end
@@ -151,14 +189,17 @@ class Plan < Nucleon.plugin_class(:CM, :disk_configuration)
 
   #---
 
-  def execute(operation, options = {})
+  def execute(operation)
     success = true
 
     if initialized?
       if ::File.exist?(manifest_path)
         method = "operation_#{operation}"
-        success = send(method, options) if respond_to?(method) && load
-        success = save if success
+
+        if respond_to?(method) && load
+          init_tokens
+          success = send(method)
+        end
         success
       else
         error('manifest_file', { :file => manifest_path })
@@ -172,27 +213,57 @@ class Plan < Nucleon.plugin_class(:CM, :disk_configuration)
 
   #---
 
-  def operation_deploy(options)
-    config = Nucleon::Config.ensure(options)
-    sequence.forward(config)
+  def operation_deploy
+    sequence.forward(:deploy)
   end
 
   #---
 
-  def operation_destroy(options)
-    config = Nucleon::Config.ensure(options)
-    sequence.reverse(config)
+  def operation_destroy
+    sequence.reverse(:destroy)
+  end
+
+  #-----------------------------------------------------------------------------
+  # Utilities
+
+  def create_sequence(resources)
+    CM.sequence({
+      :plan => myself,
+      :settings => manifest_config,
+      :resources => resources,
+      :new => true,
+    }, _get(:sequence_provider, :default))
   end
 
   #---
 
-  def save
-    save_config(target_path, { :config => manifest_config })
+  def create_batch(resources)
+    CM.batch({
+      :plan => myself,
+      :resources => resources,
+      :new => true
+    }, _get(:batch_provider, :celluloid))
   end
 
-  #-----------------------------------------------------------------------------
-  # Utilities
+  #---
 
+  def create_resource(settings)
+    settings = Nucleon::Config.ensure(settings)
+    settings[:type] ||= _get(:default_resource_provider, :variables)
+
+    CM.resource({
+      :plan => myself,
+      :settings => settings.export,
+      :id => settings[:name]
+    }, settings[:type])
+  end
+
+  #---
+
+  def step
+    answer = ask('Continue? (yes|no): ', { :i18n => false })
+    answer.match(/^[Yy][Ee][Ss]$/) ? false : true
+  end
 end
 end
 end