logical-construct 0.0.5 → 0.1.0

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

@@ -0,0 +1,33 @@
+require 'mattock/tasklib'
+
+module LogicalConstruct
+  module Target
+    class Implementation < ::Mattock::Tasklib
+      def self.task_list
+        [
+          :preflight, #Is this node acceptable?
+          :settings, #Shared in-memory configuration for the overall setup
+          :setup, #write configuration to disk for implementation tools (e.g. Chef, Puppet, apt-get)
+          :files, #deliver files from plan to filesystem
+          :execute, #run implementation tools
+          :configure, #install application configuration files (e.g. /etc/apache/http.conf)
+          :complete #All done - depends on everything.
+        ]
+      end
+
+      default_namespace :construct
+
+      def define
+        in_namespace do
+          task_spine( *self.class.task_list )
+
+          self.class.task_list.each do |taskname|
+            task taskname do
+              puts "*** Implementation stage complete: #{taskname}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logical-construct/target/plan-records.rb

@@ -0,0 +1,317 @@
+require 'fileutils'
+require 'thread'
+require 'logical-construct/protocol'
+
+module LogicalConstruct
+  module ResolutionServer
+    class PlanRecords
+      include Enumerable
+
+      Record = Struct.new(:name, :filehash)
+      Directories = Struct.new(:delivered, :current, :stored)
+
+      def initialize
+        @record_lock = Mutex.new
+        @records = []
+        @directories = Directories.new(nil, nil, nil)
+      end
+      attr_reader :directories
+
+      def reset!
+        each do |record|
+          record.cancel!
+        end
+        @records.clear
+        clear_files(directories.delivered)
+        clear_files(directories.current)
+      end
+      alias reset reset!
+
+      def clear_files(directory)
+        dirpath = Pathname.new(directory)
+        dirpath.mkpath
+        dirpath.each_child do |delivered|
+          delivered.delete
+        end
+      end
+
+      def total_state
+        return "no-plans-yet" if @records.empty?
+        return "resolved" if @records.all?(&:resolved?)
+        return "unresolved"
+      end
+
+      def find(name)
+        record = @records.find{|record| record.name == name}
+      end
+
+      def each(&block)
+        @records.each(&block)
+      end
+
+      def add(name, hash)
+        record = nil
+        @record_lock.synchronize do
+          if @records.any?{|record| record.name == name}
+            raise "Cannot add a second plan requirement for #{name}"
+          end
+          record = States::Unresolved.new(self, Record.new(name, hash))
+          @records << record
+        end
+        record.resolve
+
+        return find(name)
+      end
+
+      def change(old_state, new_state_class)
+        unless old_state.alive?
+          raise "Tried to change from old invalid state: #{old_state}"
+        end
+        new_state = new_state_class.new(self, old_state.record)
+
+        @record_lock.synchronize do
+          @records.delete(old_state)
+          @records << new_state
+          old_state.cancel!
+        end
+        new_state.enter
+
+        return new_state
+      end
+    end
+
+    module States
+      class PlanState
+        include Protocol::PlanValidation
+        include FileTest
+
+        def initialize(records, record)
+          @records, @record = records, record
+        end
+        attr_reader :record
+
+        def inspect
+          "#<#{self.class.name}:#{"0x%0x"%object_id} #{name||"dead"}:#{filehash}>"
+        end
+
+        def ==(other)
+          return true if self.equal?(other)
+          return false if !self.alive? or !other.alive?
+          return (other.class.equal?(self.class) and
+                  other.name.equal?(self.name) and
+                  other.filehash.equal?(self.filehash))
+        end
+
+
+        def name
+          return nil unless alive?
+          @record.name
+        end
+
+        def filehash
+          return nil unless alive?
+          @record.filehash
+        end
+
+        def enter
+        end
+
+        def cancel!
+          @record = nil
+        end
+
+        def alive?
+          !@record.nil?
+        end
+
+        def exists?(path)
+          super(realpath(path))
+        end
+
+        def delivered_plans_dir
+          @records.directories.delivered
+        end
+
+        def current_plans_dir
+          @records.directories.current
+        end
+
+        def stored_plans_dir
+          @records.directories.stored
+        end
+
+        def resolved?
+          false
+        end
+
+        def can_receive?
+          false
+        end
+
+        def change(next_state)
+          @records.change(self, next_state)
+        end
+
+        def received_path
+          @received_path ||= Pathname.new(delivered_plans_dir) + name
+        end
+
+        def storage_path_for(actual_hash)
+          @stored_path ||= Pathname.new(stored_plans_dir) + [name, actual_hash].join(".")
+        end
+
+        def current_path
+          @current_path ||= Pathname.new(current_plans_dir) + name
+        end
+
+        def resolve
+          warn "Cannot resolve plan in current state: #{state}"
+        end
+
+        def receive
+          warn "Cannot receive file in current state: #{state}"
+        end
+
+        def state
+          self.class.name.sub(/.*::/,'').downcase
+        end
+
+        def join
+          return
+        end
+      end
+
+      class Unresolved < PlanState
+        def can_receive?
+          true
+        end
+
+        def store_received_file(actual_hash)
+          stored_path = storage_path_for(actual_hash)
+          FileUtils.mkdir_p(stored_plans_dir)
+          unless exists?(stored_path)
+            FileUtils.mv(received_path, stored_path)
+            FileUtils.symlink(stored_path, received_path)
+          end
+        end
+
+        def enter
+          unless alive?
+            super
+            return false
+          end
+
+          unless exists?(received_path)
+            return false
+          end
+
+          actual_hash = file_checksum(received_path)
+
+          store_received_file(actual_hash)
+
+          if actual_hash == filehash
+            FileUtils.cp(received_path.readlink, current_path.to_s)
+            change(Resolved)
+          else
+            received_path.delete
+            return false
+          end
+        end
+        alias receive enter
+
+        def resolve
+          unless alive?
+            super
+            return false
+          end
+          change(Resolving)
+        end
+      end
+
+      class Resolving < PlanState
+        def cancel!
+          unless @thread.nil?
+            if @working
+              @thread.kill
+            end
+          end
+          super
+        end
+
+        def join
+          super if @thread.nil?
+          @thread.join
+        end
+
+        def enter
+          @working = true
+          @thread = Thread.new do
+            ResolutionMethods.run_all(self)
+            @working = false
+            change(Unresolved)
+          end
+        end
+      end
+
+      class Resolved < PlanState
+        def resolved?
+          true
+        end
+      end
+    end
+
+    module ResolutionMethods
+      class << self
+        def resolution_methods
+          @methods ||= []
+        end
+
+        def add_method(name, klass)
+          resolution_methods << [name, klass]
+        end
+
+        def run_all(state)
+          resolution_methods.each do |name, klass|
+            klass.new(state).run
+          end
+        end
+      end
+
+      class ResolutionMethod
+        include Protocol::PlanValidation
+        include FileTest
+
+        def self.register(name)
+          ResolutionMethods.add_method(name, self)
+        end
+
+        def exists?(path)
+          super(realpath(path))
+        end
+
+        def initialize(state)
+          @state = state
+        end
+        attr_reader :state
+
+        def run
+
+        end
+      end
+
+      class LocalStorage < ResolutionMethod
+        register :local_storage
+
+        def run
+          stored_path = state.storage_path_for(state.record.filehash)
+          received_path = state.received_path
+
+          if exists?(stored_path) and not (exists?(received_path) or symlink?(received_path))
+            FileUtils.symlink(stored_path, received_path)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/logical-construct/target/resolution-server.rb

