amigrind 0.1.1

data/lib/amigrind/cli/repo/init.rb

@@ -0,0 +1,22 @@
+module Amigrind
+  module CLI
+    REPO.add_command(
+      Cri::Command.define do
+        name          'init'
+        description   'initializes new repo'
+
+        run do |_, args, _|
+          path = args.first
+
+          raise "A path is required to initialize a repo." if path.nil?
+
+          path = File.expand_path(path)
+
+          raise "Cannot initialize a repo into an existing path." if Dir.exist?(path)
+
+          Amigrind::Repo.init(path: path)
+        end
+      end
+    )
+  end
+end

data/lib/amigrind/config.rb

@@ -0,0 +1,89 @@
+require 'settingslogic'
+require 'os'
+
+module Amigrind
+  # Config values we care about:
+  # `auto_profile` - boolean; if set
+  class Config < Settingslogic
+    extend Amigrind::Core::Logging::Mixin
+    include Amigrind::Core::Logging::Mixin
+
+    CREDENTIAL_TYPES = [ :default, :iam, :shared ].freeze
+
+    cfg_dir =
+      ENV['AMIGRIND_CONFIG_PATH'] || "#{Dir.home}/.amigrind"
+    cfg_file = "#{cfg_dir}/config.yaml"
+
+    unless Dir.exist?(cfg_dir)
+      info_log "initializing config directory"
+      FileUtils.mkdir_p(cfg_dir)
+      if OS.posix?
+        info_log "chmodding config directory"
+        FileUtils.chmod 'g=-rwx', cfg_dir
+        FileUtils.chmod 'o=-rwx', cfg_dir
+      end
+    end
+    unless File.exist?(cfg_file)
+      info_log "touching config file to create it"
+      FileUtils.touch(cfg_file)
+      if OS.posix?
+        info_log "chmodding config file"
+        FileUtils.chmod 'g=-rwx', cfg_file
+        FileUtils.chmod 'o=-rwx', cfg_file
+      end
+    end
+
+    source cfg_file
+
+    def aws_credentials(environment = nil)
+      # This is a minor disaster and should be refactored, but essentially boils down
+      # to specifying a credentials_type and any related settings. If
+      # `auto_profile_from_environment` is set, any time that an environment is
+      # passed in, `auto_profile_prefix` will be prepended to the environment name
+      # to generate the AWS profile name. This allows one to, for example, have
+      # a 'foocorp_production' profile that will be automatically used when working
+      # with the 'production' environment.
+      aws = Config['aws'] || {}
+
+      credential_type = (aws['credentials_type'] || :default).to_sym
+      auto_profile_from_environment = !!aws['auto_profile_from_environment']
+      auto_profile_prefix = aws['auto_profile_prefix'] || ''
+      profile_name = aws['profile_name']
+
+      debug_log "credentials_type: #{credential_type}"
+
+      raise "setting error: can only use profile_name with credential_type = shared." \
+        if credential_type != :shared && !profile_name.nil?
+
+      raise "setting error: cannot use both profile_name and auto_profile_from_environment." \
+        if !profile_name.nil? && auto_profile_from_environment
+
+      case credential_type
+      when :default
+        debug_log 'Using default credentials.'
+        nil
+      when :shared
+        if auto_profile_from_environment &&
+            profile_name.nil? && !environment.nil?
+          environment = environment.name \
+            if (environment.is_a?(Amigrind::Environments::Environment))
+
+          profile_name = "#{auto_profile_prefix}#{environment}"
+          debug_log "auto_profile_from_environment enabled and environment " \
+                    "passed; setting profile_name to '#{profile_name}'."
+        end
+
+        p = (profile_name || 'default').strip
+
+        debug_log "Using profile '#{p}'."
+        Aws::SharedCredentials.new(profile_name: p)
+      when :iam
+        debug_log 'Using IAM credentials.'
+        Aws::InstanceProfileCredentials.new
+      else
+        raise "invalid credential type '#{credential_type}' " \
+              "(allowed: #{CREDENTIAL_TYPES.join(', ')})"
+      end
+    end
+  end
+end

data/lib/amigrind/environments/channel.rb

@@ -0,0 +1,9 @@
+module Amigrind
+  module Environments
+    class Channel
+      include Virtus.model
+
+      attribute :name, String
+    end
+  end
+end

data/lib/amigrind/environments/environment.rb

