logical-construct 0.0.1.localtesting → 0.0.1

data/lib/logical-construct/ground-control/setup/create-construct-directory.rb

@@ -8,6 +8,7 @@ module LogicalConstruct
 
     def default_configuration(setup)
       self.construct_dir = setup.construct_dir
+      self.remote_server = setup.proxy_value.remote_server
       super
     end
 

data/lib/logical-construct/ground-control/setup/install-init.rb

@@ -0,0 +1,32 @@
+require 'mattock'
+require 'logical-construct/ground-control/run-on-target'
+
+module LogicalConstruct
+  module GroundControl
+    class InstallInit < RunOnTarget
+      required_fields :source_path, :target_path
+      setting :construct_dir
+      setting :service_name, "logical-construct"
+      setting :initd_path, "/etc/init.d"
+
+      def default_configuration(setup)
+        super
+        setup.copy_settings_to(self)
+      end
+
+      def resolve_configuration
+        super
+        self.source_path ||= File::join(construct_dir, "construct.init.d")
+        self.target_path ||= File::join(initd_path, service_name)
+      end
+
+      def define
+        remote_task(:install_init) do |task|
+          task.command = cmd("install", "-T", source_path, target_path) &
+            ["rc-update", "add", service_name, "default"]
+        end
+        bracket_task(:remote_config, :install_init, :remote_setup)
+      end
+    end
+  end
+end

data/lib/logical-construct/resolving-task.rb

@@ -1,5 +1,6 @@
 require 'rake/task'
 require 'mattock/task'
+require 'logical-construct/satisfiable-task'
 
 module LogicalConstruct
   #Ensures that all it's deps are satisfied before proceeding - the action for
@@ -17,22 +18,124 @@ module LogicalConstruct
   #So, of note: you'll only get invoked once, ever
   #You'll only be executed if #needed?
   #Deps will get invoked (ish) even if not #needed?
-  #
+  module SatisfiableManager
+    def default_configuration(*configurables)
+      super
+      self.satisfiables = configurables.find_all do |conf|
+        conf.is_a? SatisfiableTask
+      end.map{|sat| sat.rake_task}
+    end
+
+    def define
+      super
+      satisfiables.each do |sat|
+        sat.enhance([rake_task.name])
+      end
+    end
+
+    def add_satisfiable(task)
+      task = task.rake_task if task.respond_to? :rake_task
+      satisfiables << task
+      task.enhance([rake_task.name])
+    end
+  end
+
+  require 'yaml'
+  require 'digest'
+  module ResolutionProtocol
+    def digest
+      @digest ||= Digest::SHA2.new
+    end
+
+    def file_checksum(path)
+      generate_checksum(File::read(path))
+    end
+
+    def generate_checksum(data)
+      digest.reset
+      digest << data
+      digest.hexdigest
+    end
+
+    def web_path(task_name)
+      "/" + task_name.gsub(":", "/")
+    end
+  end
+
   class ResolvingTask < Rake::Task
     include Mattock::TaskMixin
+    include SatisfiableManager
+    setting :satisfiables, []
+
     def needed?
-      prerequisite_tasks.any?{|task| task.needed?}
+      !unsatisfied.empty?
     end
 
-    def unsatisfied_prerequisites
-      prerequisite_tasks.find_all{|task| task.needed?}
+    def unsatisfied
+      satisfiables.find_all{|task| task.needed?}
     end
 
     def execute(args=nil)
       super
       if needed?
-        raise "Task #{name} failed to satisfy: #{unsatisfied_prerequisites.inspect}"
+        raise "Task #{name} failed to satisfy: #{unsatisfied.inspect}"
+      end
+    end
+  end
+
+  class Manifest < SatisfiableTask
+    include SatisfiableManager
+    include ResolutionProtocol
+
+    setting :satisfiables, []
+    nil_field :manifest
+
+    default_taskname "Manifest"
+
+    def invalid_checksum(checksum, path)
+      return false unless File::exists?(path)
+      return true if checksum.nil? or checksum.empty?
+      return checksum != file_checksum(path)
+    end
+
+    def needed?
+      manifest.nil?
+    end
+
+    def fulfill(data)
+      self.manifest = YAML::load(data)
+      satisfiables.each do |sat|
+        path = sat.target_path
+        checksum = manifest[sat.name]
+        if invalid_checksum(checksum, path)
+          File::rename(path, path + ".invalid")
+        end
+      end
+    end
+  end
+
+  class GenerateManifest < Mattock::Task
+    include ResolutionProtocol
+    setting :hash, {}
+    setting :resolutions
+    setting :receiving_name
+
+    def default_configuration(resolution_host)
+      super
+      self.resolutions = resolution_host.resolutions
+    end
+
+    def data_checksum(path, data)
+      hash[path] = generate_checksum(data)
+    end
+
+    def action
+      resolutions.each_pair do |destination, data|
+        data = data.call if data.respond_to? :call
+        data = data.read if data.respond_to? :read
+        hash[destination] = generate_checksum(data)
       end
