ufo 5.0.7 → 6.0.0

data/lib/ufo/docker/state.rb

@@ -0,0 +1,63 @@
+module Ufo::Docker
+  class State
+    include Ufo::Utils::Logging
+    include Ufo::Utils::Pretty
+
+    def initialize(docker_image, options={})
+      @docker_image, @options = docker_image, options
+    end
+
+    def update
+      data = current_data
+      data[Ufo.env] ||= {}
+      data[Ufo.env]["base_image"] = @docker_image
+      pretty_path = state_path.sub("#{Ufo.root}/", "")
+      FileUtils.mkdir_p(File.dirname(state_path))
+      IO.write(state_path, YAML.dump(data))
+      logger.info "The #{pretty_path} base_image has been updated with the latest base image:".color(:green)
+      logger.info "  #{@docker_image}".color(:green)
+      reminder_message
+    end
+
+    def current_data
+      File.exist?(state_path) ? YAML.load_file(state_path) : {}
+    end
+
+    def state_path
+      path = "#{Ufo.root}/.ufo/state"
+      if ENV['UFO_APP'] # env var activates app path
+        path = "#{Ufo.root}/.ufo/state/#{Ufo.app}"
+      end
+      "#{path}/data.yml"
+    end
+
+    def reminder_message
+      return unless Ufo.config.state.reminder
+      repo = ENV['UFO_CENTRAL_REPO']
+      return unless repo
+      logger.info "It looks like you're using a central deployer pattern".color(:yellow)
+      logger.info <<~EOL
+        Remember to commit the state file:
+
+            state file: #{pretty_path(state_path)}
+            repo:       #{repo}
+
+      EOL
+
+      unless ENV['UFO_APP']
+        logger.info "WARN: It also doesnt look like UFO_ENV is set".color(:yellow)
+        logger.info "UFO_ENV should be set when you're using ufo in a central manner"
+      end
+
+      logger.info <<~EOL
+        You can disable these reminder messages with:
+
+        .ufo/config.rb
+
+            Ufo.configure do |config|
+              config.state.reminder = false
+            end
+      EOL
+    end
+  end
+end

data/lib/ufo/ecr/auth.rb

@@ -17,11 +17,12 @@ This class manipulates the ~/.docker/config.json file which is an internal docke
 =end
 module Ufo
   class Ecr::Auth
-    include AwsService
+    include Ufo::AwsServices
+    include Ufo::Utils::Logging
 
-    def initialize(full_image_name)
-      @full_image_name = full_image_name
-      @repo_domain = "#{full_image_name.split('/').first}"
+    def initialize(docker_image)
+      @docker_image = docker_image
+      @repo_domain = "#{docker_image.split('/').first}"
     end
 
     def update
@@ -32,16 +33,16 @@ module Ufo
       username, password = Base64.decode64(auth_token).split(':')
 
       command = "docker login -u #{username} --password-stdin #{@repo_domain}"
-      puts "=> #{command}".color(:green)
+      logger.debug "=> #{command}".color(:green)
       *, status = Open3.capture3(command, stdin_data: password)
       unless status.success?
-        puts "ERROR: The docker failed to login.".color(:red)
+        logger.error "ERROR: The docker failed to login.".color(:red)
         exit 1
       end
     end
 
     def ecr_image?
-      !!(@full_image_name =~ /\.amazonaws\.com/)
+      !!(@docker_image =~ /\.amazonaws\.com/)
     end
 
     def fetch_auth_token

data/lib/ufo/ecr/cleaner.rb

@@ -1,25 +1,23 @@
 require "json"
 
-# Can test:
-#
-#   ufo ship app-web --cluster prod --noop
 module Ufo
   class Ecr::Cleaner
-    include Util
-    include AwsService
+    include Ufo::AwsServices
+    include Ufo::Utils::Execute
+    include Ufo::Utils::Logging
 
     def initialize(docker_image_name, options={})
       # docker_image_name does not containg the tag
       # Example: 123456789.dkr.ecr.us-east-1.amazonaws.com/image
       @docker_image_name = docker_image_name
       @options = options
-      @keep = options[:ecr_keep] || settings[:ecr_keep]
+      @keep = options[:ecr_keep] || Ufo.config.docker.ecr_keep
       @tag_prefix = options[:tag_prefix] || "ufo"
     end
 
     def cleanup
