logical-construct 0.0.1.localtesting

data/lib/logical-construct/ground-control.rb

@@ -0,0 +1,3 @@
+require 'logical-construct/ground-control/core'
+require 'logical-construct/ground-control/setup'
+require 'logical-construct/ground-control/provision'

data/lib/logical-construct/ground-control/core.rb

@@ -0,0 +1,33 @@
+p :loading => __FILE__
+require 'mattock'
+
+module LogicalConstruct
+  module GroundControl
+    class Core < Mattock::TaskLib
+      include Mattock::ValiseManager
+      extend Mattock::ValiseManager
+
+      default_namespace :core
+      setting(:search_paths, [rel_dir(__FILE__)])
+      setting(:valise)
+
+      def default_configuration
+        super
+      end
+
+      def resolve_configuration
+        self.valise = default_valise(*search_paths)
+        super
+      end
+
+      def define
+        in_namespace do
+          desc "List the search paths for files used by ground control"
+          task :search_paths do
+            p valise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logical-construct/ground-control/provision.rb

@@ -0,0 +1,70 @@
+require 'mattock'
+require 'rake/packagetask'
+
+module LogicalConstruct
+  module GroundControl
+    class Provision < Mattock::Tasklib
+      class WebConfigure < Mattock::Task
+        setting :target_ipaddr, nil
+        setting :web_port, 51076
+        setting :resolutions, {}
+
+        def action
+          connection = Excon.new(target_address)
+          index = connection.get
+          body = Nokogiri::HTML(index.body)
+          resolution_needed = body.xpath('//a[@href]')
+          resolution_needed.each do |link|
+            href = link['href']
+            connection.post(href, {"data" => resolve(href)})
+          end
+        end
+
+        def resolve(path)
+          resolved = resolutions.fetch(path)
+          if resolved.respond_to? :call
+            resolved = resolved.call
+          end
+          return resolved
+        end
+      end
+
+      default_namespace :provision
+
+      setting :valise
+      setting :web_port, 51076
+      setting :target_ipaddr, nil
+      setting :resolutions, {}
+      setting :marshalling_path
+      setting :cookbooks_path
+
+      def default_configuration(core)
+        core.copy_settings_to(self)
+        super
+      end
+
+      def define
+        in_namespace do
+          task :collect, [:ipaddr] do |task, args|
+            self.target_ipaddr = args[:ipaddr]
+          end
+
+          WebConfigure.new(:web_configure => :collect) do |task|
+            self.copy_settings_to(task)
+          end
+
+          namespace :cookbook do
+            Rake::PackageTask.new("cookbook", :noversion) do |task|
+              task.need_tar_gz = true
+              task.package_dir = marshalling_path
+              task.package_files.include(cookbooks_path + "/**/*")
+            end
+          end
+        end
+
+        task root_task, [:ipaddr] => :web_configure
+
+      end
+    end
+  end
+end

data/lib/logical-construct/ground-control/run-on-target.rb

@@ -0,0 +1,32 @@
+require 'logical-construct/ground-control'
+require 'mattock/remote-command-task'
+
+module LogicalConstruct
+  class RunOnTarget < Mattock::TaskLib
+    include Mattock::CommandLineDSL
+
+    runtime_setting(:remote_server)
+
+    def default_configuration(setup)
+      super
+      self.remote_server = setup.proxy_value.remote_server
+    end
+
+    def remote_task(name, comment = nil)
+      in_namespace do
+        desc comment unless comment.nil?
+        Mattock::RemoteCommandTask.new(name) do |task|
+          task.ssh_options << "ControlMaster=auto"
+          task.ssh_options << "ControlPersist=3600"
+          task.ssh_options << "StrictHostKeyChecking=no"
+          task.ssh_options << "UserKnownHostsFile=/dev/null"
+
+          task.runtime_definition do |task|
+            copy_settings_to(task)
+            yield(task)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module LogicalConstruct
+  module GroundControl
+    class Setup < Mattock::TaskLib
+
+      default_namespace :setup
+
+      settings(
+        :remote_server => nested( :address => nil, :user => "root"),
+        :construct_dir => "/var/logical-construct"
+      )
+
+      nil_fields :valise
+
+      def default_configuration(core)
+        core.copy_settings_to(self)
+      end
+
+      def define
+        in_namespace do
+          task :collect, [:address] do |t, args|
+            remote_server.address = args[:address]
+            p :collect => remote_server
+          end
+
+          task :local_setup => [:collect]
+
+          task :remote_groundwork => [:local_setup]
+
+          task :remote_config => [:remote_groundwork]
+
+          task :remote_setup => [:remote_config]
+
+          task :complete => [:local_setup, :remote_setup]
+        end
+
+        desc "Set up a remote server to act as a Construct foundation"
+        task root_task,[:address] => self[:complete]
+      end
+
+      def default_subtasks
+        in_namespace do
+          CreateConstructDirectory.new(self)
+          EnsureEnv.new(self)
+          BundleSetup.new(self)
+          build_files = BuildFiles.new(self)
+          CopyFiles.new(self, build_files)
+        end
+      end
+    end
+  end
+end
+
+require 'logical-construct/ground-control/setup/bundle-setup'
+require 'logical-construct/ground-control/setup/create-construct-directory'
+require 'logical-construct/ground-control/setup/ensure-env'
+require 'logical-construct/ground-control/setup/copy-files'
+require 'logical-construct/ground-control/setup/build-files'

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

