cm 0.1.6 → 0.1.8

data/lib/CM/resource/BOSH.rb

@@ -26,7 +26,7 @@ class BOSH < Nucleon.plugin_class(:CM, :docker_resource)
 
   def operation_deploy
     super do
-      success = true
+      data = {}
     end
   end
 
@@ -34,7 +34,7 @@ class BOSH < Nucleon.plugin_class(:CM, :docker_resource)
 
   def operation_destroy
     super do
-      success = true
+      data = {}
     end
   end
 

data/lib/CM/resource/concourse.rb

@@ -26,7 +26,7 @@ class Concourse < Nucleon.plugin_class(:CM, :docker_resource)
 
   def operation_deploy
     super do
-      success = true
+      data = {}
     end
   end
 
@@ -34,7 +34,7 @@ class Concourse < Nucleon.plugin_class(:CM, :docker_resource)
 
   def operation_destroy
     super do
-      success = true
+      data = {}
     end
   end
 

data/lib/CM/resource/{keypair.rb → plan.rb}

@@ -1,7 +1,7 @@
 
 module CM
 module Resource
-class Keypair < Nucleon.plugin_class(:CM, :docker_resource)
+class Plan < Nucleon.plugin_class(:CM, :resource)
 
   #-----------------------------------------------------------------------------
   # Plugin interface
@@ -14,30 +14,12 @@ class Keypair < Nucleon.plugin_class(:CM, :docker_resource)
   #-----------------------------------------------------------------------------
   # Checks
 
-  def initialized?(options = {})
-    true
-  end
-
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
 
   #-----------------------------------------------------------------------------
   # Operations
 
-  def operation_deploy
-    super do
-      success = true
-    end
-  end
-
-  #---
-
-  def operation_destroy
-    super do
-      success = true
-    end
-  end
-
   #-----------------------------------------------------------------------------
   # Utilities
 

data/lib/CM/resource/variables.rb

@@ -20,17 +20,9 @@ class Variables < Nucleon.plugin_class(:CM, :resource)
   #-----------------------------------------------------------------------------
   # Operations
 
-  def operation_deploy
-    super do
-      success = true
-    end
-  end
-
-  #---
-
-  def operation_destroy
-    super do
-      success = true
+  def create_resource
+    super do |data|
+      info('create_variables', { :id => id })
     end
   end
 

data/lib/CM/sequence/default.rb

@@ -23,8 +23,13 @@ class Default < Nucleon.plugin_class(:CM, :sequence)
   def forward(operation)
     super do |success|
       resources.each do |resource|
-        success = false unless resource.execute(operation)
-        break if plan.trap && plan.step
+        resource.execute(operation)
+        success = false unless resource.status == code.success
+
+        myself.quit = resource.quit ||
+          (((resource.plugin_type == :batch && !Nucleon.parallel?) ||
+          resource.plugin_provider != :variables) && plan.trap && plan.step)
+        break if quit
       end
       success
     end
@@ -35,8 +40,13 @@ class Default < Nucleon.plugin_class(:CM, :sequence)
   def reverse(operation)
     super do |success|
       resources.reverse.each do |resource|
-        success = false unless resource.execute(operation)
-        break if plan.trap && plan.step
+        resource.execute(operation)
+        success = false unless resource.status == code.success
+
+        myself.quit = resource.quit ||
+          (((resource.plugin_type == :batch && !Nucleon.parallel?) ||
+          resource.plugin_provider != :variables) && plan.trap && plan.step)
+        break if quit
       end
       success
     end

data/lib/core/plugin/batch.rb

@@ -3,12 +3,18 @@ module CM
 module Plugin
 class Batch < Nucleon.plugin_class(:nucleon, :base)
 
+  def self.register_ids
+    [ :id ]
+  end
+
   #-----------------------------------------------------------------------------
   # Plugin interface
 
   def normalize(reload)
     super
 
+    codes :batch_failed
+
     @plan = delete(:plan, nil) unless reload
 
     init_resources
@@ -54,11 +60,29 @@ class Batch < Nucleon.plugin_class(:nucleon, :base)
     init_resources
   end
 
+  #---
+
+  def id
+    get(:id).to_sym
+  end
+
+  #---
+
+  def quit
+    @quit
+  end
+
+  def quit=quit
+    @quit = quit
+  end
+
   #-----------------------------------------------------------------------------
   # Operations
 
   def execute(operation)
     if initialized?
+      myself.status = code.success
+
       if Nucleon.parallel?
         success = execute_parallel(operation)
       else
@@ -67,6 +91,7 @@ class Batch < Nucleon.plugin_class(:nucleon, :base)
     else
       success = false
     end
+    myself.status = code.batch_failed unless success
     success
   end
 