-      return false unless ecr_image?
       return false unless @keep
+      return false unless ecr_image?
       update_auth_token
       image_tags = fetch_image_tags
       delete_tags = image_tags[@keep..-1] # ordered by most recent images first
@@ -36,16 +34,14 @@ module Ufo
 
     def delete_images(tags)
       return if tags.nil? || tags.empty?
-      unless @options[:mute]
-        puts "Keeping #{@keep} most recent ECR images."
-        puts "Deleting these ECR images:"
-        tag_list = tags.map { |t| "  #{repo_name}:#{t}" }
-        puts tag_list
-      end
+      logger.info "Keeping #{@keep} most recent ECR images."
+      logger.info "Deleting these ECR images:"
+      tag_list = tags.map { |t| "  #{repo_name}:#{t}" }
+      logger.info tag_list
       image_ids = tags.map { |tag| {image_tag: tag} }
       ecr.batch_delete_image(
         repository_name: repo_name,
-        image_ids: image_ids) unless @options[:noop]
+        image_ids: image_ids)
     end
 
     def update_auth_token

data/lib/ufo/ext/core/module.rb

@@ -0,0 +1,31 @@
+class Module
+  # Include all modules within the relative folder. IE: for dsl/syntax/mod/*
+  #
+  #    include Common
+  #    include Provider
+  #    # etc
+  #
+  # Caller lines are different for OSes:
+  #
+  #   windows: "C:/Ruby31-x64/lib/ruby/gems/3.1.0/gems/lono-1.1.1/lib/lono/builder.rb:34:in `build'"
+  #   linux: "/home/ec2-user/.rvm/gems/ruby-3.0.3/gems/lono-1.1.1/lib/lono/compiler/dsl/syntax/mod.rb:4:in `<module:Mod>'"
+  #
+  def include_modules(dir)
+    caller_line = caller[0]
+    parts = caller_line.split(':')
+    calling_file = caller_line.match(/^[a-zA-Z]:/) ? parts[1] : parts[0]
+    parent_dir = File.dirname(calling_file)
+
+    full_dir = "#{parent_dir}/#{dir}"
+    paths = Dir.glob("#{full_dir}/**/*.rb")
+    if paths.empty?
+      raise "Empty include_modules full_dir: #{full_dir}"
+    end
+    paths.each do |path|
+      regexp = Regexp.new(".*/lib/")
+      mod = path.sub(regexp, '').sub('.rb','').camelize
+      c = mod.constantize
+      include c if c.class == Module
+    end
+  end
+end

data/lib/ufo/ext/core/nil_class.rb

@@ -0,0 +1,11 @@
+require "json"
+
+module Ufo
+  refine NilClass do
+    def to_json
+      JSON.generate(self)
+    end
+  end
+end
+
+using Ufo

data/lib/ufo/ext.rb

@@ -0,0 +1,2 @@
+require_relative "ext/core/module"
+require_relative "ext/core/nil_class"

data/lib/ufo/{role → iam_role}/builder.rb

@@ -1,4 +1,4 @@
-module Ufo::Role
+module Ufo::IamRole
   class Builder
     def initialize(role_type)
       @role_type = role_type

data/lib/ufo/{role → iam_role}/dsl.rb

@@ -1,11 +1,13 @@
-module Ufo::Role
+module Ufo::IamRole
   class DSL
+    include DslEvaluator
+
     def initialize(path)
       @path = path # IE: .ufo/iam_roles/task_role.rb
     end
 
     def evaluate
-      instance_eval(IO.read(@path), @path)
+      evaluate_file(@path)
     end
 
     def iam_policy(policy_name, statements)
@@ -17,5 +19,9 @@ module Ufo::Role
       role_type = File.basename(@path).sub('.rb','') # task_role or execution_role
       Registry.register_managed_policy(role_type, policies)
     end
+
+    def aws
+      AwsData.new
+    end
   end
 end

data/lib/ufo/{role → iam_role}/registry.rb

@@ -1,6 +1,6 @@
 require "set"
 
-module Ufo::Role
+module Ufo::IamRole
   class Registry
     class_attribute :policies
     self.policies = {}

data/lib/ufo/info.rb

@@ -1,5 +1,7 @@
 module Ufo
-  class Info < Base
+  class Info < Ufo::CLI::Base
+    include Ufo::AwsServices
+
     def run
       unless service
         puts no_service_message
