rbcm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fa6e34e5939d408f93ecd34e461a369c1a7f5fd703a75cba0c1a29070873c58e
+  data.tar.gz: 124be8f09ba8c960d942daf7cc43c6b80daae64711fcc4de209c51ec8a533fda
+SHA512:
+  metadata.gz: a8de4fcc12dea85e1d5ec40bdd96db45d546fbe002e438a8520d2392ee17cd2209f1ac90391955c3456f3e529233558d67a621ab1203fb3edfb4f823c406a3f5
+  data.tar.gz: 600bcbd768053eeee04d72b87477cc1128c34786656c44a8d14a3843a158a69157eee9b71b037ec3a0654fef164f0f798db534530dc4a4baf6ef703a4420405d

data/app/action/action.rb

@@ -0,0 +1,75 @@
+class Action
+  attr_accessor :approved, :applied
+  attr_reader   :node, :triggered_by, :trigger, :chain, :dependencies,
+                :capability, :obsolete, :job, :check, :triggered, :result,
+                :source, :path, :tags
+
+  def initialize job:, chain:, path: nil, params: nil, line: nil, check: nil,
+                 dependencies: nil, trigger: nil, triggered_by: nil,
+                 source: nil, tags: nil
+    @dependencies = [:file] + [dependencies].flatten - [chain.last]
+    @trigger = [trigger, chain.last].flatten.compact
+    @triggered_by = [triggered_by].flatten.compact
+    @triggered = [];              @source = source
+    @node = job.node;             @job = job
+    @chain = chain;               @capability = chain.last
+    @obsolete = nil;              @approved = nil
+    @tags = tags.compact.flatten
+    # command specific
+    @line = line;                @check = check
+    # file specific
+    @path = path;                @params = params
+  end
+
+  def checkable?
+    true if @check or self.class == Action::File
+  end
+
+  def neccessary?
+    check!
+    not obsolete
+  end
+
+  def approved?
+    @approved
+  end
+
+  def approvable?
+    neccessary? and triggered? and approved? == nil
+  end
+
+  def applyable?
+    approved? and not applied?
+  end
+
+  def triggered?
+    triggered_by.empty? or triggered_by.one? do |triggered_by|
+      @node.triggered.flatten.include? triggered_by
+    end
+  end
+
+  def applied?
+    @applied
+  end
+
+  def succeeded?
+    pp self.chain unless @result
+    @result.exitstatus == 0
+  end
+
+  def failed?
+    @result.exitstatus != 0
+  end
+
+  def approve! input=:y
+    if [:a, :y].include? input
+      @node.files[@path].content = content if self.class == Action::File
+      @approved = true
+      siblings.each.approve! if input == :a
+      @node.triggered << @trigger
+      @triggered = @trigger.compact - @node.triggered
+    else
+      @approved = false
+    end
+  end
+end

data/app/action/command.rb

@@ -0,0 +1,26 @@
+class Action::Command < Action
+  attr_reader :line
+
+  # determine wether the command is neccessary
+  def check!
+    return if @obsolete != nil
+    if @check
+      @obsolete = @node.remote.execute(@check).exitstatus == 0
+    else
+      @obsolete = false
+    end
+  end
+
+  # matching commands on  other nodes to be approved at once
+  def siblings
+    @node.rbcm.actions.select{ |action|
+      action.chain[1..-1] == @chain[1..-1] and action.line == @line
+    } - [self]
+  end
+
+  # execute the command remote
+  def apply!
+    @applied = true
+    @result = @node.remote.execute(@line)
+  end
+end

data/app/action/file.rb

@@ -0,0 +1,38 @@
+# ToDo: approve all changes to a spicific file at once
+class Action::File < Action
+  attr_reader :path, :content
+
+  def check!
+    # compare
+    @node.files[path].content
+  end
+
+  def obsolete
+    @node.files[path].content.chomp.chomp == content.chomp.chomp
+  end
+
+  def siblings
+    [] # TODO
+  end
+
+  def apply!
+    @applied = true
+    @result = @node.remote.execute("echo #{Shellwords.escape content} > #{path}")
+  end
+
+  def content
+    @content ||= if @params[:content]
+      @params[:content].to_s
+    elsif @params[:template]
+      Node::Template.new(
+        name: @params[:template],
+        capability: @chain[-1],
+        context: @params[:context]
+      ).render
+    end
+  end
+
+  def same_file
+    @node.actions.file(path) - [self]
+  end
+end

