logical-construct 0.0.5 → 0.1.0

data/lib/logical-construct/node-client.rb

@@ -0,0 +1,112 @@
+require 'roadforest/remote-host'
+require 'logical-construct/protocol'
+
+module LogicalConstruct
+  class NodeClient
+    class ManifestBuilder
+      include Protocol::PlanValidation
+      def initialize(graph_focus)
+        @graph_focus = graph_focus
+      end
+
+      def plans_list
+        @graph_focus.find_or_add([:lc, "plans"]).as_list
+      end
+
+      def add_plan(plan_archive)
+        name = File::basename(plan_archive)
+        plans_list.append_node("##{name}") do |node|
+          node[[:rdf, "type"  ]] = [:lc, "Need"]
+          node[[ :lc, "name"  ]] = name
+          node[[ :lc, "digest"]] = file_checksum(plan_archive)
+        end
+      end
+    end
+
+    def initialize
+      @plan_archives = []
+      @silent = false
+    end
+
+    attr_accessor :plan_archives, :node_url, :server, :silent
+
+    def server
+      @server ||= RoadForest::RemoteHost.new(node_url).tap do |server|
+        #server.graph_transfer.trace = true
+      end
+    end
+
+    def report(item)
+      puts item unless silent
+    end
+
+    def state
+      state = nil
+      server.getting do |root|
+        state = page_labeled("Current Status", root)[:lc, "node-state"]
+      end
+      state
+    end
+
+    def resolved?
+      state.downcase == "resolved"
+    end
+
+    def page_labeled(label, focus)
+      concept = focus.all(:skos, "hasTopConcept").find do |concept|
+        concept.all(:skos, "prefLabel").include?(label) or concept.all(:skos, "altLabel").include?(label)
+      end
+      concept.first(:foaf, "page")
+    end
+
+    def deliver_manifest
+      report "Delivering manifest"
+      messages = []
+      server.putting do |root|
+        messages = []
+        needs = page_labeled("Server Manifest", root)
+
+        builder = ManifestBuilder.new(needs)
+
+        plan_archives.each do |archive|
+          messages << "Adding #{archive}"
+          builder.add_plan(archive)
+        end
+      end
+      report messages
+    end
+
+    def deliver_plans
+      loop do
+        needs = []
+        server.getting do |root|
+          needs = []
+          unresolved = page_labeled("Unresolved Plans", root)
+
+          unresolved[:lc, "plans"].as_list.each do |need|
+            needs << [need[:lc, "name"], need[:lc, "contents"]]
+          end
+        end
+        if needs.empty?
+          report "Target needs fulfilled"
+          break
+        end
+
+        report "Delivering plan archives"
+        needs.each do |need|
+          name, path = *need
+          plan = plan_archives.find do |plan|
+            File.basename(plan) == name
+          end
+
+          next if plan.nil?
+
+          File::open(plan, "r") do |file|
+            report " Delivering #{name}"
+            server.put_file(path, "application/x-gtar-compressed", file) #sorta like a ukulele
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logical-construct/plan.rb

@@ -0,0 +1,2 @@
+require 'logical-construct/plan/core'
+require 'logical-construct/plan/standalone-bundle'

data/lib/logical-construct/plan/core.rb

@@ -0,0 +1,45 @@
+require 'mattock'
+require 'logical-construct/target/implementation'
+
+module LogicalConstruct
+  module Plan
+    class Core < ::Mattock::Tasklib
+      path(:plan_rakefile, "plan.rake")
+
+      def resolve_configuration
+        self.absolute_path = plan_rakefile.pathname.dirname
+
+        resolve_paths
+        super
+      end
+
+      def define
+        in_namespace do
+          task :compile => 'compile:finished'
+          namespace :compile do
+            task_spine :preflight, :perform, :finished
+          end
+
+          task :install => "install:finished"
+          namespace :install do
+            task_spine :preflight, :perform, :finished
+          end
+
+          Target::Implementation.task_list.each_cons(2) do |first, second|
+            task second => "construct:#{first}"
+          end
+        end
+
+        namespace :construct do
+          Target::Implementation.task_list.each do |name|
+            task name => self[name]
+          end
+
+          [:install, :compile].each do |task|
+            task task => self[task]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logical-construct/plan/standalone-bundle.rb