@@ -7,12 +9,15 @@ module Ufo
       end
       puts "Resources:"
       stack_resources.each do |r|
-        # pp r
         puts "#{r.logical_resource_id} - #{r.resource_type}:".color(:green)
         puts "  #{r.physical_resource_id}"
       end
     end
 
+    def no_service_message
+      "No stack #{@stack_name.color(:green)} found"
+    end
+
     # Passing in service so method can be used else where.
     def load_balancer(service)
       load_balancer = service.load_balancers.first
@@ -33,24 +38,37 @@ module Ufo
       return unless stack
 
       service = stack_resources.find { |r| r.resource_type == "AWS::ECS::Service" }
+      return unless service # stack is still creating
       arn = service.physical_resource_id
       resp = ecs.describe_services(services: [arn], cluster: @cluster)
       resp.services.first
     end
     memoize :service
 
+    def service?
+      !!service
+    end
+
     def stack
       find_stack(@stack_name)
     end
     memoize :stack
 
-    def route53_dns
+    def url
       return unless stack
 
       output = stack.outputs.find do |o|
         o.output_key == "Route53Dns"
       end
-      output.output_value if output
+      dns_name = output.output_value if output
+      return unless dns_name
+
+      ssl = stack_resources.detect.find do |r|
+        r.logical_resource_id == "ListenerSsl"
+      end
+
+      protocol = ssl ? 'https' : 'http'
+      "#{protocol}://#{dns_name}"
     end
 
     def stack_resources

data/lib/ufo/layering/layer.rb

@@ -0,0 +1,95 @@
+require "aws_data"
+
+# Layers example
+#
+#     .ufo/vars.rb
+#     .ufo/vars/base.rb
+#     .ufo/vars/dev.rb
+#     .ufo/vars/prod.rb
+#     .ufo/vars/app1.rb
+#     .ufo/vars/app1/base.rb
+#     .ufo/vars/app1/dev.rb
+#     .ufo/vars/app1/prod.rb
+#
+module Ufo::Layering
+  class Layer
+    extend Memoist
+    include Ufo::Layering
+    include Ufo::Utils::Logging
+    include Ufo::Utils::Pretty
+
+    def initialize(task_definition)
+      @task_definition = task_definition
+    end
+
+    def paths
+      core = full_layers(".ufo/vars")
+      app = full_layers(".ufo/vars/#{Ufo.app}")
+      paths = core + app
+      add_ext!(paths)
+      paths.map! { |p| "#{Ufo.root}/#{p}" }
+      show_layers(paths)
+      paths
+    end
+
+    def full_layering
+      # layers defined in Lono::Layering module
+      all = layers.map { |layer| layer.sub(/\/$/,'') } # strip trailing slash
+      all.inject([]) do |sum, layer|
+        sum += layer_levels(layer) unless layer.nil?
+        sum
+      end
+    end
+
+    # interface method
+    def main_layers
+      ['']
+    end
+
+    # adds prefix and to each layer pair that has base and Ufo.env. IE:
+    #
+    #    "#{prefix}/base"
+    #    "#{prefix}/#{Ufo.env}"
+    #
+    def layer_levels(prefix=nil)
+      levels = ["base", Ufo.env]
+      levels.map! do |i|
+        # base layer has prefix of '', reject with blank so it doesnt produce '//'
+        [prefix, i].reject(&:blank?).join('/')
+      end
+      levels.unshift(prefix) # unless prefix.blank? # IE: params/us-west-2.txt
+      levels
+    end
+
+    def add_ext!(paths)
+      ext = "rb"
+      paths.map! do |path|
+        path = path.sub(/\/$/,'') if path.ends_with?('/')
+        "#{path}.rb"
+      end
+      paths
+    end
+
+    def full_layers(dir)
+      layers = full_layering.map do |layer|
+        "#{dir}/#{layer}"
+      end
+      role_layers = full_layering.map do |layer|
+        "#{dir}/#{@task_definition.role}/#{layer}" # Note: layer can be '' will clean up
+      end
+      layers += role_layers
+      layers.map { |l| l.gsub('//','/') } # cleanup // if layer is ''
+    end
+
+    @@shown_layers = false
+    def show_layers(paths)
+      return if @@shown_layers
+      logger.info "Vars Layers:" if ENV['UFO_SHOW_ALL_LAYERS']
+      paths.each do |path|
+        show_layer = File.exist?(path) && logger.level <= Logger::DEBUG
+        logger.info "    #{pretty_path(path)}" if show_layer || ENV['UFO_SHOW_ALL_LAYERS']
+      end
+      @@shown_layers = true
+    end
+  end
+end