data/app/action/list.rb

@@ -0,0 +1,83 @@
+class ActionList < Array
+  def initialize array=[]
+    array.each do |element|
+      insert -1, element
+    end
+  end
+
+  def resolve_dependencies
+    @actions = []
+    self.each do |action|
+      resolve_action_dependencies action
+    end
+    ActionList.new @actions
+  end
+
+  def resolve_triggers
+    @actions = []
+    self.each do |action|
+      resolve_action_triggers action
+    end
+    ActionList.new @actions
+  end
+
+  def file path
+    ActionList.new select{|action| action.path == path}
+  end
+
+  def checkable
+    ActionList.new select.checkable?
+  end
+
+  def unneccessary
+    ActionList.new (self - neccessary)
+  end
+
+  def neccessary
+    ActionList.new select.neccessary?
+  end
+
+  def approvable
+    ActionList.new select.approvable?
+  end
+
+  def approved
+    ActionList.new select.approved?
+  end
+
+  def applyable
+    ActionList.new select.applyable?
+  end
+
+  def applied
+    ActionList.new select.applied?
+  end
+
+  def succeeded
+    ActionList.new applied.select.succeeded?
+  end
+
+  def failed
+    ActionList.new applied.select.failed?
+  end
+
+  private
+
+  def resolve_action_dependencies this
+    self.select{ |action|
+      this.dependencies.include? action.capability
+    }.each{ |action|
+      resolve_action_dependencies action
+    }
+    @actions << this unless @actions.include? this
+  end
+
+  def resolve_action_triggers this
+    self.select{ |action|
+      this.trigger.one?{|trigger| action.triggered_by.include? trigger}
+    }.each{ |action|
+      resolve_action_triggers action
+    }
+    @actions << this unless @actions.include? this
+  end
+end

data/app/cli.rb