@@ -0,0 +1,80 @@
+require 'mattock'
+require 'mattock/bundle-command-task'
+
+module LogicalConstruct
+  module Plan
+    class StandaloneBundle < Mattock::TaskLib
+      include Mattock::CommandLineDSL
+      default_namespace :bundler
+
+      dir(:target_dir,
+          path(:gemfile, "Gemfile"),
+          dir(:gems, "gems"))
+
+      def default_configuration(core)
+        super
+        target_dir.absolute_path = core.absolute_path
+      end
+
+      def resolve_configuration
+        resolve_paths
+        super
+      end
+
+      def define
+        directory gems.absolute_path
+
+        #TODO: Experiment with
+        #
+        #bundle install
+        #bundle package --all
+        #....
+        #bundle install --local
+        in_namespace do
+          #bundler unconditionally re-produces bundle/setup.rb, which means
+          #that plans that use this tasklib will always be re-packed, even when
+          #the contents haven't changed significantly.
+          #
+          #It's possible that a "hash difference" file task could be written
+          #for setup.rb? Kind of a hack. Or else tell bundler that it's config
+          #dir goes in a temp directory, and then we move things, or local
+          #rsync --checksum or something.
+          Mattock::BundleCommandTask.define_task(:standalone => gems.absolute_path) do |bundle_build|
+            bundle_build.command = (
+              cmd("cd", target_dir.absolute_path) &
+              cmd("bundle", "install"){|bundler|
+              bundler.options << "--gemfile=" + gemfile.absolute_path
+              bundler.options << "--path=" + gems.absolute_path
+              bundler.options << "--standalone"
+              bundler.options << "--binstubs=bin"
+            })
+          end
+
+          task :pristine => gems.absolute_path do
+            gem_scope = [Gem.ruby_engine, Gem::ConfigMap[:ruby_version]].join("/")
+
+            cmd_env = {
+              "RUBYOPT" => "",
+              "GEM_HOME" => gems.pathname.join(gem_scope).to_s #XXX update this to use gem_scope from flight-deck
+            }
+
+            cmd("gem pristine") do |gem|
+              gem.options << "--all"
+              gem.options << "--extensions"
+              gem.command_environment.merge! cmd_env
+            end.must_succeed!
+          end
+
+          task :load_setup do
+            require gems.pathname.join("bundler/setup")
+          end
+        end
+
+        task 'install:perform' => self[:pristine]
+        task 'compile:perform' => self[:standalone]
+        task 'compile:preflight' => gemfile.absolute_path
+        task :preflight => self[:load_setup]
+      end
+    end
+  end
+end

data/lib/logical-construct/port-open-check.rb

@@ -0,0 +1,41 @@
+module LogicalConstruct
+  class TCPPortOpenCheck
+    def initialize(port)
+      @host = "localhost"
+      @port = port
+      @timeout = 0
+      @retry_delay = 0.5
+      yield self if block_given?
+    end
+    attr_accessor :host, :port
+    attr_accessor :timeout, :retry_delay
+
+    def open_socket
+      TCPSocket.new @host, @port
+    end
+
+    def open?(timeout = nil)
+      timeout ||= @timeout
+      start_time = Time.now
+      test_conn = open_socket()
+      return true
+    rescue Errno::ECONNREFUSED
+      if Time.now - start_time > timeout
+        return false
+      else
+        sleep @retry_delay
+        retry
+      end
+    ensure
+      test_conn.close if test_conn.respond_to? :close
+    end
+
+    def fail_if_open!
+      raise "Port is open, should be closed: #{@host}:#{@port}" if open?(0)
+    end
+
+    def fail_if_closed!
+      raise "Port is closed, should be open: #{@host}:#{@port}" unless open?
+    end
+  end
+end

data/lib/logical-construct/protocol.rb

@@ -0,0 +1,2 @@
+require 'logical-construct/protocol/plan-validation'
+require 'logical-construct/protocol/vocabulary'

data/lib/logical-construct/protocol/plan-validation.rb