@@ -0,0 +1,66 @@
+module Amigrind
+  module Environments
+    class Environment
+      extend Amigrind::Core::Logging::Mixin
+
+      include Virtus.model(constructor: false, mass_assignment: false)
+
+      class AWSConfig
+        include Virtus.model
+
+        attribute :region, String
+        attribute :copy_regions, Array[String]
+        attribute :vpc, String
+        attribute :subnets, Array[String]
+        attribute :ssh_keypair_name, String
+      end
+
+      attribute :name, String
+      attribute :channels, Hash[String => Channel]
+      attribute :aws, AWSConfig
+      attr_reader :properties
+
+      def initialize
+        @aws = AWSConfig.new
+        @channels = []
+        @properties = {}
+      end
+
+      def self.from_yaml(name, yaml_input)
+        yaml = YAML.load(yaml_input).deep_symbolize_keys
+
+        yaml[:amigrind] ||= {}
+        yaml[:aws] ||= {}
+        yaml[:properties] ||= {}
+
+        env = Environment.new
+        env.name = name.to_s.strip.downcase
+
+        env.aws = AWSConfig.new(yaml[:aws])
+
+        env.properties.merge!(yaml[:properties])
+
+        env.channels = (yaml[:amigrind][:channels] || []).map do |k, v|
+          [ k.to_s, Channel.new(v.merge(name: k)) ]
+        end.to_h
+
+        # TODO: use these for validations
+        valid_mappings = {
+          'root' => env,
+          'aws' => env.aws
+        }
+
+        env
+      end
+
+      def self.load_yaml_file(path)
+        raise "'path' must be a String." unless path.is_a?(String)
+        raise "'path' must be a file that exists." unless File.exist?(path)
+        raise "'path' must end in .yml, .yaml, .yml.erb, or .yaml.erb." \
+          unless path.end_with?('.yml', '.yaml', '.yml.erb', '.yaml.erb')
+
+        Environment.from_yaml(File.basename(path, '.*'), Erubis::Eruby.new(File.read(path)).result)
+      end
+    end
+  end
+end

data/lib/amigrind/environments/rb_evaluator.rb

@@ -0,0 +1,7 @@
+module Amigrind
+  module Environments
+    # TODO: implement Ruby environments
+    class RbEvaluator
+    end
+  end
+end

data/lib/amigrind/repo.rb