+      resolutions[receiving_name] = YAML::dump(hash)
     end
   end
 end

data/lib/logical-construct/satisfiable-task.rb

@@ -20,9 +20,24 @@ module LogicalConstruct
       #Swallowed
     end
 
+    def prefer_file?
+      false
+    end
+
     def receive(data)
       return unless needed?
       fulfill(data)
+      if data.respond_to? :path
+        fulfill_file(data)
+      elsif data.respond_to? :read
+        fulfill(data.read)
+      else
+        fulfill(data.to_s)
+      end
+    end
+
+    def receive_file(file)
+      fulfill(file.read)
     end
 
     def fulfill(string)
@@ -39,13 +54,21 @@ module LogicalConstruct
   class SatisfiableFileTask < SatisfiableTask
     setting :target_path
 
+    def prefer_file?
+      true
+    end
+
     def criteria(task)
       File::exists?(target_path)
     end
 
-    def fulfill(string)
+    def fulfill_file(file)
+      FileUtils::move(file.path, target_path)
+    end
+
+    def fulfill(data)
       File::open(target_path, "w") do |file|
-        file.write(string)
+        file.write(data)
       end
     end
   end

data/lib/logical-construct/target/chef-solo.rb

@@ -6,35 +6,32 @@ module LogicalConstruct
 
     settings(
       :chef_solo_bin => "chef-solo",
-      :config_file => "/etc/chef/solo.rb",
       :daemonize => nil,
       :user => nil,
       :group => nil,
       :node_name => nil
     )
 
+    setting :config_file
+
     def default_configuration(chef_config)
+      super
       self.config_file = chef_config.solo_rb
     end
 
-    def chef_command
-      Mattock::CommandLine.new(chef_solo_bin) do |cmd|
-        cmd.options << "--config #{config_file}" unless config_file.nil?
-        cmd.options << "--daemonize" if daemonize
-        cmd.options << "--user #{user}" if user
-        cmd.options << "--group #{group}" if group
-        cmd.options << "--node_name #{node_name}" if node_name
-      end
-    end
-
     def define
       in_namespace do
-        file config_file
-        task :run => [config_file] do
-          chef_command.run
+        Mattock::CommandTask.new(:run) do |task|
+          task.command = Mattock::CommandLine.new(chef_solo_bin) do |cmd|
+            cmd.options << "--config #{config_file}" unless config_file.nil?
+            cmd.options << "--daemonize" if daemonize
+            cmd.options << "--user #{user}" if user
+            cmd.options << "--group #{group}" if group
+            cmd.options << "--node_name #{node_name}" if node_name
+          end
         end
       end
-      task :provision => self[:run]
+      bracket_task(:build_configs, :run, :provision)
     end
   end
 end

data/lib/logical-construct/target/platforms/default/chef-config.rb

@@ -1,22 +1,29 @@
 require 'mattock/tasklib'
 require 'mattock/template-host'
+require 'mattock/command-line'
 require 'logical-construct/satisfiable-task'
 
 module LogicalConstruct
   module Default
+    #XXX Should get broken into at least 2 smaller tasklibs
     class ChefConfig < Mattock::Tasklib
       include Mattock::TemplateHost
       default_namespace :chef_config
 
       required_field :construct_dir
-      required_fields :file_cache_path, :cookbook_path, :cookbook_tarball_path, :json_attribs
+      required_fields :cookbook_path, :data_bags_path, :json_attribs,
+        :cookbook_tarball_path, :file_cache_path, :secret_data_tarball_path, :normal_data_tarball_path
       required_field :valise
       settings :solo_rb => "/etc/chef/solo.rb",
+        :etc_chef => "/etc/chef",
+        :data_bags_relpath => "data-bags",
         :cookbook_relpath => "cookbooks",
         :cookbook_tarball_relpath => "cookbooks.tgz",
+        :secret_data_tarball_relpath => "secret_data.tgz",
+        :normal_data_tarball_relpath => "normal_data.tgz",
         :json_attribs_relpath => "node.json"
 
-      setting :resolution_task
+      setting :resolution
 
       nil_fields :recipe_url, :role_path, :role_relpath
 
@@ -24,23 +31,38 @@ module LogicalConstruct
         super
         self.construct_dir = provision.construct_dir
         self.valise = provision.valise
-        self.resolution_task = resolution[:resolve]
+        self.resolution = resolution
       end
 
+      #XXX Hints about decomposing this Tasklib: there are settings for
+      #chef/solo.rb, which are only incidentally related to the tarball
+      #unpacking tasks - which are themselves closely related
       def resolve_configuration
         if unset?(file_cache_path)
           self.file_cache_path = File::expand_path('chef', construct_dir)
         end
-
         self.file_cache_path = File::expand_path(file_cache_path)
+
         if unset?(cookbook_path) and !cookbook_relpath.nil?
           self.cookbook_path = File::expand_path(cookbook_relpath, file_cache_path)
         end
 