data/lib/ufo/layering.rb

@@ -0,0 +1,23 @@
+require "active_support/lazy_load_hooks"
+
+module Ufo
+  module Layering
+    def layers
+      pre_layers + main_layers + post_layers
+    end
+
+    def main_layers
+      super
+    end
+
+    def pre_layers
+      []
+    end
+
+    def post_layers
+      []
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks(:ufo_layering, Ufo::Layering)

data/lib/ufo/log_group.rb

@@ -1,24 +1,20 @@
 # Use to automatically create the CloudWatch group.
 # For some reason creating ECS does do this by default.
 module Ufo
-  class LogGroup
-    include AwsService
-
-    def initialize(task_definition, options)
-      @task_definition, @options = task_definition, options
-    end
+  class LogGroup < Ufo::CLI::Base
+    include Ufo::AwsServices
 
     def create
-      puts "Ensuring log group for #{@task_definition.color(:green)} task definition exists"
+      logger.debug "Ensuring log group for #{@task_definition.name.color(:green)} task definition exists"
       return if @options[:noop]
       return if @options[:rollback] # dont need to create log group because previously deployed
 
-      Ufo.check_task_definition!(@task_definition)
+      check_task_definition_exists!
       task_def = JSON.load(IO.read(task_def_path))
       task_def["containerDefinitions"].each do |container_def|
         begin
           log_group_name = container_def["logConfiguration"]["options"]["awslogs-group"]
-          puts "Log group name: #{log_group_name}"
+          logger.debug "Log group name: #{log_group_name}"
         rescue NoMethodError
           # silence when the logConfiguration is not specified
         end
@@ -34,7 +30,19 @@ module Ufo
     end
 
     def task_def_path
-      "#{Ufo.root}/.ufo/output/#{@task_definition}.json"
+      "#{Ufo.root}/.ufo/output/task_definition.json"
+    end
+
+    def check_task_definition_exists!
+      return if File.exist?(task_def_path)
+      logger.error "ERROR: Unable to find the task definition at #{task_def_path}.".color(:red)
+      logger.error <<~EOL
+          Please double check that it was built correctly with:
+
+              ufo build
+
+      EOL
+      exit 1
     end
   end
 end

data/lib/ufo/logger/formatter.rb

@@ -0,0 +1,13 @@
+class Ufo::Logger
+  class Formatter < ::Logger::Formatter
+    def call(severity, time, progname, msg)
+      # careful changing the format. All::Summary uses a regexp on this format to remove the timestamp
+      "[#{format_datetime(time)} ##{Process.pid} #{progname}]: #{msg}"
+    end
+
+  private
+    def format_datetime(time)
+      time.strftime("%Y-%m-%dT%H:%M:%S")
+    end
+  end
+end

data/lib/ufo/logger.rb

@@ -0,0 +1,32 @@
+require 'logger'
+
+module Ufo
+  class Logger < ::Logger
+    def initialize(*args)
+      super
+      self.formatter = Formatter.new
+      self.level = ENV['UFO_LOG_LEVEL'] || :info # note: only respected when config.logger not set in config/app.rb
+    end
+
+    def format_message(severity, datetime, progname, msg)
+      line = if @logdev.dev == $stdout || @logdev.dev == $stderr || @logdev.dev.is_a?(StringIO)
+        msg # super simple format if stdout
+      else
+        super # use the configured formatter
+      end
+      line =~ /\n$/ ? line : "#{line}\n"
+    end
+
+    # Used to allow output to always go to stdout
+    def stdout(msg, newline: true)
+      if newline
+        puts msg
+      else
+        print msg
+      end
+    end
+
+    public :print
+    public :printf
+  end
+end

data/lib/ufo/names.rb

