logical-construct 0.0.5 → 0.1.0

data/lib/logical-construct/ground-control/setup/build-files.rb

@@ -1,93 +0,0 @@
-require 'mattock'
-require 'mattock/bundle-command-task'
-
-module LogicalConstruct
-  class ConfigBuilder < Mattock::TaskLib
-    include Mattock::TemplateHost
-    include Mattock::DeferredDefinition
-    Mattock::DeferredDefinition.add_settings(self)
-
-    setting(:source_path, nil)
-    setting(:target_path, nil)
-
-    setting(:valise)
-    setting(:target_dir)
-
-    setting(:base_name)
-    setting(:extra, {})
-
-    def default_configuration(host)
-      super
-      host.copy_settings_to(self)
-    end
-
-    def resolve_configuration
-      self.target_path ||= fail_unless_set(:target_dir) && File::join(target_dir, base_name)
-      self.source_path ||= fail_unless_set(:base_name)  && "#{base_name}.erb"
-      super
-    end
-
-    def define
-      task base_name => [target_dir, valise.find("templates/" + source_path).full_path, Rake.application.rakefile] do
-        finalize_configuration
-        File::open(target_path, "w") do |file|
-          file.write render(source_path)
-        end
-      end
-      task base_name => target_dir
-      task :local_setup => target_path
-    end
-  end
-
-  class BuildFiles < Mattock::TaskLib
-    include Mattock::CommandLineDSL
-
-    default_namespace :build_files
-
-    setting(:target_dir, "target_configs")
-    required_fields :valise, :construct_dir, :platform
-
-    def default_configuration(parent)
-      super
-      self.valise = parent.valise
-      self.construct_dir = parent.construct_dir
-      self.platform = parent.proxy_value.platform
-    end
-
-    def define
-      rakefile = nil
-      initd = nil
-      in_namespace do
-        directory target_dir
-
-        gemfile = ConfigBuilder.new(self) do |task|
-          task.base_name = "Gemfile"
-        end
-
-        Mattock::BundleCommandTask.new(:standalone => gemfile.target_path) do |bundle_build|
-          bundle_build.command = (
-            cmd("cd", target_dir) &
-            cmd("bundle", "install"){|bundler|
-            bundler.options << "--standalone"
-            bundler.options << "--binstubs=bin"
-          })
-        end
-
-        rakefile = ConfigBuilder.new(self) do |task|
-          task.base_name = "Rakefile"
-        end
-
-        initd = ConfigBuilder.new(self) do |task|
-          task.base_name = "construct.init.d"
-          task.extra[:construct_dir] = construct_dir
-          task.runtime_definition do
-            task.extra[:platform] = platform
-          end
-        end
-      end
-      task root_task => [rakefile.target_path] + in_namespace(:standalone)
-      task root_task => [initd.target_path] + in_namespace(:standalone)
-      task :local_setup => root_task
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-require 'logical-construct/ground-control/run-on-target'
-
-module LogicalConstruct
-  class CreateConstructDirectory < RunOnTarget
-    default_namespace :construct_directory
-
-    setting(:construct_dir)
-
-    def default_configuration(setup)
-      self.construct_dir = setup.construct_dir
-      self.remote_server = setup.proxy_value.remote_server
-      super
-    end
-
-    def define
-      remote_task(:create) do |task|
-        task.command = cmd "mkdir", "-p", construct_dir
-      end
-      task :remote_groundwork => self[:create]
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-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,141 +0,0 @@
-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
-  #ResolvingTasks is all about satisfying deps.
-  #
-  #Key is how Rake invokes tasks:
-  #Task runner calls Task#invoke
-  #Which is "setup args" and #invoke_with_call_chain
-  #which is
-  #  return if @already_invoked
-  #  and #invoke_prerequisites
-  #    which is prereqs.each{|pr| pr.invoke_with_call_chain }
-  #  and #execute if needed
-  #
-  #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?
-      !unsatisfied.empty?
-    end
-
-    def unsatisfied
-      satisfiables.find_all{|task| task.needed?}
-    end
-
-    def execute(args=nil)
-      super
-      if needed?
-        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

@@ -1,87 +0,0 @@
-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 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)
-    end
-
-    def needed?
-      return !criteria(self)
-    end
-
-    def criteria(me)
-    end
-  end
-
-  class SatisfiableFileTask < SatisfiableTask
-    setting :target_path
-
-    def prefer_file?
-      true
-    end
-
-    def criteria(task)
-      File::exists?(target_path)
-    end
-
-    def fulfill_file(file)
-      FileUtils::move(file.path, target_path)
-    end
-
-    def fulfill(data)
-      File::open(target_path, "w") do |file|
-        file.write(data)
-      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

@@ -1,4 +0,0 @@
-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

@@ -1,37 +0,0 @@
-require 'mattock/tasklib'
-
-module LogicalConstruct
-  class ChefSolo < Mattock::TaskLib
-    default_namespace :chef_solo
-
-    settings(
-      :chef_solo_bin => "chef-solo",
-      :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 define
-      in_namespace do
-        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
-      bracket_task(:build_configs, :run, :provision)
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-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'