logical-construct 0.0.1.localtesting

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

@@ -0,0 +1,64 @@
+require 'mattock/task'
+
+module LogicalConstruct
+  #This task won't kill the run if it fails - the assumption is that there's a
+  #ResolvingTask that depends on this task to make it work.
+  #
+  #Based on my reasoning about Rake (c.f. ResolvingTask):
+  # Each ST should have a configured #needed? that checks it's responsibility
+  # Execute needs to catch errors
+  class SatisfiableTask < Rake::Task
+    include Mattock::TaskMixin
+
+    def execute(args=nil)
+      super
+      if application.options.trace and needed?
+        $stderr.puts "** Unsatisfied: #{name}"
+      end
+    rescue Object => ex
+      warn "#{ex.class}: #{ex.message} while performing #{name}"
+      #Swallowed
+    end
+
+    def receive(data)
+      return unless needed?
+      fulfill(data)
+    end
+
+    def fulfill(string)
+    end
+
+    def needed?
+      return !criteria(self)
+    end
+
+    def criteria(me)
+    end
+  end
+
+  class SatisfiableFileTask < SatisfiableTask
+    setting :target_path
+
+    def criteria(task)
+      File::exists?(target_path)
+    end
+
+    def fulfill(string)
+      File::open(target_path, "w") do |file|
+        file.write(string)
+      end
+    end
+  end
+
+  class SatisfiableEnvTask < SatisfiableTask
+    setting :target_name
+
+    def criteria(task)
+      ENV.has_key?(target_name)
+    end
+
+    def fulfill(string)
+      ENV[target_name] = string
+    end
+  end
+end

data/lib/logical-construct/target.rb

@@ -0,0 +1,4 @@
+require 'logical-construct/target/platforms'
+require 'logical-construct/target/provision'
+require 'logical-construct/target/chef-solo'
+require 'logical-construct/target/unpack-cookbook'

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

@@ -0,0 +1,40 @@
+require 'mattock/tasklib'
+
+module LogicalConstruct
+  class ChefSolo < Mattock::TaskLib
+    default_namespace :chef_solo
+
+    settings(
+      :chef_solo_bin => "chef-solo",
+      :config_file => "/etc/chef/solo.rb",
+      :daemonize => nil,
+      :user => nil,
+      :group => nil,
+      :node_name => nil
+    )
+
+    def default_configuration(chef_config)
+      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
+        end
+      end
+      task :provision => self[:run]
+    end
+  end
+end

data/lib/logical-construct/target/platforms.rb

@@ -0,0 +1,51 @@
+module LogicalConstruct
+  def self.platforms
+    @platforms ||= {}
+  end
+
+  def self.register_platform(mod)
+    name = mod.name.split('::').last
+    platforms[name] = mod
+  end
+
+  def self.require_platform_files(platform, mod = nil)
+    [
+      ['volume', :Volume],
+      ['chef-config', :ChefConfig],
+      ['resolve-configuration', :ResolveConfiguration],
+    ].each do |file, classname|
+      begin
+        require File::join('logical-construct', 'target', 'platforms', platform, file)
+      rescue LoadError
+        raise if mod.nil?
+        klass = Class.new(LogicalConstruct::Default.const_get(classname))
+        mod.const_set(classname, klass)
+      end
+    end
+  end
+
+  def self.Platform(explicit = nil)
+    name = explicit || $DEPLOYMENT_PLATFORM || ENV['LOGCON_DEPLOYMENT_PLATFORM']
+    return platforms.fetch(name)
+  rescue KeyError
+    puts "Cannot find platform specified:"
+    puts "  explicit argument: #{explicit.inspect}"
+    puts "  $DEPLOYMENT_PLATFORM: #{$DEPLOYMENT_PLATFORM.inspect}"
+    puts "  ENV['LOGCON_DEPLOYMENT_PLATFORM']: #{ENV['LOGCON_DEPLOYMENT_PLATFORM'].inspect}"
+    puts "  available: #{platforms.keys.inspect}"
+    puts
+    raise
+  end
+
+  module PlatformSpecific
+    def register_platform(name)
+      LogicalConstruct.register_platform(self)
+      LogicalConstruct.require_platform_files(name, self)
+    end
+  end
+
+  require_platform_files('default')
+end
+
+require 'logical-construct/target/platforms/virtualbox'
+require 'logical-construct/target/platforms/aws'

