cult 0.1.1.pre

data/lib/cult/node.rb

@@ -0,0 +1,62 @@
+require 'cult/role'
+require 'fileutils'
+
+module Cult
+  class Node < Role
+    def self.from_data!(project, data)
+      node = by_name(project, data[:name])
+      raise Errno::EEXIST if node.exist?
+
+      FileUtils.mkdir_p(node.path)
+      File.write(project.dump_name(node.node_path),
+                 project.dump_object(data))
+      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
+
+
+    def self.path(project)
+      File.join(project.path, 'nodes')
+    end
+
+
+    def node_path
+      File.join(path, 'node')
+    end
+
+
+    def state_path
+      File.join(path, 'state')
+    end
+
+
+    def definition_path
+      [ node_path, state_path ]
+    end
+
+
+    def definition_parameters
+      super.merge(node: self)
+    end
+
+
+    def extra_file
+      File.join(path, 'extra')
+    end
+
+
+    def includes
+      definition.direct('roles') || super
+    end
+
+
+    alias_method :roles, :parent_roles
+  end
+end

data/lib/cult/project.rb

@@ -0,0 +1,169 @@
+require 'securerandom'
+require 'shellwords'
+require 'json'
+require 'yaml'
+
+require 'cult/config'
+require 'cult/role'
+require 'cult/provider'
+
+module Cult
+  class Project
+    CULT_RC = '.cultrc'
+
+    attr_reader :path
+    attr_accessor :cult_version
+
+    def initialize(path)
+      @path = path
+
+      if Cult.immutable?
+        self.provider
+        self.freeze
+      end
+    end
+
+
+    def name
+      File.basename(path)
+    end
+
+
+    def cultrc
+      location_of(CULT_RC)
+    end
+
+
+    def execute_cultrc
+      load(cultrc)
+    end
+
+
+    def inspect
+      "\#<#{self.class.name} name=#{name.inspect} path=#{path.inspect}>"
+    end
+    alias_method :to_s, :inspect
+
+
+    def location_of(file)
+      File.join(path, file)
+    end
+
+
+    def relative_path(obj_path)
+      prefix = "#{path}/"
+
+      if obj_path.start_with?(prefix)
+        return obj_path[prefix.length .. -1]
+      end
+
+      fail ArgumentError, "#{path} isn't in the project"
+    end
+
+
+    def remote_path
+      "cult"
+    end
+
+
+    def constructed?
+      File.exist?(cultrc)
+    end
+    alias_method :exist?, :constructed?
+
+    def nodes
+      @nodes ||= begin
+        Node.all(self)
+      end
+    end
+
+
+    def roles
+      @roles ||= begin
+        Role.all(self)
+      end
+    end
+
+
+    def providers
+      @providers ||= begin
+        Cult::Provider.all(self)
+      end
+    end
+
+    attr_writer :default_provider
+    def default_provider
+      @default_provider ||= providers[0]
+    end
+
+
+    def drivers
+      @drivers ||= begin
+        Cult::Drivers.all
+      end
+    end
+
+
+    def self.locate(path)
+      path = File.expand_path(path)
+      loop do
+        return nil if path == '/'
+
+        unless File.directory?(path)
+          path = File.dirname(path)
+        end
+
+        candidate = File.join(path, CULT_RC)
+        return new(path) if File.exist?(candidate)
+        path = File.dirname(path)
+      end
+    end
+
+
+    def self.from_cwd
+      locate Dir.getwd
+    end
+
+    attr_accessor :git_integration
+    alias_method :git?, :git_integration
+
+    def git_branch
+      res = %x(git -C #{Shellwords.escape(path)} branch --no-color)
+      if res && (m = res.match(/^\* (.*)/))
+        return m[1].chomp
+      end
+    end
+
+
+    def dump_yaml?
+      !! (ENV['CULT_DUMP'] || '').match(/^yaml$/i)
+    end
+
+
+    def dump_object(obj)
+      dump_yaml? ? YAML.dump(obj) : JSON.pretty_generate(obj)
+    end
+
+
+    def dump_name(basename)
+      basename + (dump_yaml? ? '.yml' : '.json')
+    end
+
+
+    def env
+      ENV['CULT_ENV'] || begin
+        if git_branch&.match(/\bdev(el(opment)?)?\b/)
+          'development'
+        else
+          'production'
+        end
+      end
+    end
+
+
+    def development?
+      env == 'development'
+    end
+
+  end
+end

data/lib/cult/provider.rb

@@ -0,0 +1,134 @@
+require 'cult/named_array'
+require 'cult/definition'
+
+require 'forwardable'
+
+module Cult
+  class Provider
+    extend Forwardable
+
+    def_delegators :driver, :sizes, :images, :zones, :provision!, :destroy!
+
+    attr_reader :project
+    attr_reader :path
+
+
+    def initialize(project, path)
+      @project = project
+      @path = path
+    end
+
+
+    def name
+      File.basename(path)
+    end
+
+
+    def inspect
+      prelude = "#{self.class.name} \"#{name}\""
+      driver_name = driver.class.driver_name
+      driver_string = (driver_name == name) ? '' : " driver=\"#{driver_name}\""
+      "\#<#{prelude}#{driver_string}>"
+    end
+
+
+    def driver
+      @driver ||= begin
+        cls = project.drivers[definition['driver']]
+        cls.new(api_key: definition['api_key'])
+      end
+    end
+
+
+    def definition
+      @definition ||= Definition.new(self)
+    end
+
+
+    def definition_path
+      [File.join(path, "provider"), File.join(path, "defaults")]
+    end
+
+
+    def definition_parameters
+      { project: self.project }
+    end
+
+    def definition_parents
+      []
+    end
+
+
+    # Chooses the smallest size setup with Ubuntu > Debian > Redhat,
+    # and a random zone.
+    def self.generate_defaults(definition)
+      definition = JSON.parse(definition.to_json)
+      text_to_mb = ->(text) {
+        multipliers = {
+          mb: 1 ** 1,
+          gb: 1 ** 2,
+          tb: 1 ** 3,
+          pb: 1 ** 4
+        }
+        if (m = text.match(/(\d+)([mgtp]b)/))
+          base = m[1].to_i
+          mul = multipliers.fetch(m[2].to_sym)
+          base * mul
+        else
+          nil
+        end
+      }
+
+      conf = definition['configurations']
+
+      # select the smallest size
+      size = conf['sizes'].map do |size|
+        if mb = text_to_mb.(size)
+          [mb, size]
+        else
+          nil
+        end
+      end.compact.sort_by(&:first).last.last
+
+      image = conf['images'].sort_by do |i|
+        case i
+          when /ubuntu-(\d+)-(\d+)/;
+            10000 + ($1.to_i * 100) + ($2.to_i * 10)
+          when /debian-(\d+)/
+            9000 + ($1.to_i * 100)
+          when /(redhat|centos|fedora)-(\d+)/
+            8000 + ($2.to_i * 100)
+          else
+            1
+        end
+      end.last
+
+      zone = conf['zones'].sample
+
+      {
+        default_size:  size,
+        default_zone:  zone,
+        default_image: image
+      }
+    end
+
+
+    def self.path(project)
+      project.location_of("providers")
+    end
+
+
+    def self.all_files(project)
+      Dir.glob(File.join(path(project), "*")).select do |file|
+        Dir.exist?(file)
+      end
+    end
+
+
+    def self.all(project)
+      all_files(project).map do |filename|
+        new(project, filename)
+      end.to_named_array
+    end
+  end
+end

data/lib/cult/role.rb

@@ -0,0 +1,213 @@
+require 'tsort'
+
+require 'cult/task'
+require 'cult/artifact'
+require 'cult/config'
+require 'cult/definition'
+require 'cult/named_array'
+
+module Cult
+  class Role
+    attr_accessor :project
+    attr_accessor :path
+
+    def initialize(project, path)
+      @project = project
+      @path = path
+
+      if Cult.immutable?
+        definition
+        parent_roles
+        self.freeze
+      end
+    end
+
+
+    def exist?
+      Dir.exist?(path)
+    end
+
+
+    def name
+      File.basename(path)
+    end
+
+
+    def collection_name
+      class_name = self.class.name.split('::')[-1]
+      class_name.downcase + 's'
+    end
+
+
+    def remote_path
+      File.join(project.remote_path, collection_name, name)
+    end
+
+
+    def relative_path(obj_path)
+      fail unless obj_path.start_with?(path)
+      obj_path[path.size + 1 .. -1]
+    end
+
+
+    def inspect
+      if Cult.immutable?
+        "\#<#{self.class.name} id:#{object_id.to_s(36)} #{name.inspect}>"
+      else
+        "\#<#{self.class.name} #{name.inspect}>"
+      end
+    end
+    alias_method :to_s, :inspect
+
+
+    def hash
+      [self.class, project, path].hash
+    end
+
+
+    def ==(rhs)
+      [self.class, project, path] == [rhs.class, rhs.project, rhs.path]
+    end
+    alias_method :eql?, :==
+
+
+    def tasks
+      Task.all_for_role(project, self)
+    end
+
+
+    def artifacts
+      Artifact.all_for_role(project, self)
+    end
+    alias_method :files, :artifacts
+
+
+    def definition
+      @definition ||= Definition.new(self)
+    end
+
+
+    def definition_path
+      File.join(path, "role")
+    end
+
+
+    def definition_parameters
+      { project: project, role: self }
+    end
+
+
+    def definition_parents
+      parent_roles
+    end
+
+
+    def includes
+      definition.direct('includes') || ['all']
+    end
+
+
+    def parent_roles
+      Array(includes).map do |name|
+        Role.by_name(project, name)
+      end.to_named_array
+    end
+
+
+    def recursive_parent_roles(seen = [])
+      result = []
+      parent_roles.each do |role|
+        next if seen.include?(role)
+        seen.push(role)
+        result.push(role)
+        result += role.recursive_parent_roles(seen)
+      end
+      result.to_named_array
+    end
+
+
+    def tree
+      ([self] + recursive_parent_roles).to_named_array
+    end
+
+
+    def self.by_name(project, name)
+      new(project, File.join(path(project), name))
+    end
+
+
+    def self.path(project)
+      File.join(project.path, "roles")
+    end
+
+
+    def self.all_files(project)
+      Dir.glob(File.join(path(project), "*")).select do |file|
+        Dir.exist?(file)
+      end
+    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|
+          yield new_role if block_given?
+        end
+      end.to_named_array
+    end
+
+
+    def build_order
+      all_items = [self] + parent_roles
+
+      each_node = ->(&block) {
+        all_items.each(&block)
+      }
+
+      each_child = ->(node, &block) {
+        node.parent_roles.each(&block)
+      }
+
+      TSort.tsort(each_node, each_child).to_named_array
+    end
+
+
+    def has_role?(role)
+      ! tree[role].nil?
+    end
+
+  end
+end

data/lib/cult/skel.rb

@@ -0,0 +1,85 @@
+require 'fileutils'
+require 'cult/template'
+
+module Cult
+  class Skel
+    SKEL_DIR = File.expand_path(File.join(__dir__, '../../skel'))
+
+    attr_reader :project
+
+    def initialize(project)
+      @project = project
+    end
+
+
+    def template
+      @erb ||= Template.new(project: project)
+    end
+
+
+    # Skeleton files are files that are copied over for a new project.
+    # We allow template files to live in the skeleton directory too, but
+    # they're not copied over until needed.
+    def skeleton_files
+      Dir.glob(File.join(SKEL_DIR, "**", "{.*,*}")).reject do |fn|
+        fn.match(/template/i)
+      end
+    end
+
+
+    def template_file(name)
+      File.join(SKEL_DIR, name)
+    end
+
+
+    def copy_template(name, dst)
+      src = template_file(name)
+      dst = project.location_of(dst)
+      process_file(src, dst)
+    end
+
+
+    def process_file(src, dst = nil)
+      dst ||= begin
+        relative = src.sub(%r/\A#{Regexp.escape(SKEL_DIR)}/, '')
+        project.location_of(relative)
+      end
+
+      if File.directory?(src)
+        return
+      end
+
+      dst, data = case src
+        when /\.erb\z/
+          [ dst.sub(/\.erb\z/, ''), template.process(File.read(src))]
+        else
+          [ dst, File.read(src) ]
+        end
+
+      display_name = File.basename(dst) == ".keep" ? File.dirname(dst) : dst
+
+      print "  Creating #{display_name}"
+      if File.exist?(dst)
+        puts " exists, skipped."
+        return
+      end
+
+
+      FileUtils.mkdir_p(File.dirname(dst))
+
+      File.write(dst, data)
+      File.chmod(File.stat(src).mode, dst)
+      puts
+    end
+
+
+    def copy!
+      puts "Creating project from skeleton..."
+      FileUtils.mkdir_p(project.path)
+      skeleton_files.each do |file|
+        process_file(file)
+      end
+      puts
+    end
+  end
+end

data/lib/cult/task.rb

@@ -0,0 +1,64 @@
+require 'cult/transferable'
+require 'cult/named_array'
+
+module Cult
+  class Task
+    include Transferable
+
+    attr_reader :path
+    attr_reader :role
+    attr_reader :serial
+    attr_reader :name
+
+    LEADING_ZEROS = 5
+    BASENAME_RE = /\A(\d{#{LEADING_ZEROS},})-([\w-]+)(\..+)?\z/i
+
+
+    def initialize(role, path)
+      @role = role
+      @path = path
+      @basename = File.basename(path)
+
+      if (m = @basename.match(BASENAME_RE))
+        @serial = m[1].to_i
+        @name = m[2]
+      else
+        fail ArgumentError, "invalid task name: #{path}"
+      end
+    end
+
+
+    def self.from_serial_and_name(role, serial:, name:)
+      basename = sprintf("%0#{LEADING_ZEROS}d-%s", serial, name)
+      new(role, File.join(role.path, collection_name, basename))
+    end
+
+
+    def relative_path
+      File.basename(path)
+    end
+
+
+    def inspect
+      "\#<#{self.class.name} role:#{role&.name.inspect} " +
+          "serial:#{serial} name:#{name.inspect}>"
+    end
+    alias_method :to_s, :inspect
+
+
+    def file_mode
+      super | 0100
+    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)
+        new(role, filename).tap do |new_task|
+          yield new_task if block_given?
+        end
+      end.compact.to_named_array
+    end
+
+  end
+end