@@ -0,0 +1,46 @@
+require 'openssl'
+module LogicalConstruct
+  module Protocol
+    module PlanValidation
+      class DigestFailure < ::StandardError; end
+
+      def digest
+        @digest ||= OpenSSL::Digest::SHA256.new
+      end
+
+      def check_digest(checksum, path, target_path=nil)
+        if file_checksum(path) != checksum
+          raise DigestFailure, "Digest failure for #{target_path || path}"
+        end
+      end
+
+      #The biggest digest-block-length-aligned chunk under 4MB
+      BIG_CHUNK = 4 * 1024 * 1024
+      def chunk_size
+        @chunk_size ||= (BIG_CHUNK / digest.block_length).floor * digest.block_length
+      end
+
+      def realpath(path)
+        File::readlink(path.to_s)
+      rescue Errno::EINVAL, Errno::ENOENT
+        path
+      end
+
+      def file_checksum(path)
+        digest.reset
+        File::open(realpath(path)) do |file|
+          while chunk = file.read(chunk_size)
+            digest.update(chunk)
+          end
+        end
+        digest.hexdigest
+      end
+
+      def generate_checksum(data)
+        digest.reset
+        digest << data
+        digest.hexdigest
+      end
+    end
+  end
+end

data/lib/logical-construct/protocol/ssh-tunnel.rb

@@ -0,0 +1,127 @@
+require 'socket'
+require 'mattock'
+require 'mattock/command-task'
+
+module LogicalConstruct
+  class SSHTunnel < Mattock::Tasklib
+    class OpenPortTask < Mattock::Rake::Task
+      default_taskname :open_port
+      setting :base_port
+      setting :found_port
+
+      def resolve_configuration
+        self.found_port = base_port
+        super
+      end
+
+      def configure_discovery(base_port)
+        self.base_port = base_port
+        return proxy_value.found_port
+      end
+
+      def action(args)
+      test_server = TCPServer.new("0.0.0.0", found_port)
+      rescue Errno::EADDRINUSE
+        self.found_port += 1
+        retry
+      ensure
+        test_server.close
+      end
+    end
+
+    class CreateSSHMaster < Mattock::Rake::CommandTask
+      default_taskname :create_ssh_master
+
+      setting :target_address
+
+      def verify_command
+        cmd("ssh", "-o ControlMaster=auto", "-O check", target_address)
+      end
+
+      def command
+        cmd("ssh", "-Nf", "-o ControlMaster=auto", "-o ControlPersist=300", "-o ExitOnForwardFailure=yes", target_address)
+      end
+
+      def action(args)
+        super
+      rescue StandardError => se
+        puts "Attempting to recover from: #{se.message}"
+        retry
+      end
+    end
+
+    class CreateTunnel < Mattock::Rake::CommandTask
+      default_taskname :create_tunnel
+
+      setting :target_address
+      setting :local_target_port
+      setting :remote_target_port
+
+      def command
+        cmd("ssh", "-O", "forward", "-L", "localhost:#{local_target_port}:localhost:#{remote_target_port}", target_address)
+      end
+    end
+
+    class CancelTask < Mattock::Rake::CommandTask
+      default_taskname :cancel_tunnel
+
+      setting :target_address
+
+      def verify_command
+        cmd("ssh", "-o ControlMaster=auto", "-O check", target_address)
+      end
+
+      def check_verification_command
+        !super
+      end
+
+      def command
+        cmd("ssh", "-n", "-o ControlMaster=auto", "-O exit", target_address)
+      end
+    end
+
+    default_namespace :ssh_tunnel
+
+    runtime_setting :target_address
+    setting :target_port, 10000
+    setting :local_target_port
+    setting :remote_target_port
+
+    def resolve_configuration
+      self.local_target_port ||= target_port
+      self.remote_target_port ||= target_port
+      super
+    end
+
+    def wrap(task_name)
+      task task_name => self[:create_tunnel]
+      task self[:cancel_tunnel] => task_name
+    end
+
+    def define
+      in_namespace do
+        open_port = OpenPortTask.define_task do |open_port|
+          self.local_target_port = open_port.configure_discovery(local_target_port)
+        end
+
+        master = CreateSSHMaster.define_task(self) do |master|
+          copy_settings_to(master)
+        end
+
+        create = CreateTunnel.define_task(self) do |create|
+          copy_settings_to(create)
+        end
+
+        cancel = CancelTask.define_task(self) do |cancel|
+          copy_settings_to(cancel)
+        end
+
+        task_spine create.task_name, :close_tunnel, :run
+
+        task master.task_name => open_port.task_name
+        task create.task_name => master.task_name
+        task :close_tunnel => cancel.task_name
+      end
+    end
+  end
+end