@@ -0,0 +1,153 @@
+class CLI
+  def initialize params
+    options = Options.new params
+    render section: "RBCM starting", first: true
+    # bootstrap
+    @rbcm = rbcm = RBCM.new params[0] || `pwd`.chomp
+    render :project
+    render :capabilities
+    # parse
+    rbcm.parse
+    render :nodes
+    # check
+    render section: "CHECKING #{rbcm.actions.checkable.count} actions on #{rbcm.nodes.count} nodes"
+    rbcm.actions.each do |action|
+      check action
+    end
+    # approve
+    render section: "APPROVING #{rbcm.actions.approvable.count}/#{rbcm.actions.unneccessary.count} actions"
+    approve rbcm.actions.unneccessary.resolve_triggers
+    while action = rbcm.actions.approvable.resolve_triggers.first
+      approve action
+      if action.approved?
+        approve action.siblings
+        approve action.same_file if action.class == Action::File
+      end
+    end
+    # apply
+    render section: "APPLYING #{rbcm.actions.approved.count} actions"
+    while action = rbcm.actions.applyable.resolve_dependencies.first
+      apply action
+    end
+    # finish
+    render :applied
+    puts "┗━━──"
+  end
+
+  private
+
+  def check action
+    @action = action
+    render checking: action.check
+    action.check!
+  end
+
+  def approve actions
+    [actions].flatten(1).each do |action|
+      @action = action
+      render :title, color: (action.obsolete ? :green : :yellow)
+      render :command if action.class == Action::Command
+      next if not action.approvable?
+      render :siblings if action.siblings.any?
+      render :source if action.source.any?
+      render :diff if action.class == Action::File
+      render :prompt
+      sleep 0.25 unless [:a,:y,:n].include? r = STDIN.getch.to_sym # avoid 'ctrl-c'-trap
+      action.approve! r
+      render :approved
+      render :triggered if action.triggered.any?
+    end
+  end
+
+  def apply actions
+    [actions].flatten(1).each do |action|
+      @action = action
+      response = action.apply!
+      render :title, color: response.exitstatus == 0 ? :green : :red
+      render :command if response.exitstatus != 0
+      render response: response if response.length > 0
+    end
+  end
+
+  def render element=nil, section: nil, color: nil, first: false, response: nil, checking: nil
+    prefix = "┃   "
+    if section
+      out "#{first ? nil : "┗━━──"}\n\n┏━━#{format :invert, :bold}#{" "*16}#{section}#{" "*16}#{format}━──\n┃"
+    elsif element == :title
+      triggerd_by = "#{format :trigger, :bold} #{@action.triggered_by.join(", ")} " if @action.triggered_by.any?
+        out "┣━ #{triggerd_by}#{format color, :bold} #{(@action.chain).join(" > ")} " +
+        "#{format} #{format :params}#{@action.job.params}#{format}" +
+        " #{format :tag}#{"tags: " if @action.tags.any?}#{@action.tags.join(", ")}#{format}"
+    elsif element == :capabilities
+      out prefix + "capabilities: #{Node::Sandbox.capabilities.join(", ")}"
+    elsif element == :project
+      out prefix + "project: #{@rbcm.project.files.count} ruby files"
+    elsif element == :nodes
+      out prefix + @rbcm.nodes.values.collect{ |node|
+        name = node.name.+(":").ljust(@rbcm.nodes.keys.each.length.max+1, " ")
+        jobs = node.jobs.count.to_s.rjust(@rbcm.nodes.values.collect{|node| node.jobs.count}.max.digits.count, " ")
+        actions = node.actions.count.to_s.rjust(@rbcm.nodes.values.collect{|node| node.actions.count}.max.digits.count, " ")
+        "#{name} #{jobs} jobs, #{actions} actions"
+      }.flatten(1).join("\n#{prefix}")
+    elsif element == :command
+      check_string = " UNLESS #{@action.check}" if @action.check
+      out prefix + "$> #{@action.line}\e[2m#{check_string}\e[0m"
+    elsif element == :siblings
+      string = @action.siblings.collect do |sibling|
+        "#{sibling.neccessary? ? format(:yellow) : format(:green)} #{sibling.node.name} #{format}"
+      end.join
+      out prefix + "#{format :siblings}siblings:#{format} #{string}"
+    elsif element == :source
+      out prefix + "source: #{format :bold}#{@source.join("#{format}, #{format :bold}")}#{format}"
+    elsif element == :prompt
+      color = @action.siblings.any? ? :siblings : :light
+      print prefix + "APPROVE? #{format color}[a]ll#{format}, [y]es, [N]o: "
+    elsif element == :triggered
+      out prefix +
+        "triggered: #{format :trigger} #{@action.triggered.join(", ")} \e[0m;" +
+        " again: #{@action.trigger.-(@action.triggered).join(", ")}"
+    elsif element == :diff
+      out prefix[0..-2] + Diffy::Diff.new(
+        @action.node.files[@action.path].content,
+        @action.content
+      ).to_s(:color).split("\n").join("\n#{prefix[0..-2]}")
+    elsif element == :approved
+      string = @action.approved? ? "#{format :green} APPROVED" : "#{format :red} DECLINED"
+      puts "#{string} #{format}"
+    elsif element.class == String
+      out prefix + "#{element}"
+    elsif checking
+      out prefix + "CHECKING #{@action.node.name}: #{checking}"
+    elsif response
+      out prefix + response.to_s.chomp.split("\n").join("\n#{prefix}")
+    elsif element == :applied
+      out prefix
+      out "┣━\ #{format :green, :bold} #{@rbcm.actions.succeeded.count} secceeded #{format}"
+      out "┣━\ #{format :red, :bold} #{@rbcm.actions.failed.count} failed #{format}"
+    else
+    end
+  end
+
+  def out line
+    puts "\r#{line}"
+  end
+
+  def format *params, **_
+    "\e[0m" + {
+      reset:    "\e[0m",
+      bold:     "\e[1m",
+      light:    "\e[2m",
+      invert:   "\e[7m",
+      trigger:  "\e[30;46m",
+      red:      "\e[30;101m",
+      green:    "\e[30;42m",
+      yellow:   "\e[30;43m",
+      cyan:     "\e[36m",
+      tag:      "\e[35m",
+      params:   "\e[36m",
+      siblings: "\e[35m"
+    }.select{ |key, _|
+      params.include? key
+    }.values.join
+  end
+end

