tataru 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e42d1ffd98cb2d158b53f58b572cba30e0e08cb9da10f65386260bf24156b069
+  data.tar.gz: 2078749626908e57c5bef6759dbba0ff2e244638f4811c36d1cfc97dc841a688
+SHA512:
+  metadata.gz: c9eefcedd70c5328abbae21d9e286d751e819f28b7fb85c64468aa3f978ddabb29f3f40cecf4bf557e9eb0da4ee6e78a8cf402b4e49ed9e145586ac3df52cbee
+  data.tar.gz: c5f88a391a8f67f6ab30afd095fbf438a8ae76dcc08e7febbaba563d733f5209da60bbb6c23e3d9f343e0256c04c329f689f1b0dde156083c0d9c3e348f33553

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/tataru.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require 'bunny/tsort'
+
+require 'tataru/version'
+require 'tataru/resource'
+require 'tataru/state'
+require 'tataru/instruction'
+require 'tataru/execution_step'
+require 'tataru/planner'
+require 'tataru/default_resource_finder'
+require 'tataru/requirements_dsl'
+require 'tataru/resource_dsl'
+require 'tataru/requirements'

data/lib/tataru/default_resource_finder.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Tataru
+  # finds resource classes
+  class DefaultResourceFinder
+    def resource_named(name)
+      Kernel.const_get("Tataru::Resources::#{name.to_s.camelize}Resource")
+    end
+  end
+end

data/lib/tataru/execution_step.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Tataru
+  # An execution step
+  class ExecutionStep
+    def initialize(state, instruction)
+      @state = state
+      @instruction = instruction
+      @instances = {}
+    end
+
+    def id
+      @instruction.id
+    end
+
+    def rf
+      @instruction.requirements.resource_finder
+    end
+
+    def type_of_id
+      @instruction.requirements.type(id)
+    end
+
+    def class_of_id
+      rf.resource_named(type_of_id)
+    end
+
+    def instance_of_id
+      @instances[id] ||= class_of_id.new
+    end
+
+    def execute
+      return execute_begin! if @instruction.action.to_s.start_with?('begin_')
+
+      execute_wait!
+    end
+
+    def overall_action
+      @instruction.action.to_s.split('_')[1].to_sym
+    end
+
+    def execute_begin!
+      instance_of_id.send(@instruction.action, @state)
+      [send(:"begin_#{overall_action}"), true]
+    end
+
+    def begin_create
+      new_state = @state.clone
+      replacer = true
+      replacer = false if new_state[id].nil?
+
+      @instruction.state.each do |name, value|
+        new_state.putstate(id, name, value, replacer: replacer)
+      end
+      new_state.waiting_on(id, overall_action)
+      new_state
+    end
+
+    def begin_delete
+      begin_update
+    end
+
+    def begin_update
+      new_state = @state.clone
+      new_state.waiting_on(id, overall_action)
+      new_state
+    end
+
+    def execute_wait!
+      new_state = @state.clone
+      success = instance_of_id.send(:"#{overall_action}_complete?", @state)
+      if success
+        new_state.no_longer_waiting(id)
+        new_state.replace(id) if overall_action == :delete
+      end
+      [new_state, success]
+    end
+  end
+end

data/lib/tataru/instruction.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Tataru
+  # An instruction
+  class Instruction
+    attr_reader :action, :id, :state, :requirements
+
+    def initialize(action, id, state, requirements)
+      @action = action
+      @id = id
+      @state = state
+      @requirements = requirements
+    end
+  end
+end