@@ -82,8 +107,13 @@ class Batch < Nucleon.plugin_class(:nucleon, :base)
   def execute_sequence(operation)
     success = true
     resources.each do |resource|
-      success = false unless resource.execute(operation)
-      break if plan.trap && plan.step
+      resource.execute(operation)
+      success = false unless resource.status == code.success
+
+      myself.quit = resource.quit ||
+        ((resource.plugin_type != :sequence || resource.plugin_provider != :variables) &&
+        plan.trap && plan.step)
+      break if quit
     end
     success
   end

data/lib/core/plugin/cm_action.rb

@@ -3,7 +3,6 @@ module Nucleon
 module Plugin
 class CmAction < Nucleon.plugin_class(:nucleon, :action)
 
-  include Parallel
   include Mixin::Action::Config
 
   #-----------------------------------------------------------------------------

data/lib/core/plugin/docker_resource.rb

@@ -7,6 +7,13 @@ module CM
 module Plugin
 class DockerResource < Nucleon.plugin_class(:CM, :resource)
 
+  #-----------------------------------------------------------------------------
+
+  def self.options(action)
+    action.register_bool :docker, true, 'cm.action.docker_resource.options.docker'
+    action.register_bool :keep_alive, false, 'cm.action.docker_resource.options.keep_alive'
+  end
+
   #-----------------------------------------------------------------------------
   # Plugin interface
 
@@ -28,13 +35,18 @@ class DockerResource < Nucleon.plugin_class(:CM, :resource)
       Docker.url = "#{settings[:docker_protocol]}://#{settings[:docker_host]}:#{settings[:docker_port]}"
     end
 
+    Docker.options[:write_timeout] = timeout
+    Excon.defaults[:write_timeout] = timeout
+    Docker.options[:read_timeout] = timeout
+    Excon.defaults[:read_timeout] = timeout
+
     yield if block_given?
   end
 
   #---
 
   def remove_plugin
-    destroy_container(plugin_instance_name)
+    destroy_container
   end
 
   #-----------------------------------------------------------------------------
@@ -50,9 +62,21 @@ class DockerResource < Nucleon.plugin_class(:CM, :resource)
     File.exist?('/.dockerinit')
   end
 
+  def dockerize?
+    action_settings[:docker] || settings[:docker]
+  end
+
+  def keep_alive?
+    action_settings[:keep_alive] || settings[:keep_alive]
+  end
+
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
 
+  def docker_id
+    @docker_id ||= "#{id}-#{Time.now.strftime('%Y-%m-%dT%H-%M-%S%z')}"
+  end
+
   def image
     get(:image, 'awebb/cm').to_s
   end
@@ -82,47 +106,79 @@ class DockerResource < Nucleon.plugin_class(:CM, :resource)
   #---
 
   def host_input_directory
-    get(:host_input_directory, "/tmp/cm/input/#{plugin_instance_name}")
+    get(:host_input_directory, "/tmp/cm-data/input/#{docker_id}")
   end
 
   def input_directory
-    get(:input_directory, '/opt/cm/volumes/input')
+    get(:input_directory, "/opt/cm/volumes/input")
   end
 
   #---
 
   def host_output_directory
-    get(:host_output_directory, "/tmp/cm/output/#{plugin_instance_name}")
+    get(:host_output_directory, "/tmp/cm-data/output/#{docker_id}")
   end
 
   def output_directory
-    get(:output_directory, '/opt/cm/volumes/output')
+    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
+    operation_run(:deploy) do
+      data = super
+      yield if block_given?
+      data
+    end
+  end
+
+  def operation_destroy
+    operation_run(:destroy) do
+      data = super
+      yield if block_given?
+      data
+    end
+  end
+
+  #---
+
+  def operation_run(operation)
+    data = {}
+
+    # A fork in the road!
+    if !dockerize? || internal?
+      data = yield if block_given?
+
+      if dockerize?
+        FileUtils.mkdir_p(output_directory)
+
+        output_config = CM.configuration(extended_config(:resource_results, {
+          :provider => get(:resource_output_provider, :file),
+          :path => "#{output_directory}/config.json"
+        }))
+        output_config.import(Nucleon::Config.ensure(data).export)
+        output_config.save
+        Nucleon.remove_plugin(output_config)
       end
-      myself.data = data
-      myself.status == code.success
+
+      logger.info("Docker internal data: #{hash(data)}")
+    else
+      info('cm.resource.docker_resource.info.run_dockerized', { :image => Nucleon.yellow(image), :id => Nucleon.green(id), :op => operation, :time => Nucleon.purple(Time.now.to_s) })
+      logger.info("Running #{operation} operation on #{plugin_provider} resource")
+
+      data = action(plugin_provider, operation)
+      logger.info("Docker return data: #{hash(data)}")
     end
