cult 0.1.1.pre → 0.1.2.pre

data/lib/cult/named_array.rb

@@ -73,27 +73,36 @@ module Cult
     private :extract_regexp_options
 
 
-    # Returns all keys that match if method == :select, the first if
-    # method == :find
-    def all(key, method = :select)
-      key = case key
-        when Integer
-          # Fallback to default behavior
-          return super
+    # Most of the named-array predicates are meant to be useful for user input
+    # or an interactive session.  We give special behavior to certain strings
+    # the user might enter to convert them to a regexp, etc.
+    def expand_predicate(predicate)
+      case predicate
         when String
-          key[0] == '/' ? build_regexp_from_string(key) : key
+          predicate[0] == '/' ? build_regexp_from_string(predicate) : predicate
         when Regexp, Proc, Range
-          key
-        when Symbol
-          key.to_s
+          predicate
+        when Symbol, Integer
+          ->(v) { predicate.to_s == v.to_s }
         when NilClass
-          return nil
+          nil
         else
-          fail KeyError, "#{key} did not resolve to an object"
+          fail KeyError, "Invalid predicate: #{predicate.inspect}"
       end
+    end
+    private :expand_predicate
+
+
+    # Returns all keys that match if method == :select, the first if
+    # method == :find
+    def all(key, method = :select)
+      return super if key.is_a?(Integer)
+      return nil if key.nil?
+
+      predicate = expand_predicate(key)
 
       send(method) do |v|
-        key === v.named_array_identifier
+        predicate === v.named_array_identifier
       end
     end
 
@@ -125,5 +134,44 @@ module Cult
     def values
       self
     end
+
+    # Takes a predicate in the form of:
+    #   key: value
+    # And returns all items that both respond_to?(key), and
+    # predicate === the result of sending key.
+    #
+    # Instances can override what predicates mean by defining "names_for_*" to
+    # override what is tested.
+    #
+    # For example, if you have an Object that contains a list of "Foos", but
+    # you want to select them by name, you'd do something like:
+    #
+    # class Object
+    #   attr_reader :foos   # Instances of Foo class
+    #
+    #   def names_for_foos  # Now we can select by name
+    #     foos.map(&:name)
+    #   end
+    # end
+    #
+    def with(**kw)
+      fail ArgumentError, "with requires exactly one predicate" if kw.size != 1
+
+      method, predicate = kw.first
+      predicate = expand_predicate(predicate)
+
+      select do |candidate|
+        method = ["names_for_#{method}", method].find do |m|
+          candidate.respond_to?(m)
+        end
+
+        if method
+          result = Array(candidate.send(method))
+          result.any? {|r| predicate === r }
+        end
+      end
+    end
+
+    alias_method :where, :with
   end
 end

data/lib/cult/node.rb

@@ -1,5 +1,7 @@
-require 'cult/role'
 require 'fileutils'
+require 'shellwords'
+
+require 'cult/role'
 
 module Cult
   class Node < Role
@@ -10,16 +12,17 @@ module Cult
       FileUtils.mkdir_p(node.path)
       File.write(project.dump_name(node.node_path),
                  project.dump_object(data))
+
+      node.generate_ssh_keys!
+
       return by_name(project, data[:name])
     end
 
-    # These are convenience methods for templates, etc.
-    # delegate them to the definition.
-    %i(user host ipv4_public ipv4_private ipv6_public ipv6_private).each do |m|
-      define_method(m) do
-        definition[m.to_s]
-      end
-    end
+    delegate_to_definition :host
+    delegate_to_definition :ipv4_public
+    delegate_to_definition :ipv4_private
+    delegate_to_definition :ipv6_public
+    delegate_to_definition :ipv6_private
 
 
     def self.path(project)
@@ -56,7 +59,39 @@ module Cult
       definition.direct('roles') || super
     end
 
+    def provider
+      project.providers[definition['provider']]
+    end
+
+    def names_for_provider
+      [ provider&.name ]
+    end
 
     alias_method :roles, :parent_roles