data/lib/tataru/planner.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Rage
+    # not valid
+    class InvalidRequirement < StandardError; end
+  end
+
+
+  # A plan
+  class Planner
+    def initialize(current_state, requirement)
+      @current_state = current_state
+      @requirement = requirement
+      @actions = {}
+
+      raise Rage::InvalidRequirement unless requirement.valid?
+    end
+
+    def order
+      Bunny::Tsort.tsort(@requirement.dep_tree)
+    end
+
+    def delete_instruction_for(id, pref)
+      Instruction.new(:"#{pref}_delete", id, @current_state[id], @requirement)
+    end
+
+    def generate_delete_instruction_for(id, pref)
+      return if @current_state[id].nil?
+      return unless action(id) == :replace
+
+      delete_instruction_for(id, pref)
+    end
+
+    def generate_instruction_for(id, pref)
+      if @current_state[id].nil?
+        Instruction.new(:"#{pref}_create", id, end_state[id], @requirement)
+      elsif action(id) == :replace
+        Instruction.new(:"#{pref}_create", id, end_state[id], @requirement)
+      elsif action(id) == :update
+        Instruction.new(:"#{pref}_update", id, end_state[id], @requirement)
+      end
+    end
+
+    def generate_removal_instructions
+      remove_actions = []
+      @current_state.id_list.keys.each do |id|
+        next if @requirement.exist? id
+
+        remove_actions << delete_instruction_for(id, :begin)
+      end
+      remove_actions
+    end
+
+    def generate_delete_instructions
+      delete_actions = []
+      order.reverse.each do |step|
+        %i[begin wait].each do |substep|
+          step.each do |id|
+            delete_action = generate_delete_instruction_for(id, substep)
+            delete_actions << delete_action unless delete_action.nil?
+          end
+        end
+      end
+      delete_actions + generate_removal_instructions
+    end
+
+    def generate_instructions
+      instr = []
+      order.each do |step|
+        %i[begin wait].each do |substep|
+          step.each do |id|
+            instruction = generate_instruction_for(id, substep)
+            instr << instruction unless instruction.nil?
+          end
+        end
+      end
+      instr + generate_delete_instructions
+    end
+
+    def instructions
+      @instructions ||= generate_instructions
+    end
+
+    def action(id)
+      @actions[id] ||= @requirement.action(id, @current_state[id])
+    end
+
+    def end_state
+      @requirement.end_state
+    end
+  end
+end

data/lib/tataru/requirements.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Tataru
+  # Requirements list
+  class Requirements
+    attr_reader :resource_finder, :errors
+
+    def initialize(resource_finder = DefaultResourceFinder.new, &block)
+      dsl = RequirementsDSL.new(resource_finder)
+      dsl.instance_exec(&block)
+      @errors = dsl.errors
+      @reqs = dsl.resource_list
+      @resource_finder = resource_finder
+    end
+
+    def dep_tree
+      @reqs.map { |k, v| [k, v[:dependencies]] }.to_h
+    end
+
+    def end_state
+      state = State.new
+      @reqs.each do |id, info|
+        info[:state].each do |state_name, state_value|
+          state.putstate(id, state_name, state_value)
+        end
+      end
+      state
+    end
+
+    def exist?(id)
+      @reqs.key? id
+    end
+
+    def type(id)
+      @reqs[id][:type]
+    end
+
+    def valid?
+      errors.length.zero?
+    end
+
+    def compare(id, current_state)
+      rclass = @resource_finder.resource_named(type(id))
+      resdef = rclass.new
+      changed = false
+      replace = false
+
+      current_state.each do |state_name, current_value|
+        next if current_value == @reqs[id][:state][state_name]
+
+        changed = true
+        replace ||= resdef.send(:"#{state_name}_change_action") == :replace
+      end
+
+      [changed, replace]
+    end
+
+    def action(id, current_state)
+      changed, replace = compare(id, current_state)
+
+      return :nothing unless changed
+      return :update unless replace
+
+      :replace
+    end
+  end
+end

data/lib/tataru/requirements_dsl.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Tataru
+  # Requirements DSL
+  class RequirementsDSL
+    attr_reader :resource_list
+
+    def initialize(resource_finder)
+      @resource_finder = resource_finder
+      @resource_list = {}
+    end
+
+    def respond_to_missing?
+      true
+    end
+
+    def method_missing(type, name, &block)
+      rclass = @resource_finder.resource_named(type)
+      res = ResourceDSL.new(rclass.new)
+      res.instance_exec(&block) if block
+      @resource_list[name] = {
+        type: type, dependencies: res.dependencies,
+        state: res.fields, errors: res.errors
+      }
+    rescue NameError
+      super
+    end
+
+    def errors
+      @resource_list.flat_map { |_, v| v[:errors] }
+    end
+  end
+end

data/lib/tataru/resource.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Tataru
+  # base resource class
+  class Resource
+    class << self
+      def state(state_name, change_behaviour)
+        define_method "#{state_name}_change_action" do
+          change_behaviour
+        end
+
+        define_method "_state_#{state_name}" do
+          state_name
+        end
+      end
+
+      def output(output_name)
+        define_method "_output_#{output_name}" do
+          output_name
+        end
+
+        define_method(output_name) {}
+      end
+    end
+
+    def states
+      list_props(:state)
+    end
+
+    def outputs
+      list_props(:output)
+    end
+
+    %i[
+      begin_create
+      begin_update
+      begin_delete
+      create_complete?
+      update_complete?
+      delete_complete?
+    ].each do |thing|
+      define_method(thing) { |_state| }
+    end
+
+    private
+
+    def list_props(prop_type)
+      methods.select { |x| x.to_s.start_with? "_#{prop_type}_" }
+             .map { |x| x.to_s.sub("_#{prop_type}_", '').to_sym }
+    end
+  end
+end