data/app/lib/array_hash.rb

@@ -0,0 +1,9 @@
+# a hash which keys are initiated as arrays
+# default values via `Hash.new []` are inadequate for being volatile 
+
+class ArrayHash < Hash
+  def [] key
+    store key, [] unless has_key? key
+    super
+  end
+end

data/app/lib/lib.rb

@@ -0,0 +1,32 @@
+def log notice, warning: nil, error: nil
+  puts "┃\ \ \ \e[2m#{notice or warning or error}\e[0m"
+end
+
+# https://mrbrdo.wordpress.com/2013/02/27/ruby-with-statement/
+module Kernel
+  def with(object, &block)
+    object.instance_eval &block
+  end
+end
+
+class Hash
+  def << hash
+    merge! hash
+  end
+end
+
+class Array
+  def include_one? array
+    (self & array).any?
+  end
+end
+
+# a hash which keys are initiated as arrays
+# default values via `Hash.new []` are inadequate for being volatile
+
+class ArrayHash < Hash
+  def [] key
+    store key, [] unless has_key? key
+    super
+  end
+end

data/app/lib/options.rb

@@ -0,0 +1,6 @@
+# https://docs.ruby-lang.org/en/2.1.0/OptionParser.html
+
+class Options
+  def initialize params
+  end
+end

data/app/lib/params.rb