@@ -0,0 +1,69 @@
+module Ufo
+  class Names
+    extend Memoist
+
+    attr_reader :role
+    def initialize
+      @role = Ufo.role
+    end
+
+    def cluster
+      expansion(Ufo.config.ecs.cluster) # IE: :ENV => dev
+    end
+    memoize :cluster
+
+    def stack
+      name = expansion(Ufo.config.names.stack) # IE: :APP-:ROLE-:ENV => demo-web-dev
+      [name, Ufo.extra].compact.join('-')
+    end
+    memoize :stack
+
+    def task_definition
+      expansion(Ufo.config.names.task_definition) # IE: :APP-:ROLE-:ENV => demo-web-dev
+    end
+    memoize :task_definition
+
+    def expansion(string, options={})
+      return string unless string.is_a?(String) # in case of nil
+
+      string = string.dup
+      vars = string.scan(/:\w+/) # => [":APP", ":ROLE", :ENV"]
+      vars.each do |var|
+        string.gsub!(var, var_value(var))
+      end
+      string = strip(string)
+      dashes = options[:dasherize].nil? ? true : options[:dasherize]
+      string = string.dasherize if dashes
+      string
+    end
+
+    def var_value(unexpanded)
+      name = unexpanded.sub(':','').downcase
+      if respond_to?(name)
+        send(name).to_s # pass value straight through
+      else
+        unexpanded
+      end
+    end
+
+    def strip(string)
+      string.sub(/^-+/,'').sub(/-+$/,'') # remove leading and trailing -
+            .gsub(%r{-+},'-') # remove double dashes are more. IE: -- => -
+    end
+
+    def app
+      Ufo.app
+    end
+
+    def env
+      Ufo.env
+    end
+    alias_method :ufo_env, :env
+
+    delegate :region, to: :aws
+    def aws
+      AwsData.new
+    end
+    memoize :aws
+  end
+end

data/lib/ufo/param.rb

@@ -18,7 +18,8 @@ module Ufo
     memoize :data
 
     def template_scope
-      @template_scope ||= Ufo::TemplateScope.new(Ufo::DSL::Helper.new, nil)
+      self # TODO: add access to helpers like network
+      # @template_scope ||= Ufo::TemplateScope.new(Ufo::DSL::Helper.new, nil)
     end
   end
 end

data/lib/ufo/task_definition/builder.rb

@@ -0,0 +1,7 @@
+class Ufo::TaskDefinition
+  class Builder < Ufo::CLI::Base
+    def build
+      Erb.new(@options).run
+    end
+  end
+end

data/lib/ufo/task_definition/context.rb

@@ -0,0 +1,45 @@
+class Ufo::TaskDefinition
+  module Context
+    include DslEvaluator
+    include Helpers
+
+    def load_context
+      load_variables
+      load_custom_helpers
+    end
+
+    def load_variables
+      layers = Ufo::Layering::Layer.new(@task_definition).paths
+      layers.each do |layer|
+        evaluate_file(layer)
+      end
+    end
+
+    def load_custom_helpers
+      load_helper_files("#{Ufo.root}/.ufo/helpers")
+    end
+
+    # Load custom project helper methods
+    def load_helper_files(dir)
+      paths = Dir.glob("#{dir}/**/*.rb")
+      paths.sort_by! { |p| p.size } # so namespaces are loaded first
+      paths.each do |path|
+        next unless File.file?(path)
+
+        filename = path.sub(%r{.*/helpers/},'').sub('.rb','')
+        module_name = filename.camelize
+
+        # Prepend a period so require works when UFO_ROOT is set to a relative path without a period.
+        #   Example: UFO_ROOT=tmp/ufo_project
+        first_char = path[0..0]
+        path = "./#{path}" unless %w[. /].include?(first_char)
+
+        # Examples:
+        #     path:        .ufo/helpers/custom_helper.rb
+        #     module_name: CustomHelper
+        require path
+        self.class.send :include, module_name.constantize
+      end
+    end
+  end
+end

data/lib/ufo/task_definition/erb/base.rb

@@ -0,0 +1,18 @@
+class Ufo::TaskDefinition::Erb
+  class Base < Ufo::CLI::Base
+    def initialize(options={})
+      super
+      @path = options[:path]
+      @task_definition = options[:task_definition]
+    end
+
+    def print_code(text)
+      lines = text.split("\n")
+      lpad = lines.size.to_s.size
+      lines.each_with_index do |line,n|
+        printf("%#{lpad}d %s\n", n+1, line)
+      end
+      nil
+    end
+  end
+end