data/lib/tataru/resource_dsl.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Tataru
+  module DoLater
+    # delayed expression
+    class Expression
+      def requested_resources
+        raise 'Abstract class'
+      end
+    end
+
+    # placeholder for extern resource
+    class ExternResourcePlaceholder < Expression
+      def initialize(name)
+        @name = name
+      end
+
+      def respond_to_missing?
+        true
+      end
+
+      def method_missing(name, *_args)
+        super if name.nil?
+
+        MemberCallPlaceholder.new(self, name)
+      end
+
+      def requested_resources
+        [@name]
+      end
+    end
+
+    # placeholder for member call
+    class MemberCallPlaceholder < ExternResourcePlaceholder
+      def initialize(expr, member)
+        @expr = expr
+        @member = member
+      end
+
+      def requested_resources
+        @expr.requested_resources
+      end
+    end
+  end
+
+  # Resource DSL
+  class ResourceDSL
+    attr_reader :fields, :extern_refs
+
+    def initialize(resource_inst)
+      @resource_inst = resource_inst
+      @fields = {}
+      @extern_refs = {}
+    end
+
+    def respond_to_missing?
+      true
+    end
+
+    def method_missing(name, *args, &block)
+      if @resource_inst.respond_to?("#{name}_change_action")
+        @fields[name] = args[0]
+      elsif name.to_s.start_with?(/[a-z]/)
+        @extern_refs[name] ||= DoLater::ExternResourcePlaceholder.new(name)
+      else
+        super
+      end
+    end
+
+    def errors
+      (@resource_inst.states - @fields.keys).map do |x|
+        { missing_state: x }
+      end
+    end
+
+    def dependencies
+      deps = []
+      @fields.each do |_name, info|
+        next unless info.is_a? DoLater::Expression
+
+        deps += info.requested_resources
+      end
+      deps.map(&:to_s).uniq
+    end
+  end
+end

data/lib/tataru/state.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Tataru
+  # The state of the environment
+  class State
+    def initialize(objstate = {})
+      @current_ids = objstate[:current_ids] || {}
+      @replacer_ids = objstate[:replacer_ids] || {}
+      @waiting_ids = objstate[:waiting_ids] || {}
+    end
+
+    def putstate(id, state, value, replacer: false)
+      ids = id_list(replacer)
+      ids[id] = {} unless ids.key? id
+      ids[id][state] = value
+    end
+
+    def getstate(id, state, replacer: false)
+      ids = id_list(replacer)
+      return unless ids.key? id
+
+      ids[id][state]
+    end
+
+    def id_list(replacer = false)
+      return @replacer_ids if replacer
+
+      @current_ids
+    end
+
+    def replace(id)
+      @current_ids[id] = @replacer_ids[id]
+      @replacer_ids.delete(id)
+    end
+
+    def delete_list
+      @replacer_ids.keys.select { |x| @current_ids.key? x }
+    end
+
+    def [](id)
+      @current_ids[id].clone
+    end
+
+    def waiting_on(id, what)
+      @waiting_ids[id] = what
+    end
+
+    def no_longer_waiting(id)
+      @waiting_ids.delete(id)
+    end
+
+    def waiting_list
+      @waiting_ids.clone
+    end
+
+    def to_h
+      {
+        current_ids: @current_ids,
+        replacer_ids: @replacer_ids,
+        waiting_ids: @waiting_ids
+      }
+    end
+  end
+end

data/lib/tataru/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Tataru
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: tataru
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Siaw
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bunny-tsort
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Sworn upon the name of the receptionist
+email:
+- dsiaw@degica.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/tataru.rb
+- lib/tataru/default_resource_finder.rb
+- lib/tataru/execution_step.rb
+- lib/tataru/instruction.rb
+- lib/tataru/planner.rb
+- lib/tataru/requirements.rb
+- lib/tataru/requirements_dsl.rb
+- lib/tataru/resource.rb
+- lib/tataru/resource_dsl.rb
+- lib/tataru/state.rb
+- lib/tataru/version.rb
+homepage: https://github.com/davidsiaw/tataru
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/davidsiaw/tataru
+  source_code_uri: https://github.com/davidsiaw/tataru
+  changelog_uri: https://github.com/davidsiaw/tataru
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Task planner
+test_files: []