@@ -0,0 +1,52 @@
+class Params
+  attr_reader :ordered, :named
+
+  def initialize ordered, named
+    @ordered, @named = ordered, named
+  end
+
+  def [] key
+    return ordered[key] if key.class == Integer
+    return named[key] if key.class == Symbol
+  end
+
+  def []= key, value
+    ordered[key] = value if key.class == Integer
+    named[key] = value if key.class == Symbol
+  end
+
+  def to_s
+    [ ordered.collect{ |param|
+        "#{param}"
+      },
+      named.collect{ |k, v|
+        "\e[2m\e[1m#{k}:\e[21m\e[22m #{v[0..40].to_s.gsub("\n"," \\ ")}#{"\e[2m\e[1m…\e[21m\e[22m" if v.length > 40}"
+      }
+    ].flatten(1).join("\e[2m\e[1m, \e[21m\e[22m")
+  end
+
+  def sendable
+    [*ordered, named.any? ? named : nil].compact
+  end
+
+  def empty?
+    true if ordered.none? and named.none?
+  end
+
+  def first
+    ordered[0]
+  end
+
+  def second
+    ordered[1]
+  end
+
+  def delete *ids
+    copy = self.dup
+    [ids].flatten.each do |id|
+      copy.ordered.delete id if id.class == Integer
+      copy.named.delete id   if id.class == Symbol
+    end
+    return copy
+  end
+end

data/app/lib/quick_each.rb

@@ -0,0 +1,61 @@
+#
+# quickeach
+#
+
+class QuickEach
+  def initialize enumerable
+    @enumerable = enumerable
+  end
+  def method_missing method, *args, &block
+    @enumerable.collect do |element|
+      element.send method, *args, &block
+    end
+  end
+end
+
+class Array
+  # copy method
+  define_method(
+    :_original_each,
+    instance_method(:each)
+  )
+
+  def each &block
+    unless block_given?
+      return QuickEach.new self
+    else
+      _original_each &block
+    end
+  end
+end
+
+#
+# quickselect
+#
+
+class QuickSelect
+  def initialize enumerable
+    @enumerable = enumerable
+  end
+  def method_missing method, *args, &block
+    @enumerable.select do |element|
+      element.send(method, *args, &block) == true
+    end
+  end
+end
+
+class Array
+  # copy method
+  define_method(
+    :_original_select,
+    instance_method(:select)
+  )
+
+  def select &block
+    unless block_given?
+      return QuickSelect.new self
+    else
+      _original_select &block
+    end
+  end
+end

data/app/node/file.rb

@@ -0,0 +1,16 @@
+class Node::File
+  def initialize path:, filesystem:
+    @path       = path
+    @filesystem = filesystem
+  end
+
+  attr_writer :content, :mode
+
+  def content
+    @content ||= @filesystem.download @path
+  end
+
+  def mode
+    @mode ||= @filesystem.mode @path
+  end
+end

data/app/node/filesystem.rb

@@ -0,0 +1,22 @@
+class Node::Filesystem
+  def initialize node, overlays: false
+    @node = node
+    @underlying = overlays
+    @files = {}
+  end
+
+  def [] path
+    if @underlying
+      @files[path] || @underlying[path]
+    else
+      @files[path] ||= Node::File.new path: path, filesystem: self
+    end
+  end
+
+  def download path
+    log "DOWNLOADING #{@node.name}: '#{path}'"
+    response = @node.remote.execute("cat '#{path}'")
+    response = "" if response.exitstatus != 0
+    response
+  end
+end

data/app/node/job.rb

@@ -0,0 +1,16 @@
+# contains parameters send to capabilities
+# used to read configuration via "?"-suffix methods
+
+class Node::Job
+  attr_reader :capability, :params, :node
+
+  def initialize node, capability, params
+    @node = node
+    @capability = capability
+    @params = params
+  end
+
+  def to_s
+    "#{@capability} #{@params}"
+  end
+end

data/app/node/node.rb

@@ -0,0 +1,36 @@
+class Node
+  attr_reader   :jobs, :definitions, :files, :name, :remote, :rbcm, :sandbox
+  attr_accessor :actions, :memberships, :triggered
+
+  def initialize rbcm, name
+    @rbcm = rbcm
+    @name = name
+    @definitions = []
+    @sandbox = Node::Sandbox.new self
+    @remote = Node::Remote.new self
+    @files = Node::Filesystem.new self, overlays: @remote.files
+    @actions = ActionList.new
+    @memberships = []
+    @jobs = []
+    @blocked_jobs = []
+    @triggered = [:file]
+  end
+
+  def << definition
+    @definitions << definition
+  end
+
+  def parse
+    @sandbox.evaluate definitions.flatten.compact
+  end
+
+  def capabilities
+    jobs.each.capability.uniq
+  end
+
+  def additions
+    @rbcm.group_additions.select{ |group, additions|
+      memberships.include? group
+    }.values.flatten(1)
+  end
+end

data/app/node/remote.rb

@@ -0,0 +1,16 @@
+class Node::Remote
+  attr_reader :files
+
+  def initialize node
+    @host = node.name
+    @files = Node::Filesystem.new node
+  end
+
+  def execute action
+    @session ||= Net::SSH.start @host, 'root'
+    @session.exec! action
+  end
+end
+
+# @session = Net::SSH.start 'test.ckn.li', 'root'
+# @session.exec!("ls").class

data/app/node/sandbox.rb

@@ -0,0 +1,205 @@
+# runs a definition and catches jobs
+# accepts definition-Proc and provides definition-Proc and job list
+
+class Node::Sandbox
+  attr_reader :content, :jobs
+
+  def initialize node
+    @node = node
+    @name = node.name
+    @dependency_cache = []
+    @cache = {
+      chain: [@node.name], trigger: [], triggered_by: [], check: [],
+      source: [], tag: []
+    }
+    # define in instance, otherwise method-binding will be wrong (to class)
+    @@capabilities = @node.rbcm.project.capabilities.each.name
+    @node.rbcm.project.capabilities.each do |capability|
+      add_capability capability
+    end
+  end
+
+  def evaluate definitions
+    [definitions].flatten.each do |definition|
+      __cache chain: definition.origin do
+        instance_eval &definition.content
+      end
+    end
+  end
+
+  def tag name, &block
+    __cache tag: name, chain: "tag:#{name}" do
+      instance_eval &block
+    end
+  end
+
+  def trigger name, &block
+    __cache trigger: name, chain: "trigger:#{name}" do
+      instance_eval &block
+    end
+  end
+
+  def triggered_by name, &block
+    __cache triggered_by: name, chain: "triggered_by:#{name}" do
+      instance_eval &block
+    end
+  end
+
+  def group name, &block
+    if block_given? # expand group
+      @node.rbcm.group_additions[name] << block
+    else # include group
+      raise "undefined group #{name}" unless @node.rbcm.groups[name]
+      @node.memberships << name
+      __cache chain: "group:#{name}" do
+        @node.rbcm.groups[name].each do |definition|
+          instance_eval &definition.content
+        end
+      end
+    end
+  end
+
+  def dont *params
+    puts "dont #{params}"
+  end
+
+  def needs *capabilities
+    @dependency_cache += [capabilities].flatten(1)
+  end
+
+  def check line, &block
+    __cache check: line do
+      instance_eval &block
+    end
+  end
+
+  def run action, check: nil, tags: nil, trigger: nil, triggered_by: nil
+    @node.actions << Action::Command.new(
+      line: action,
+      check: check,
+      chain: @cache[:chain].dup.flatten(1),
+      dependencies: @dependency_cache.dup,
+      tags: [tags] + @cache[:tag].dup,
+      trigger: [@cache[:trigger].dup, trigger].flatten(1),
+      triggered_by: [triggered_by, @cache[:triggered_by].dup].flatten(1),
+      job: @node.jobs.last,
+      source: @cache[:source].dup.flatten, # information from other nodes
+    )
+  end
+
+  def file path, trigger: nil, **named
+     raise "RBCM: invalid file paramteres '#{named}'" if (
+       named.keys - [:exists, :includes_line, :after, :mode, :content,
+         :template, :context, :tags]
+     ).any?
+     @node.actions << Action::File.new(
+       path: path,
+       params: Params.new([path], named),
+       chain: [@cache[:chain].dup].flatten(1),
+       tags: [named[:tags]] + @cache[:tag].dup,
+       trigger: [@cache[:trigger].dup, trigger].flatten(1),
+       triggered_by: @cache[:triggered_by].dup,
+       job: @node.jobs.last,
+       source: @cache[:source].dup.flatten, # information from other nodes
+     )
+  end
+
+  # handle getter method calls
+  def method_missing name, *named, **ordered, &block
+    #log "method #{name} missing on #{@name}"
+    capability_name = name[0..-2].to_sym
+    params = Params.new named, ordered
+    if not @@capabilities.include? capability_name
+      super
+    elsif name =~ /\!$/
+      return # never call cap! diectly
+    elsif name =~ /\?$/
+      __search capability_name, params, &block
+    end
+  end
+
+  def __search capability_name, params, &block
+    if params[:nodes] == :all # scope
+      jobs = @node.rbcm.jobs
+    else
+      jobs = @node.jobs
+    end
+    jobs = jobs.select{|job| job.capability == capability_name}
+    if params.delete(:nodes).empty?
+      # return ordered prarams
+      r = jobs.collect{|job| job.params}
+    elsif params[0].class == Symbol
+      # return values of a named param
+      r = jobs.find_all{ |job|
+        job.params.named.include? params.first if job.params.named.any?
+      }.collect{ |job|
+        job.params.named
+      }.collect{ |named_params|
+        named_params[params.first]
+      }
+    elsif params.named.any?
+      if params[:with]
+        # return values of a named param
+        r = jobs.find_all{ |job|
+          job.params.named.keys.include? params[:with] and job.params.named.any?
+        }.collect{ |job|
+          params = job.params
+          params[:source] = job.node.name
+          params
+        }
+      end
+    end
+    return r.collect &block if block_given? # no-each-syntax
+    return r
+  end
+
+  def __cache trigger: nil, triggered_by: nil, params: nil, check: nil,
+      chain: [], source: nil, reset: nil, tag: nil
+    @cache[:source].append []             if chain
+    @cache[:source].last  << source       if source
+    @cache[:chain]        << chain        if chain
+    @cache[:tag]          << tag          if tag
+    @cache[:trigger]      << trigger      if trigger
+    @cache[:triggered_by] << triggered_by if triggered_by
+    @cache[:check]        << check        if check
+    yield if block_given?
+    @cache[:source].pop                   if chain
+    @cache[:chain].pop                    if chain
+    @cache[:tag].pop                      if tag
+    @cache[:trigger].pop                  if trigger
+    @cache[:triggered_by].pop             if triggered_by
+    @cache[:check].pop                    if check
+    @cache[reset]         =  []           if reset
+  end
+
+  def add_capability capability
+    @@capabilities << capability.name unless capability.name[-1] == "!"
+    # define capability method
+    define_singleton_method :"__#{capability.name}", &capability.content.bind(self)
+    # define wrapper method
+    if capability.type == :regular
+      define_singleton_method capability.name do |*ordered, **named|
+        params = Params.new ordered, named
+        @node.jobs.append Node::Job.new @node, capability.name, params
+        @node.triggered.append capability.name
+        __cache trigger: params[:trigger],
+              triggered_by: params[:triggered_by],
+              chain: capability.name do
+          send "__#{__method__}", *params.delete(:trigger, :triggered_by).sendable
+        end
+        @dependency_cache = [:file]
+      end
+    else # capability.type == :final
+      define_singleton_method capability.name do
+        __cache chain: __method__ do
+          send "__#{__method__}"
+        end
+        @dependency_cache = [:file]
+      end
+    end
+  end
+
+  def self.capabilities
+    @@capabilities.uniq
+  end
+end

data/app/node/template.rb

@@ -0,0 +1,49 @@
+class Node::Template
+  @@engines = [:erb, :mustache]
+
+  def initialize name:, capability: nil, context: {}
+    @name = name
+    @capability = capability
+    @context = context
+  end
+
+  def render
+    content = File.read path
+    layers.each do |layer|
+      if layer == :mustache
+        require "mustache"
+        content = Mustache.render(content, **@context)
+      elsif layer == :erb
+        # https://zaiste.net/rendering_erb_template_with_bindings_from_hash/
+        require "ostruct"; require "erb"
+        content = ERB.new(content).result(
+          OpenStruct.new(@context).instance_eval{binding}
+        )
+      end
+    end
+    return content
+  end
+
+  private
+
+  def path
+    @path ||= Dir["#{@@project_path}/#{"capabilities/#{@capability.to_s.gsub("!","")}" if @capability}/#{@name}*"].first
+  end
+
+  def filename
+    File.basename(path)
+  end
+
+  def layers
+    @layers = []
+    filename.split(".").reverse.each.to_sym.each do |layer|
+      break unless @@engines.include? layer
+      @layers << layer
+    end
+    return @layers
+  end
+
+  def self.project_path= path
+    @@project_path = path
+  end
+end

data/app/project/capability.rb

@@ -0,0 +1,16 @@
+# holds a capability in form of an unbound method, extracted from
+# Project::Sandbox module
+
+class Project::Capability
+  def initialize name:, content:
+    @name = name
+    @content = content
+    @type = type
+  end
+
+  attr_reader :name, :content
+
+  def type
+    @name[-1] == "!" ? :final : :regular
+  end
+end

data/app/project/definition.rb

@@ -0,0 +1,13 @@
+# holds a definition on form of a proc to be executed in a nodes sandbox
+
+class Project::Definition
+  def initialize type:, name:, content:
+    @type, @name, @content = type, name, content
+  end
+
+  attr_reader :type, :name, :content
+
+  def origin
+    "#{type}:#{name}"
+  end
+end

data/app/project/file.rb

@@ -0,0 +1,42 @@
+# extracts capabilities and definitions from project files
+
+class Project::File
+  def initialize project_file_path
+    @path = project_file_path
+    @definitions = []
+    @capabilities = []
+    file = File.read project_file_path
+    method_names_cache = methods(false)
+    instance_eval file
+    sandbox = Project::Sandbox.dup
+    sandbox.module_eval(file)
+    sandbox.instance_methods.each do |name|
+      @capabilities.append Project::Capability.new(
+        name:    name,
+        content: sandbox.instance_method(name)
+      )
+    end
+  end
+
+  attr_reader :capabilities, :definitions, :path
+
+  private
+
+  def group name=nil
+    @definitions.append Project::Definition.new(
+      type:    :group,
+      name:    name,
+      content: Proc.new
+    )
+  end
+
+  def node names=nil
+    [names].flatten(1).each do |name|
+      @definitions.append Project::Definition.new(
+        type:    name.class == Regexp ? :pattern : :node,
+        name:    name,
+        content: Proc.new
+      )
+    end
+  end
+end

data/app/project/project.rb

@@ -0,0 +1,21 @@
+class Project
+  def initialize path
+    @path = path
+    @files = Dir["#{path}/**/*.rb"].collect{ |project_file_path|
+      Project::File.new project_file_path
+    }
+  end
+
+  attr_reader :path, :files
+
+  def capabilities
+    @files.each.capabilities.flatten(1).compact
+  end
+
+  def definitions type=nil
+    with @files.each.definitions.flatten(1) do
+      return select{|definition| definition.type == type} if type
+      return self
+    end
+  end
+end

data/app/project/sandbox.rb

@@ -0,0 +1,5 @@
+module Project::Sandbox
+  def self.method_missing *params, &block
+    # do nothing
+  end
+end

data/app/rbcm.rb

@@ -0,0 +1,69 @@
+require "net/ssh"
+require "net/scp"
+require "fileutils"
+require "shellwords"
+require "diffy"
+require "optparse"
+require "parallel"
+require "yaml"
+
+require "pry"
+
+APPDIR = File.expand_path File.dirname(__FILE__)
+[ "action/action", "action/command", "action/file", "action/list",
+  "lib/array_hash", "lib/lib", "node/node", "node/file", "node/job",
+  "node/filesystem", "node/remote", "node/sandbox", "node/template",
+  "lib/options", "lib/quick_each",
+  "lib/params", "project/project", "project/definition", "project/file",
+  "project/capability", "project/sandbox", "cli"
+].each{|requirement| require "#{APPDIR}/#{requirement}.rb"}
+
+class RBCM
+  def initialize project_path
+    # initialize project
+    @project = Project.new project_path
+    # create nodes
+    @group_additions = ArrayHash.new
+    @nodes = {}
+    @project.definitions(:node).each do |node_definition|
+      @nodes[node_definition.name] ||= Node.new self, node_definition.name
+      @nodes[node_definition.name] << node_definition
+      # apply pattern definitions to node
+      @nodes[node_definition.name] << @project.definitions(:pattern).collect do |pattern_definition|
+         pattern_definition if node_definition.name =~ /#{pattern_definition.name}/
+      end
+    end
+    # create groups
+    @groups = ArrayHash.new
+    @project.definitions(:group).each do |group_definition|
+      @groups[group_definition.name] << group_definition
+    end
+    # else
+    # tell project path to template class
+    Node::Template.project_path = @project.path
+  end
+
+  attr_reader   :nodes, :groups, :project, :actions
+  attr_accessor :group_additions
+
+  def actions
+    ActionList.new nodes.values.each.actions.flatten(1)
+  end
+
+  def jobs
+    nodes.values.each.jobs.flatten(1)
+  end
+
+  def parse
+    log "parsing nodes"
+    nodes.values.each.parse
+    log "parsing additions"
+    nodes.values.each do |node|
+      node.sandbox.evaluate node.additions
+    end
+    log "parsing 'cap!'"
+    nodes.values.each do |node|
+      node.capabilities.each{|capability| node.sandbox.send "#{capability}!"}
+    end
+  end
+end

data/bin/rbcm

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rbcm'
+
+CLI.new ARGV

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: rbcm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Martin Wiegand
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+description: manage your servers via simple config-files
+email: martin@wiegand.tel
+executables:
+- rbcm
+extensions: []
+extra_rdoc_files: []
+files:
+- app/action/action.rb
+- app/action/command.rb
+- app/action/file.rb
+- app/action/list.rb
+- app/cli.rb
+- app/lib/array_hash.rb
+- app/lib/lib.rb
+- app/lib/options.rb
+- app/lib/params.rb
+- app/lib/quick_each.rb
+- app/node/file.rb
+- app/node/filesystem.rb
+- app/node/job.rb
+- app/node/node.rb
+- app/node/remote.rb
+- app/node/sandbox.rb
+- app/node/template.rb
+- app/project/capability.rb
+- app/project/definition.rb
+- app/project/file.rb
+- app/project/project.rb
+- app/project/sandbox.rb
+- app/rbcm.rb
+- bin/rbcm
+homepage: https://github.com/CroneKorkN/rbcm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- app/
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Ruby Config Management
+test_files: []