@@ -0,0 +1,217 @@
+module Amigrind
+  class Repo
+    include Amigrind::Core::Logging::Mixin
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = File.expand_path path
+
+      raise "'path' (#{path}) is not a directory." unless Dir.exist?(path)
+      raise "'path' is not an Amigrind root (lacks .amigrind_root file)." \
+        unless File.exist?(File.join(path, '.amigrind_root'))
+
+      info_log "using Amigrind path: #{path}"
+    end
+
+    def environments_path
+      File.join(path, 'environments')
+    end
+
+    def blueprints_path
+      File.join(path, 'blueprints')
+    end
+
+    # TODO: Ruby DSL environments
+    def environment_names
+      yaml_environments =
+        Dir[File.join(environments_path, '*.yaml')] \
+          .map { |f| File.basename(f, '.yaml').to_s.strip.downcase }
+
+      rb_environments =
+        [].map { |f| File.basename(f, '.rb').to_s.strip.downcase }
+
+      duplicate_environments = yaml_environments & rb_environments
+      duplicate_environments.each do |dup_env_name|
+        warn_log "environment '#{dup_env_name}' found in both YAML and Ruby; skipping."
+      end
+
+      (yaml_environments + rb_environments - duplicate_environments).sort
+    end
+
+    # TODO: cache environments (but make configurable)
+    def environment(name)
+      yaml_path = yaml_path_if_exists(name)
+      rb_path = rb_path_if_exists(name)
+
+      raise "found multiple env files for same env #{name}." if !yaml_path.nil? && !rb_path.nil?
+      raise "TODO: implement Ruby environments." unless rb_path.nil?
+
+      env = Environments::Environment.load_yaml_file(yaml_path) unless yaml_path.nil?
+
+      raise "no env found for '#{name}'." if env.nil?
+
+      IceNine.deep_freeze(env)
+      env
+    end
+
+    def with_environment(environment_name, &block)
+      block.call(environment(environment_name))
+    end
+
+    def blueprint_names
+      Dir[File.join(blueprints_path, "*.rb")].map { |f| File.basename(f, ".rb") }
+    end
+
+    # TODO: cache blueprint/environment tuples (but make configurable)
+    def evaluate_blueprint(blueprint_name, env)
+      raise "'env' must be a String or an Environment." \
+        unless env.is_a?(String) || env.is_a?(Environments::Environment)
+
+      if env.is_a?(String)
+        env = environment(env)
+      end
+
+      ev = Amigrind::Blueprints::Evaluator.new(File.join(blueprints_path,
+                                                         "#{blueprint_name}.rb"),
+                                               env)
+
+      ev.blueprint
+    end
+
+    # TODO: refactor these client-y things.
+    def add_to_channel(env, blueprint_name, id, channel)
+      raise "'env' must be a String or an Environment." \
+        unless env.is_a?(String) || env.is_a?(Environments::Environment)
+      raise "'blueprint_name' must be a String." unless blueprint_name.is_a?(String)
+      raise "'id' must be a Fixnum." unless id.is_a?(Fixnum)
+      raise "'channel' must be a String or Symbol." \
+        unless channel.is_a?(String) || channel.is_a?(Symbol)
+
+      if env.is_a?(String)
+        env = environment(env)
+      end
+
+      raise "channel '#{channel}' does not exist in environment '#{env.name}'." \
+        unless env.channels.key?(channel.to_s) || channel.to_sym == :latest
+
+      credentials = Amigrind::Config.aws_credentials(env)
+
+      amigrind_client = Amigrind::Core::Client.new(env.aws.region, credentials)
+      ec2 = Aws::EC2::Client.new(region: env.aws.region, credentials: credentials)
+
+      image = amigrind_client.get_image_by_id(name: blueprint_name, id: id)
+
+      tag_key = Amigrind::Core::AMIGRIND_CHANNEL_TAG % { channel_name: channel }
+
+      info_log "setting '#{tag_key}' on image #{image.id}..."
+      ec2.create_tags(
+        resources: [ image.id ],
+        tags: [
+          {
+            key: tag_key,
+            value: '1'
+          }
+        ]
+      )
+    end
+
+    def remove_from_channel(env, blueprint_name, id, channel)
+      raise "'env' must be a String or an Environment." \
+        unless env.is_a?(String) || env.is_a?(Environments::Environment)
+      raise "'blueprint_name' must be a String." unless blueprint_name.is_a?(String)
+      raise "'id' must be a Fixnum." unless id.is_a?(Fixnum)
+      raise "'channel' must be a String or Symbol." \
+        unless channel.is_a?(String) || channel.is_a?(Symbol)
+
+      if env.is_a?(String)
+        env = environment(env)
+      end
+
+      raise "channel '#{channel}' does not exist in environment '#{env.name}'." \
+        unless env.channels.key?(channel.to_s) || channel.to_sym == :latest
+
+      credentials = Amigrind::Config.aws_credentials(env)
+
+      amigrind_client = Amigrind::Core::Client.new(env.aws.region, credentials)
+      ec2 = Aws::EC2::Client.new(region: env.aws.region, credentials: credentials)
+
+      image = amigrind_client.get_image_by_id(name: blueprint_name, id: id)
+
+      tag_key = Amigrind::Core::AMIGRIND_CHANNEL_TAG % { channel_name: channel }
+
+      info_log "clearing '#{tag_key}' on image #{image.id}..."
+      ec2.delete_tags(
+        resources: [ image.id ],
+        tags: [
+          {
+            key: tag_key,
+            value: nil
+          }
+        ]
+      )
+    end
+
+    def get_image_by_channel(env, blueprint_name, channel, steps_back = 0)
+      raise "'env' must be a String or an Environment." \
+        unless env.is_a?(String) || env.is_a?(Environments::Environment)
+      raise "'blueprint_name' must be a String." unless blueprint_name.is_a?(String)
+      raise "'channel' must be a String or Symbol." \
+        unless channel.is_a?(String) || channel.is_a?(Symbol)
+
+      if env.is_a?(String)
+        env = environment(env)
+      end
+
+      raise "channel '#{channel}' does not exist in environment '#{env.name}'." \
+        unless env.channels.key?(channel.to_s) || channel.to_sym == :latest
+
+      credentials = Amigrind::Config.aws_credentials(env)
+      amigrind_client = Amigrind::Core::Client.new(env.aws.region, credentials)
+
+      amigrind_client.get_image_by_channel(name: blueprint_name, channel: channel, steps_back: steps_back)
+    end
+
+    class << self
+      def init(path:)
+        raise "TODO: implement"
+      end
+
+      def with_repo(path: nil, &block)
+        path = path || ENV['AMIGRIND_PATH'] || Dir.pwd
+
+        repo = Repo.new(path)
+
+        Dir.chdir path do
+          block.call(repo)
+        end
+      end
+    end
+
+    private
+
+    def yaml_path_if_exists(name)
+      matches = [
+        "#{environments_path}/#{name}.yml",
+        "#{environments_path}/#{name}.yaml",
+        "#{environments_path}/#{name}.yml.erb",
+        "#{environments_path}/#{name}.yaml.erb"
+      ].select { |f| File.exist?(f) }
+
+      case matches.size
+      when 0
+        nil
+      when 1
+        matches.first
+      else
+        raise "found multiple env files for same env #{name}."
+      end
+    end
+
+    def rb_path_if_exists(name)
+      path = "#{environments_path}/#{name}.rb"
+
+      File.exist?(path) ? path : nil
+    end
+  end
+end

data/lib/amigrind/version.rb

@@ -0,0 +1,3 @@
+module Amigrind
+  VERSION = "0.1.1"
+end

data/sample_config/config.yaml

@@ -0,0 +1,9 @@
+aws:
+#  IF YOU ARE USING SHARED CREDENTIALS (~/.aws/credentials):
+#  ---------------------------------------------------------
+  credentials_type: shared
+  profile_name: default
+
+amigrind:
+# Without this, you'll need to pass the --environment argument all over the place.
+  default_environment: development

data/sample_repo/blueprints/dependent_ubuntu.rb

@@ -0,0 +1,21 @@
+source :parent do
+  name 'simple_ubuntu'
+  channel :live
+end
+
+build_channel :prerelease
+
+aws do
+  instance_type 't2.micro'
+  ssh_username 'ubuntu'
+
+  associate_public_ip_address true
+end
+
+provisioner :something_else, RemoteShell do
+  run_as_root!
+
+  command <<-CMD
+    echo "dependent_ubuntu" > /MACHINE_TYPE
+  CMD
+end