@@ -0,0 +1,64 @@
+module LogicalConstruct
+  class ConfigBuilder < Mattock::TaskLib
+    include Mattock::TemplateHost
+
+    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
+      file target_path => [target_dir, valise.find("templates/" + source_path).full_path, Rake.application.rakefile] do
+        File::open(target_path, "w") do |file|
+          file.write render(source_path)
+        end
+      end
+      task :local_setup => target_path
+    end
+  end
+
+  class BuildFiles < Mattock::TaskLib
+    default_namespace :build_files
+
+    setting(:target_dir, "target_configs")
+    setting(:valise)
+
+    def default_configuration(parent)
+      super
+      self.valise = parent.valise
+    end
+
+    attr_reader :built_files
+
+    def define
+      file_tasks = []
+      in_namespace do
+        directory target_dir
+
+        file_tasks = ["Rakefile", "Gemfile"].map do |path|
+          ConfigBuilder.new(self) do |task|
+            task.base_name = path
+          end
+        end
+      end
+      desc "Template files to be created on the remote server"
+      task root_task => file_tasks.map{|t| t.target_path}
+      task :local_setup => root_task
+    end
+  end
+end

data/lib/logical-construct/ground-control/setup/bundle-setup.rb

@@ -0,0 +1,36 @@
+require 'logical-construct/ground-control/run-on-target'
+
+module LogicalConstruct
+  class BundleSetup < RunOnTarget
+    default_namespace :bundle_setup
+
+    setting :construct_dir
+    nil_fields :bundle_path, :bin_path
+
+    def default_configuration(setup)
+      setup.copy_settings_to(self)
+      super
+    end
+
+    def resolve_configuration
+      self.bundle_path ||= File.join(construct_dir, "lib")
+      self.bin_path ||= File.join(construct_dir, "bin")
+    end
+
+    def remote_command
+      Mattock::PrereqChain.new do |cmd|
+        cmd.add Mattock::CommandLine.new("cd", construct_dir)
+        cmd.add Mattock::CommandLine.new("bundle") do |cmd|
+        end
+      end
+    end
+
+    def define
+      remote_task(:run, "Set up bundle on the remote server") do |task|
+        task.command = (cmd("cd", construct_dir) &
+          ["bundle", "--path #{bundle_path}", "--binstubs #{bin_path}"]).tap{|cl| p cl}
+      end
+      bracket_task(:remote_config, :run, :remote_setup)
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'mattock/command-task'
+
+module LogicalConstruct
+  class SecureCopyFile < Mattock::CommandTask
+    nil_fields :destination_address
+    nil_fields :source_dir, :destination_dir, :basename
+    required_fields :source_path, :destination_path
+    runtime_required_field :remote_server
+    runtime_required_field :command
+
+    def default_configuration(copy)
+      self.remote_server = copy.proxy_value.remote_server
+    end
+
+    def resolve_configuration
+      super
+      self.source_path ||= File::join(source_dir, basename)
+      self.destination_path ||= File::join(destination_dir, basename)
+    end
+
+    def resolve_runtime_configuration
+      self.destination_address ||= [remote_server.address, destination_path].join(":")
+      if remote_server.user
+        self.destination_address = "#{remote_server.user}@#{destination_address}"
+      end
+      self.command = cmd("scp",
+                         "-o ControlMaster=auto",
+                         source_path, destination_address)
+    end
+  end
+
+  class CopyFiles < Mattock::TaskLib
+    default_namespace :copy_files
+
+    required_fields :files_dir, :remote_server, :construct_dir
+
+    setting :files, ["Rakefile", "Gemfile"]
+
+    def default_configuration(setup, build_files)
+      super()
+      self.files_dir = build_files.target_dir
+      self.remote_server = setup.proxy_value.remote_server
+      self.construct_dir = setup.construct_dir
+    end
+
+    def define
+      files.each do |file|
+        in_namespace do
+          SecureCopyFile.new(self, file) do |task|
+            task.runtime_definition do
+              task.remote_server = remote_server
+            end
+            task.source_dir = files_dir
+            task.destination_dir = construct_dir
+            task.basename = file
+          end
+        end
+        bracket_task(:local_setup, file, :remote_config)
+      end
+
+      desc "Copy locally generated files to the remote server"
+      task root_task => in_namespace(*files)
+      task :remote_config => root_task
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+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
+      super
+    end
+
+    def define
+      remote_task(:create, "Create #{construct_dir} on the remote server") 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/ensure-env.rb

@@ -0,0 +1,15 @@
+require 'logical-construct/ground-control/run-on-target'
+
+module LogicalConstruct
+  class EnsureEnv < RunOnTarget
+    default_namespace :ensure_env
+
+    def define
+      remote_task(:bundler, "Ensure that bundler is installed on the remote server") do |task|
+        task.verify_command = cmd "bundle", "--version"
+        task.command = cmd("sudo") - %w{gem install bundler}
+      end
+      bracket_task(:local_setup, :bundler, :remote_setup)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'rake/task'
+require 'mattock/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?
+  #
+  class ResolvingTask < Rake::Task
+    include Mattock::TaskMixin
+    def needed?
+      prerequisite_tasks.any?{|task| task.needed?}
+    end
+
+    def unsatisfied_prerequisites
+      prerequisite_tasks.find_all{|task| task.needed?}
+    end
+
+    def execute(args=nil)
+      super
+      if needed?
+        raise "Task #{name} failed to satisfy: #{unsatisfied_prerequisites.inspect}"
+      end
+    end
+  end
+end