+    data
   end
 
   #-----------------------------------------------------------------------------
   # Docker resource operation execution
 
   def exec(command)
-    data = nil
+    data = {}
 
     create_container
 
@@ -135,35 +191,27 @@ class DockerResource < Nucleon.plugin_class(:CM, :resource)
 
     if results[2] == 0
       if output_config = CM.configuration(extended_config(:resource_results, {
-        :provider => get(:resource_result_provider, :directory),
-        :path => host_output_directory
+        :provider => get(:resource_result_provider, :file),
+        :path => "#{host_output_directory}/config.json"
       }))
         data = Nucleon::Util::Data.clone(output_config.export)
         Nucleon.remove_plugin(output_config)
       end
     end
-
-    destroy_container
     data
+  ensure
+    destroy_container
   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
+    command = Nucleon.command(Nucleon::Config.new({ :command => command }, {}, true, false).import(options), :bash)
+    Nucleon.remove_plugin(command)
 
-    data = exec(command.to_s.strip) do |stream, message|
+    exec(command.to_s.strip) do |stream, message|
       yield(stream, message) if block_given?
     end
-
-    Nucleon.remove_plugin(command) if remove_command
-    data
   end
 
   #---
@@ -175,24 +223,21 @@ class DockerResource < Nucleon.plugin_class(:CM, :resource)
     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
+    command('cm', Nucleon::Util::Data.clean({
+      :subcommand => extended_config(:action, {
+        :command => 'resource run',
+        :data => { :encoded  => Nucleon::Util::CLI.encode(action_settings) },
+        :args => [ provider, operation ]
+      }),
+      :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
+  ensure
+    unless keep_alive?
+      FileUtils.rm_rf(host_input_directory)
+      FileUtils.rm_rf(host_output_directory)
+    end
   end
 
   #-----------------------------------------------------------------------------
@@ -200,15 +245,17 @@ class DockerResource < Nucleon.plugin_class(:CM, :resource)
 
   def create_container
     container = nil
+    gem_path = "#{ENV['GEM_HOME']}/gems/cm-#{CM.VERSION}"
 
-    destroy_container
+    destroy_container(true)
 
     container_env = []
+    container_env << "NUCLEON_LOG=#{Nucleon.log_level}" if Nucleon.log_level
     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,
+      'name' => docker_id,
       'Image' => image,
       'Cmd' => array(startup_commands),
       'Tty' => true,
@@ -217,14 +264,16 @@ class DockerResource < Nucleon.plugin_class(:CM, :resource)
         plan_directory => {},
         key_directory => {},
         input_directory => {},
-        output_directory => {}
+        output_directory => {},
+        gem_path => {}
       },
       '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
+          "#{host_output_directory}:#{output_directory}:rw", # ??.yaml and/or ??.json
+          "#{gem_path}:#{gem_path}:ro"
         ]
       }
     })
@@ -242,24 +291,13 @@ class DockerResource < Nucleon.plugin_class(:CM, :resource)
   #---
 
   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.import({ :config => plan.manifest_config })
     config.save
-
     Nucleon.remove_plugin(config)
 
     # Generate and store plan tokens in local input directory
@@ -269,13 +307,12 @@ class DockerResource < Nucleon.plugin_class(:CM, :resource)
     }))
     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[:manifest] = plan.manifest_file
     action_settings[:config_provider] = 'file'
     action_settings[:config_path] = "#{input_directory}/config.json"
     action_settings[:token_provider] = 'file'
@@ -288,16 +325,19 @@ class DockerResource < Nucleon.plugin_class(:CM, :resource)
 
   #---
 
-  def destroy_container
-    containers = Docker::Container.all({ :all => 1 })
+  def destroy_container(override = false)
+    if override || !keep_alive?
+      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
+      # TODO: Fix occasional crashed actor issue when in parallel mode
+      containers.each do |cont|
+        if cont.info.key?('Names') && cont.info['Names'].include?("/#{docker_id}")
+          cont.kill!
+          cont.remove
+        end
       end
+      @container = nil
     end
-    @container = nil
   end
   protected :destroy_container
 
@@ -305,11 +345,12 @@ class DockerResource < Nucleon.plugin_class(:CM, :resource)
 
   def render_docker_message(stream, message)
     if stream == 'stderr'
-      puts message
+      warn("(#{Nucleon.red(image)})>#{message}", { :i18n => false, :prefix => false })
     else
-      puts message
+      info("(#{Nucleon.yellow(image)})>#{message}", { :i18n => false, :prefix => false })
     end
   end
+  protected :render_docker_message
 end
 end
 end