+
+
+    def ssh_public_key_file
+      File.join(path, 'ssh.pub')
+    end
+
+    def ssh_private_key_file
+      File.join(path, 'ssh.key')
+    end
+
+    def generate_ssh_keys!
+      esc = ->(s) { Shellwords.escape(s) }
+      tmp_public = ssh_private_key_file + '.pub'
+
+      # Wanted to use -o and -t ecdsa, but Net::SSH still has some
+      # issues with ECDSA, and only 4.0 beta supports -o style new keys
+      cmd = "ssh-keygen -N '' -t rsa -b 4096 -C #{esc.(name)} " +
+            "-f #{esc.(ssh_private_key_file)} && " +
+            "mv #{esc.(tmp_public)} #{esc.(ssh_public_key_file)}"
+      %x(#{cmd})
+      unless $?.success?
+        fail "Couldn't generate SSH key, command: #{cmd}"
+      end
+    end
+
   end
 end

data/lib/cult/project.rb

@@ -3,9 +3,6 @@ require 'shellwords'
 require 'json'
 require 'yaml'
 
-require 'cult/config'
-require 'cult/role'
-require 'cult/provider'
 
 module Cult
   class Project
@@ -16,11 +13,6 @@ module Cult
 
     def initialize(path)
       @path = path
-
-      if Cult.immutable?
-        self.provider
-        self.freeze
-      end
     end
 
 

data/lib/cult/project_context.rb

@@ -0,0 +1,23 @@
+require 'forwardable'
+
+module Cult
+  class ProjectContext
+    extend Forwardable
+    def_delegators :project, :methods, :respond_to?, :to_s, :inspect
+
+    attr_reader :project
+
+    def initialize(project, **extra)
+      @project = project
+
+      extra.each do |k, v|
+        define_singleton_method(k) { v }
+      end
+    end
+
+    def method_missing(*args)
+      project.send(*args)
+    end
+
+  end
+end

data/lib/cult/provider.rb

@@ -1,6 +1,3 @@
-require 'cult/named_array'
-require 'cult/definition'
-
 require 'forwardable'
 
 module Cult

data/lib/cult/role.rb

@@ -1,25 +1,24 @@
 require 'tsort'
 
-require 'cult/task'
-require 'cult/artifact'
-require 'cult/config'
-require 'cult/definition'
-require 'cult/named_array'
-
 module Cult
   class Role
+    include SingletonInstances
+
+    def self.delegate_to_definition(method_name, definition_key = nil)
+      definition_key ||= method_name
+      define_method(method_name) do
+        definition[definition_key.to_s]
+      end
+    end
+
+    delegate_to_definition :user
+
     attr_accessor :project
     attr_accessor :path
 
     def initialize(project, path)
       @project = project
       @path = path
-
-      if Cult.immutable?
-        definition
-        parent_roles
-        self.freeze
-      end
     end
 
 
@@ -51,11 +50,7 @@ module Cult
 
 
     def inspect
-      if Cult.immutable?
-        "\#<#{self.class.name} id:#{object_id.to_s(36)} #{name.inspect}>"
-      else
-        "\#<#{self.class.name} #{name.inspect}>"
-      end
+      "\#<#{self.class.name} id:#{object_id.to_s(36)} #{name.inspect}>"
     end
     alias_method :to_s, :inspect
 
@@ -76,6 +71,16 @@ module Cult
     end
 
 
+    def build_tasks
+      tasks.select(&:build_task?)
+    end
+
+
+    def event_tasks
+      tasks.select(&:event_task?)
+    end
+
+
     def artifacts
       Artifact.all_for_role(project, self)
     end
@@ -148,39 +153,6 @@ module Cult
     end
 
 
-    if Cult.immutable?
-      def self.cache_get(cls, *args)
-        @singletons ||= {}
-        key = [cls, *args]
-
-        if (rval = @singletons[key])
-          return rval
-        end
-
-        return nil
-      end
-
-
-      def self.cache_put(obj, *args)
-        @singletons ||= {}
-        key = [obj.class, *args]
-        @singletons[key] = obj
-        obj
-      end
-
-
-      def self.new(*args)
-        if (result = cache_get(self, *args))
-          return result
-        else
-          result = super
-          cache_put(result, *args)
-          return result
-        end
-      end
-    end
-
-
     def self.all(project)
       all_files(project).map do |filename|
         new(project, filename).tap do |new_role|
@@ -209,5 +181,13 @@ module Cult
       ! tree[role].nil?
     end
 
+    def names_for_role(*a)
+      build_order.map(&:name)
+    end
+
+    def names_for_task
+      tasks.map(&:name)
+    end
+
   end
 end

data/lib/cult/singleton_instances.rb

@@ -0,0 +1,43 @@
+module Cult
+  module SingletonInstances
+
+    module ClassMethods
+
+      private
+      def singletons
+        @singletons ||= {}
+      end
+
+
+      def cache_get(cls, *args)
+        singletons[[cls, *args]]
+      end
+
+
+      def cache_put(obj, *args)
+        singletons[[obj.class, *args]] = obj
+      end
+
+
+      public
+      def new(*args)
+        return super unless Cult.singletons?
+
+        if (result = cache_get(self, *args))
+          return result
+        end
+
+        super.tap do |result|
+          cache_put(result, *args)
+        end
+      end
+
+    end
+
+    def self.included(cls)
+      class << cls
+        prepend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/cult/skel.rb

@@ -1,5 +1,4 @@
 require 'fileutils'
-require 'cult/template'
 
 module Cult
   class Skel
@@ -51,7 +50,8 @@ module Cult
 
       dst, data = case src
         when /\.erb\z/
-          [ dst.sub(/\.erb\z/, ''), template.process(File.read(src))]
+          [ dst.sub(/\.erb\z/, ''),
+            template.process(File.read(src), filename: src)]
         else
           [ dst, File.read(src) ]
         end

data/lib/cult/task.rb

@@ -1,17 +1,17 @@
-require 'cult/transferable'
-require 'cult/named_array'
-
 module Cult
   class Task
     include Transferable
+    include SingletonInstances
 
     attr_reader :path
     attr_reader :role
     attr_reader :serial
     attr_reader :name
+    attr_reader :type
 
-    LEADING_ZEROS = 5
+    LEADING_ZEROS = 3
     BASENAME_RE = /\A(\d{#{LEADING_ZEROS},})-([\w-]+)(\..+)?\z/i
+    EVENTS = [:sync]
 
 
     def initialize(role, path)
@@ -19,11 +19,20 @@ module Cult
       @path = path
       @basename = File.basename(path)
 
+      unless self.class.valid_task_name?(@basename)
+        fail ArgumentError, "invalid task name: #{path}"
+      end
+
       if (m = @basename.match(BASENAME_RE))
+        @type = :build
         @serial = m[1].to_i
         @name = m[2]
+      elsif EVENTS.map(&:to_s).include?(@basename)
+        @type = :event
+        @serial = nil
+        @name = @basename
       else
-        fail ArgumentError, "invalid task name: #{path}"
+        fail "WTF"
       end
     end
 
@@ -39,8 +48,18 @@ module Cult
     end
 
 
+    def build_task?
+      type == :build
+    end
+
+
+    def event_task?
+      type != :build
+    end
+
+
     def inspect
-      "\#<#{self.class.name} role:#{role&.name.inspect} " +
+      "\#<#{self.class.name} type: #{type} role:#{role&.name.inspect} " +
           "serial:#{serial} name:#{name.inspect}>"
     end
     alias_method :to_s, :inspect
@@ -50,15 +69,18 @@ module Cult
       super | 0100
     end
 
+    def self.valid_task_name?(basename)
+      EVENTS.map(&:to_s).include?(basename) || basename.match(BASENAME_RE)
+    end
+
 
     def self.all_for_role(project, role)
       Dir.glob(File.join(role.path, "tasks", "*")).map do |filename|
-        next unless File.basename(filename).match(BASENAME_RE)
+        next unless valid_task_name?(File.basename(filename))
         new(role, filename).tap do |new_task|
           yield new_task if block_given?
         end
       end.compact.to_named_array
     end
-
   end
 end

data/lib/cult/template.rb

@@ -1,91 +1,39 @@
 require 'erb'
 require 'json'
+require 'cult/user_refinements'
 
 module Cult
   class Template
+    class Context < ProjectContext
+      using ::Cult::UserRefinements
 
-    # Alright!  We found a use for refinements!
-    module Refinements
-      module Util
-        module_function
-        def squote(s)
-          "'" + s.gsub("'", "\\\\\'") + "'"
-        end
-
-
-        def quote(s)
-          s.to_json
-        end
-
-
-        def slash(s)
-          Shellwords.escape(s)
-        end
-      end
-
-      refine String do
-        def quote
-          Util.quote(self)
-        end
-        alias_method :q, :quote
-
-
-        def squote
-          Util.squote(self)
-        end
-        alias_method :sq, :squote
-
-
-        def slash
-          Util.slash(self)
-        end
-      end
-
-      refine Array do
-        def quote(sep = ' ')
-          map {|v| Util.quote(v) }.join(sep)
-        end
-        alias_method :q, :quote
-
-
-        def squote(sep = ' ')
-          map {|v| Util.squote(v) }.join(sep)
-        end
-        alias_method :sq, :squote
-
-
-        def slash
-          map {|v| Util.slash(v) }.join(' ')
-        end
-      end
-    end
-
-    class Context
-      using Refinements
-
-      def initialize(pwd: nil, **kw)
+      def initialize(project, pwd: nil, **kw)
         @pwd = pwd
-        kw.each do |k,v|
-          define_singleton_method(k) { v }
-        end
+        super(project, **kw)
       end
 
-
-      def _process(template)
+      def _process(template, filename: nil)
         Dir.chdir(@pwd || Dir.pwd) do
-          ::ERB.new(template).result(binding)
+          erb = ::ERB.new(template)
+          erb.filename = filename
+          erb.result(binding)
         end
       end
+
+      def binding
+        super
+      end
     end
 
+    attr_reader :context
 
-    def initialize(pwd: nil, **kw)
-      @context = Context.new(pwd: pwd, **kw)
+    def initialize(project:, pwd: nil, **kw)
+      @context = Context.new(project, pwd: pwd, **kw)
     end
 
 
-    def process(text)
-      @context._process(text)
+    def process(text, filename: nil)
+      context._process(text, filename: filename)
     end
 
   end

data/lib/cult/transaction.rb

@@ -0,0 +1,44 @@
+module Cult
+  module Transaction
+    class Log
+      attr_reader :steps
+      def initialize
+        @steps = []
+        yield self if block_given?
+      end
+
+      def unwind
+        begin
+          while (step = steps.pop)
+            step.call
+          end
+        rescue Exception => e
+          puts "Error raised while rolling back: #{e.inspect}\n#{e.backtrace}"
+          retry
+        end
+      end
+
+      def protect(&block)
+        begin
+          yield
+        rescue Exception
+          $stderr.puts "Rolling back actions"
+          unwind
+          raise
+        end
+      end
+
+      def rollback(&block)
+        steps.push(block)
+      end
+    end
+
+    def transaction
+      Log.new do |list|
+        list.protect do
+          yield list
+        end
+      end
+    end
+  end
+end

data/lib/cult/transferable.rb

@@ -1,8 +1,5 @@
-require 'cult/template'
-
 module Cult
   module Transferable
-
     module ClassMethods
       def collection_name
         name.split('::')[-1].downcase + 's'
@@ -39,8 +36,8 @@ module Cult
       if binary?
         File.read(path)
       else
-        erb = Template.new(pwd: pwd, project: project, role: role, node: node)
-        erb.process File.read(path)
+        erb = Template.new(project: project, pwd: pwd, role: role, node: node)
+        erb.process(File.read(path), filename: path)
       end
     end