@@ -0,0 +1,153 @@
+require 'rdf/vocab/skos'
+require 'roadforest/server'
+require 'logical-construct/protocol'
+require 'logical-construct/target/plan-records'
+
+module LogicalConstruct
+  module ResolutionServer
+    class Application < ::RoadForest::Application
+      def setup
+        router.add  :root,              [],                    :read_only,  Models::Navigation
+        router.add  :status,            ["status"],            :read_only,  Models::ServerStatus
+        router.add  :manifest,          ["manifest"],          :leaf,       Models::ServerManifest
+        router.add  :unresolved_plans,  ["unresolved_plans"],  :parent,     Models::UnresolvedPlansList
+        router.add  :full_plans,        ["full_plans"],        :parent,     Models::FullPlansList
+        router.add  :plan,              ["plans",'*'],         :leaf,       Models::Plan
+        router.add  :file_content,      ["files","*"],         :leaf,       Models::PlanContent
+      end
+    end
+
+    class ServicesHost < ::RoadForest::Application::ServicesHost
+      attr_accessor :plan_records
+
+      def initialize
+        @plan_records = PlanRecords.new
+      end
+
+      def destination_dir
+        plan_records.directories.delivered
+      end
+    end
+
+    module Models
+      class Navigation < RoadForest::RDFModel
+        def exists?
+          true
+        end
+
+        def update(graph)
+          return false
+        end
+
+        def nav_entry(graph, name, path)
+          graph.add_node([:skos, :hasTopConcept], "#" + name) do |entry|
+            entry[:rdf, :type] = [:skos, "Concept"]
+            entry[:skos, :prefLabel] = name
+            entry[:foaf, "page"] = path
+          end
+        end
+
+        def fill_graph(graph)
+          graph[:rdf, "type"] = [:skos, "ConceptScheme"]
+          nav_entry(graph, "Server Manifest", path_for(:manifest))
+          nav_entry(graph, "Unresolved Plans", path_for(:unresolved_plans))
+          nav_entry(graph, "All Plans", path_for(:full_plans))
+          nav_entry(graph, "Current Status", path_for(:status))
+        end
+      end
+
+      class ServerStatus < RoadForest::RDFModel
+        def data
+          services.plan_records.total_state
+        end
+
+        def fill_graph(graph)
+          graph[[:lc, "node-state"]] = data
+        end
+      end
+
+      class ServerManifest < RoadForest::RDFModel
+        def fill_graph(graph)
+          graph.add_list(:lc, "plans") do |list|
+            services.plan_records.each do |record|
+              list << path_for(:plan, '*' => record.name)
+            end
+          end
+        end
+
+        def graph_update(graph)
+          services.plan_records.reset!
+
+          graph[:lc, "plans"].as_list.each do |plan|
+            services.plan_records.add(plan.first(:lc, "name"), plan.first(:lc, "digest"))
+          end
+
+          new_graph
+        end
+      end
+
+      class FullPlansList < RoadForest::RDFModel
+        def exists?
+          true
+        end
+
+        def update(graph)
+        end
+
+        def add_child(graph)
+          services.plan_records.add(graph.first(:lc, "name"), graph.first(:lc, "digest"))
+        end
+
+        def plan_records
+          services.plan_records
+        end
+
+        def fill_graph(graph)
+          graph.add_list(:lc, "plans") do |list|
+            plan_records.each do |record|
+              list << path_for(:plan, '*' => record.name)
+            end
+          end
+        end
+      end
+
+      class UnresolvedPlansList < FullPlansList
+        def plan_records
+          #recheck resolution?
+          services.plan_records.find_all{|record| !record.resolved?}
+        end
+      end
+
+      class PlanContent < RoadForest::BlobModel
+        add_type "text/plain", TypeHandlers::Handler.new
+        add_type "application/octet-stream", TypeHandlers::Handler.new
+        add_type "application/x-gtar-compressed", TypeHandlers::Handler.new
+
+        def update(file)
+          name = params.remainder
+          record = services.plan_records.find(name)
+          raise "Unexpected file: #{name}" if record.nil?
+          raise "Plan already resolved: #{name}" unless record.can_receive?
+
+          super(file)
+
+          record.receive
+
+          nil
+        end
+      end
+
+      class Plan < RoadForest::RDFModel
+        def data
+          @data = services.plan_records.find(params.remainder)
+        end
+
+        def fill_graph(graph)
+          graph[[:lc, "name"]] = data.name
+          graph[[:lc, "digest"]] = data.filehash
+          graph[[:lc, "contents"]] = path_for(:file_content)
+        end
+      end
+    end
+  end
+end