+        if unset?(data_bags_path) and !data_bags_relpath.nil?
+          self.data_bags_path = File::expand_path(data_bags_relpath, file_cache_path)
+        end
+
         if unset?(cookbook_tarball_path) and !cookbook_tarball_relpath.nil?
           self.cookbook_tarball_path = File::expand_path(cookbook_tarball_relpath, file_cache_path)
         end
 
+        if unset?(secret_data_tarball_path) and !secret_data_tarball_relpath.nil?
+          self.secret_data_tarball_path = File::expand_path(secret_data_tarball_relpath, file_cache_path)
+        end
+
+        if unset?(normal_data_tarball_path) and !normal_data_tarball_relpath.nil?
+          self.normal_data_tarball_path = File::expand_path(normal_data_tarball_relpath, file_cache_path)
+        end
+
         self.solo_rb = File::expand_path(solo_rb, file_cache_path)
 
         if unset?(json_attribs) and !json_attribs_relpath.nil?
@@ -53,36 +75,59 @@ module LogicalConstruct
         super
       end
 
+      include Mattock::CommandLineDSL
       def define
         in_namespace do
+          directory etc_chef
           directory file_cache_path
 
           Mattock::CommandTask.new(:unpack_cookbooks => :cookbook_tarball) do |task|
-            task.command = Mattock::CommandLine.new("tar", "-xzf", cookbook_tarball_path)
+            task.command = cmd("cd", file_cache_path) & cmd("tar", "-xzf", cookbook_tarball_path)
+          end
+
+          Mattock::CommandTask.new(:unpack_secret_data => :secret_data_tarball) do |task|
+            task.command = cmd("cd", file_cache_path) & cmd("tar", "-xzf", secret_data_tarball_path)
+          end
+
+          Mattock::CommandTask.new(:unpack_normal_data => :normal_data_tarball) do |task|
+            task.command = cmd("cd", file_cache_path) & cmd("tar", "-xzf", normal_data_tarball_path)
           end
 
-          file solo_rb => [:unpack_cookbooks, :json_attribs, file_cache_path, resolution_task] do
+          file solo_rb => [etc_chef, :json_attribs, :unpack_cookbooks, :unpack_secret_data, :unpack_normal_data] do
             File::open(solo_rb, "w") do |file|
               file.write(render("chef.rb.erb"))
             end
           end
 
-          SatisfiableFileTask.new(:json_attribs => file_cache_path) do |task|
+          resolution.add_file(SatisfiableFileTask.new(:json_attribs => file_cache_path) do |task|
             task.target_path = json_attribs
-          end
+          end)
 
-          SatisfiableFileTask.new(:cookbook_tarball => file_cache_path) do |task|
+          resolution.add_file(SatisfiableFileTask.new(:cookbook_tarball => file_cache_path) do |task|
             task.target_path = cookbook_tarball_path
-          end
+          end)
+
+          resolution.add_file(SatisfiableFileTask.new(:secret_data_tarball => file_cache_path) do |task|
+            task.target_path = secret_data_tarball_path
+          end)
+
+          resolution.add_file(SatisfiableFileTask.new(:normal_data_tarball => file_cache_path) do |task|
+            task.target_path = normal_data_tarball_path
+          end)
 
           unless role_path.nil?
             directory role_path
             file solo_rb => role_path
           end
+
+          desc "Delete all the chef config files (to re-provision)"
+          task :clobber do
+            cmd("rm", "-rf", file_cache_path)
+          end
         end
 
-        task resolution_task => self[:cookbook_tarball]
-        task resolution_task => self[:json_attribs]
+        file solo_rb => resolution[:Manifest]
+        task :build_configs => solo_rb
       end
     end
   end

data/lib/logical-construct/target/platforms/default/resolve-configuration.rb

@@ -8,16 +8,35 @@ module LogicalConstruct
       setting :port, 51076
       setting :valise
 
+      def initialize(*args, &block)
+        @pending_satisfiables = []
+        @resolver = nil
+        @manifest = nil
+        super
+      end
+
       def default_configuration(provision)
+        super
         self.valise = provision.valise
       end
 
+      def add_file(file_satisfiable)
+        if @resolver.nil?
+          @pending_satifiables << file_satisfiable
+        else
+          @resolver.add_satisfiable(file_satisfiable)
+          @manifest.add_satisfiable(file_satisfiable)
+        end
+      end
+
       def define
         in_namespace do
-          resolver = LogicalConstruct::SinatraResolver.new do |task|
-            task.task_name = "resolve"
+          @manifest = LogicalConstruct::Manifest.new(*@pending_satisfiables)
+
+          @resolver = LogicalConstruct::SinatraResolver.new(*([@manifest] + @pending_satisfiables)) do |task|
+            copy_settings_to(task)
           end
-          copy_settings_to(resolver)
+          @pending_satisfiables.clear
         end
       end
     end