data/lib/logical-construct/target/platforms/aws.rb

@@ -0,0 +1,8 @@
+require 'logical-construct/target/platforms'
+
+module LogicalConstruct
+  module AWS
+    extend PlatformSpecific
+    register_platform('aws')
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'mattock/tasklib'
+require 'mattock/template-host'
+require 'logical-construct/satisfiable-task'
+
+module LogicalConstruct
+  module Default
+    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_field :valise
+      settings :solo_rb => "/etc/chef/solo.rb",
+        :cookbook_relpath => "cookbooks",
+        :cookbook_tarball_relpath => "cookbooks.tgz",
+        :json_attribs_relpath => "node.json"
+
+      setting :resolution_task
+
+      nil_fields :recipe_url, :role_path, :role_relpath
+
+      def default_configuration(provision, resolution)
+        super
+        self.construct_dir = provision.construct_dir
+        self.valise = provision.valise
+        self.resolution_task = resolution[:resolve]
+      end
+
+      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?(cookbook_tarball_path) and !cookbook_tarball_relpath.nil?
+          self.cookbook_tarball_path = File::expand_path(cookbook_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?
+          self.json_attribs = File::expand_path(json_attribs_relpath, file_cache_path)
+        end
+
+        if role_path.nil? and !role_relpath.nil?
+          self.role_path = File::expand_path(role_relpath, file_cache_path)
+        end
+        super
+      end
+
+      def define
+        in_namespace do
+          directory file_cache_path
+
+          Mattock::CommandTask.new(:unpack_cookbooks => :cookbook_tarball) do |task|
+            task.command = Mattock::CommandLine.new("tar", "-xzf", cookbook_tarball_path)
+          end
+
+          file solo_rb => [:unpack_cookbooks, :json_attribs, file_cache_path, resolution_task] 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|
+            task.target_path = json_attribs
+          end
+
+          SatisfiableFileTask.new(:cookbook_tarball => file_cache_path) do |task|
+            task.target_path = cookbook_tarball_path
+          end
+
+          unless role_path.nil?
+            directory role_path
+            file solo_rb => role_path
+          end
+        end
+
+        task resolution_task => self[:cookbook_tarball]
+        task resolution_task => self[:json_attribs]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'logical-construct/target/sinatra-resolver'
+module LogicalConstruct
+  module Default
+    class ResolveConfiguration < Mattock::Tasklib
+      default_namespace 'configuration'
+
+      setting :bind, '0.0.0.0'
+      setting :port, 51076
+      setting :valise
+
+      def default_configuration(provision)
+        self.valise = provision.valise
+      end
+
+      def define
+        in_namespace do
+          resolver = LogicalConstruct::SinatraResolver.new do |task|
+            task.task_name = "resolve"
+          end
+          copy_settings_to(resolver)
+        end
+      end
+    end
+  end
+end

data/lib/logical-construct/target/platforms/default/volume.rb

@@ -0,0 +1,11 @@
+require 'mattock/tasklib'
+
+module LogicalConstruct
+  module Default
+    class Volume < Mattock::Tasklib
+      def define
+
+      end
+    end
+  end
+end

data/lib/logical-construct/target/platforms/virtualbox.rb

@@ -0,0 +1,8 @@
+require 'logical-construct/target/platforms'
+
+module LogicalConstruct
+  module VirtualBox
+    extend PlatformSpecific
+    register_platform('virtualbox')
+  end
+end

data/lib/logical-construct/target/platforms/virtualbox/volume.rb

@@ -0,0 +1,15 @@
+require 'logical-construct/target/platforms/virtualbox'
+
+module LogicalConstruct
+  module VirtualBox
+    class Volume < Default::Volume
+      def define
+        Mattock::CommandTask.new(self) do |task|
+          task.command = Mattock::CommandLine.new("mount") do |mount|
+            mount.options = [device, mountpoint]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logical-construct/target/provision.rb

@@ -0,0 +1,26 @@
+require 'mattock'
+require 'mattock/template-host'
+
+module LogicalConstruct
+  class Provision < Mattock::Tasklib
+    include Mattock::ValiseManager
+    extend Mattock::ValiseManager
+
+    settings(
+      :construct_dir => "/var/logical-construct",
+      :attr_source => nil,
+      :config_path => nil
+    )
+    setting :valise
+    setting :search_paths, [rel_dir(__FILE__)]
+
+    def resolve_configuration
+      self.valise = default_valise(search_paths)
+      super
+    end
+
+    def define
+      task_spine(:preflight, :approve_host, :build_configs, :provision)
+    end
+  end
+end

data/lib/logical-construct/target/sinatra-resolver.rb

@@ -0,0 +1,102 @@
+require 'logical-construct/resolving-task'
+require 'mattock/task'
+require 'mattock/template-host'
+require 'sinatra'
+
+module LogicalConstruct
+  class SinatraResolver < ResolvingTask
+    include Mattock::TemplateHost
+
+    def web_path(task)
+      "/" + task.name.gsub(":", "/")
+    end
+
+    def build_collector(resolver, prereqs)
+      klass = Class.new(Sinatra::Application) do
+        class << self
+          attr_accessor :running_server
+        end
+
+        set :show_exceptions => true
+
+        get '/' do
+          resolver.render('resolver/index.html.erb')
+        end
+
+        prereqs.each do |task|
+          path = resolver.web_path(task)
+
+          get path do
+            resolver.render('resolver/task-form.html.erb') do |locals|
+              locals[:task_path] = path
+            end
+          end
+
+          post path do
+            task.fulfill(request.params["data"])
+            if resolver.needed?
+              redirect to("/")
+            else
+              resolver.render('resolver/finished.html.erb')
+              quit!
+            end
+          end
+
+          put path do
+            request.body.rewind
+            task.fulfill(request.body.read)
+            if resolver.needed?
+              redirect to("/")
+            else
+              resolver.render('resolver/finished.html.erb')
+              quit!
+            end
+          end
+        end
+
+        def self.rack_handler
+          handler = detect_rack_handler
+        end
+
+        def quit!
+          self.class.quit!(self.class.running_server, "A server")
+        end
+      end
+      return klass
+    end
+
+    setting :bind, "0.0.0.0"
+    setting :port, 51076 #JDL's birthday
+    setting :valise, Mattock::ValiseManager.default_valise("lib")
+
+    def action
+      puts
+      puts "STARTING WEB LISTENER TO RESOLVE PREREQUISITES"
+      puts
+
+      collector = build_collector(self, prerequisite_tasks)
+      handler      = collector.rack_handler
+      handler_name = handler.name
+
+      old_handlers = nil
+      handler.run collector, :Host => bind, :Port => port do |server|
+        old_handlers = Hash[
+          [:INT, :TERM].map { |sig| [sig, trap(sig) { collector.quit!(server, handler_name) }] }
+        ]
+        collector.running_server = server
+        if server.respond_to? :threaded=
+          server.threaded = settings.threaded
+        end
+        puts "Listening on #{port} with #{handler.name}"
+      end
+
+      old_handlers.each_pair do |signal, handler|
+        trap(signal, handler)
+      end
+
+    rescue Errno::EADDRINUSE => e
+      puts "Port #{port} in use!"
+      exit 1
+    end
+  end
+end