lono 4.2.7 → 5.0.1

data/lib/lono/app_file/registry.rb

@@ -0,0 +1,14 @@
+module Lono::AppFile
+  class Registry
+    @@items = []
+    class << self
+      def register(name, blueprint, options={})
+        @@items << Item.new(name, blueprint, options) unless @@items.detect { |i| i.name == name }
+      end
+
+      def items
+        @@items
+      end
+    end
+  end
+end

data/lib/lono/app_file/registry/item.rb

@@ -0,0 +1,46 @@
+module Lono::AppFile
+  class Registry
+    # Holds metadata about the item in the regsitry.
+    class Item
+      attr_reader :name, :options
+      def initialize(name, blueprint, options={})
+        @name, @blueprint, @options = name, blueprint, options
+      end
+
+      def path
+        "#{Lono.root}/output/#{@blueprint}/files/#{@name}"
+      end
+
+      def directory?
+        File.directory?(path)
+      end
+
+      def file?
+        File.file?(path)
+      end
+
+      def s3_path
+        file_path = zip_file_path.sub(%r{.*/output/[\w_-]+/files/}, '') # dont use basename. there might be subfolders
+        "#{s3_prefix}/#{file_path}"
+      end
+
+      # full path
+      def zip_file_path
+        "#{File.dirname(path)}/#{zip_file_name}"
+      end
+
+      def zip_file_name
+        "#{File.basename(path)}-#{Lono::Md5.sum(path)}.zip"
+      end
+
+    private
+      def md5_path
+        Lono::Md5.name(path)
+      end
+
+      def s3_prefix
+        "#{Lono.env}/#{@blueprint}/files" # development/ecs-asg/files
+      end
+    end
+  end
+end

data/lib/lono/app_file/upload.rb

@@ -0,0 +1,39 @@
+module Lono::AppFile
+  class Upload < Base
+    include Lono::AwsServices
+    extend Memoist
+
+    def initialize(blueprint, options={})
+      @blueprint, @options = blueprint, options
+    end
+
+    def upload
+      puts "Uploading app/files..."
+
+      Registry.items.each do |item|
+        s3_upload(item)
+      end
+    end
+
+    # TODO: check md5sum and only upload if it changes
+    def s3_upload(item)
+      filepath = item.zip_file_path
+      s3_key = item.s3_path
+      s3_path = "s3://#{s3_bucket}/#{s3_key}"
+      message = "Uploading: #{filepath} to #{s3_path}".color(:green)
+      message = "NOOP: #{message}" if @options[:noop]
+      puts message
+      return if @options[:noop]
+
+      s3.put_object(
+        body: IO.read(filepath),
+        bucket: s3_bucket,
+        key: s3_key,
+      )
+    end
+
+    def s3_bucket
+      Lono::S3::Bucket.name
+    end
+  end
+end

data/lib/lono/autoloader.rb

@@ -0,0 +1,22 @@
+require "zeitwerk"
+
+module Lono
+  class Autoloader
+    class Inflector < Zeitwerk::Inflector
+      def camelize(basename, _abspath)
+        map = { cli: "CLI", version: "VERSION" }
+        map[basename.to_sym] || super
+      end
+    end
+
+    class << self
+      def setup
+        loader = Zeitwerk::Loader.new
+        loader.inflector = Inflector.new
+        loader.push_dir(File.dirname(__dir__)) # lib
+        # loader.log! # uncomment to debug
+        loader.setup
+      end
+    end
+  end
+end

data/lib/lono/aws_services.rb

@@ -0,0 +1,46 @@
+require "aws-sdk-cloudformation"
+require "aws-sdk-ec2"
+require "aws-sdk-iam"
+require "aws-sdk-s3"
+
+module Lono
+  module AwsServices
+    extend Memoist
+    include Util
+
+    def ec2
+      Aws::EC2::Client.new
+    end
+    memoize :ec2
+
+    def iam
+      Aws::IAM::Client.new
+    end
+    memoize :iam
+
+    def sts
+      Aws::STS::Client.new # part of aws-sdk-core
+    end
+    memoize :sts
+
+    def s3
+      Aws::S3::Client.new
+    end
+    memoize :s3
+
+    def s3_resource
+      Aws::S3::Resource.new
+    end
+    memoize :s3_resource
+
+    def s3_presigner
+      Aws::S3::Presigner.new(client: s3)
+    end
+    memoize :s3_presigner
+
+    def cfn
+      Aws::CloudFormation::Client.new
+    end
+    memoize :cfn
+  end
+end

data/lib/lono/aws_services/util.rb

@@ -0,0 +1,49 @@
+module Lono::AwsServices
+  module Util
+    def stack_exists?(stack_name)
+      return true if testing_update?
+      return false if @options[:noop]
+
+      exist = nil
+      begin
+        # When the stack does not exist an exception is raised. Example:
+        # Aws::CloudFormation::Errors::ValidationError: Stack with id blah does not exist
+        cfn.describe_stacks(stack_name: stack_name)
+        exist = true
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        if e.message =~ /does not exist/
+          exist = false
+        elsif e.message.include?("'stackName' failed to satisfy constraint")
+          # Example of e.message when describe_stack with invalid stack name
+          # "1 validation error detected: Value 'instance_and_route53' at 'stackName' failed to satisfy constraint: Member must satisfy regular expression pattern: [a-zA-Z][-a-zA-Z0-9]*|arn:[-a-zA-Z0-9:/._+]*"
+          puts "Invalid stack name: #{stack_name}"
+          puts "Full error message: #{e.message}"
+          exit 1
+        else
+          raise # re-raise exception  because unsure what other errors can happen
+        end
+      end
+      exist
+    end
+
+    def find_stack(stack_name)
+      resp = cfn.describe_stacks(stack_name: stack_name)
+      resp.stacks.first
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      # example: Stack with id demo-web does not exist
+      if e.message =~ /Stack with/ && e.message =~ /does not exist/
+        nil
+      else
+        raise
+      end
+    end
+
+    def rollback_complete?(stack)
+      stack.stack_status == 'ROLLBACK_COMPLETE'
+    end
+
+    def testing_update?
+      ENV['TEST'] && self.class.name == "LonoCfn::Update"
+    end
+  end
+end

data/lib/lono/blueprint.rb

@@ -0,0 +1,113 @@
+module Lono
+  class Blueprint < Sequence
+    include Helper
+
+    argument :blueprint_name
+
+    def self.source_root
+      templates = File.expand_path("../templates", File.dirname(__FILE__))
+      "#{templates}/blueprint"
+    end
+
+    def self.cli_options
+      [
+        [:bundle, type: :boolean, default: true, desc: "Runs bundle install on the project"],
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files."],
+        [:from_new, type: :boolean, desc: "Called from `lono new` command."],
+        [:project_name, default: '', desc: "Only used with from_new internally"],
+        [:type, default: "dsl", desc: "Blueprint type: dsl or erb"],
+      ]
+    end
+
+    cli_options.each do |args|
+      class_option(*args)
+    end
+
+    # for specs
+    def set_cwd
+      @cwd = ENV['TEST'] ? File.dirname(Lono.root) : "#{Dir.pwd}/blueprints"
+
+      if options[:from_new]
+        # At this point @cwd will have the project_name from `lono new`
+        # Yup, it's confusing.  Here's an example to explain:
+        #
+        #   lono new my-infra - sets @cwd = my-infra
+        #
+        # Then within the new Thor::Group this is called
+        #
+        #   Lono::Blueprint.start(["ec2", "--from-new"])
+        #
+        # So @cwd = my-infra/blueprints
+        @cwd = "#{options[:project_name]}/blueprints"
+      end
+    end
+
+    def create_project
+      puts "=> Creating new blueprint called #{blueprint_name}."
+      directory ".", "#{@cwd}/#{blueprint_name}"
+    end
+
+    def create_app_folder
+      directory "../blueprint_types/#{@options[:type]}", "#{@cwd}/#{blueprint_name}"
+    end
+
+    def create_empty_directories
+      # Note: Not using Lono::Core::Config::PATHS.keys to create all of them because
+      # think it is more common to not have all the folders. Instead create them explicitly.
+      empty_directory "#{@cwd}/#{blueprint_name}/app/templates"
+    end
+
+    def create_starter_configs
+      if options[:from_new] # lono new command
+        directory "../blueprint_configs", options[:project_name]
+      else # lono blueprint command
+        directory "../blueprint_configs", "."
+      end
+    end
+
+    # After this commands are executed with the newly created project
+    def set_destination_root
+      destination_root = "#{@cwd}/#{blueprint_name}"
+      self.destination_root = destination_root
+      FileUtils.cd(self.destination_root)
+    end
+
+    def bundle_install
+      return if options[:from_new]
+      return unless options[:bundle]
+
+      puts "=> Installing dependencies with: bundle install"
+      Bundler.with_clean_env do
+        system("BUNDLE_IGNORE_CONFIG=1 bundle install")
+      end
+    end
+
+    def welcome_message
+      return if options[:from_new]
+      puts <<~EOL
+        #{"="*64}
+        Congrats 🎉 You have successfully created a lono blueprint.
+
+        Cd into your blueprint and check things out.
+
+          cd #{blueprint_name}
+
+        More info: https://lono.cloud/docs/core/blueprints
+
+      EOL
+    end
+
+    def tree
+      return if options[:from_new]
+      tree_installed = system("type tree > /dev/null")
+      return unless tree_installed
+
+      structure = `tree .`
+      puts <<~EOL
+        Here's the structure of your blueprint:
+
+        #{structure}
+      EOL
+    end
+  end
+end

data/lib/lono/blueprint/find.rb

@@ -0,0 +1,90 @@
+require "yaml"
+
+class Lono::Blueprint
+  class Find
+    class << self
+      extend Memoist
+
+      def one_or_all(blueprint)
+        blueprint ? [blueprint] : all_blueprints
+      end
+
+      # Returns both project and gem blueprints
+      def all_blueprints
+        project_blueprints = all_project_blueprint_infos.map { |info| info.name }
+
+        gem_blueprints = specs.map do |spec|
+          dot_lono = dot_meta_path(spec)
+          config = YAML.load_file(dot_lono)
+          config["blueprint_name"]
+        end
+
+        all = project_blueprints + gem_blueprints
+        all.uniq
+      end
+
+      # Returns blueprint root full path. Can be:
+      #
+      #   1. projects blueprints/BLUEPRINT - higher precedence
+      #   2. full gem path
+      #
+      def find(blueprint)
+        # Check projects blueprints
+        info = all_project_blueprint_infos.find { |info| info.name == blueprint}
+        return info.path if info
+
+        # Check gem specs
+        result = specs.find do |spec|
+          dot_lono = dot_meta_path(spec)
+          config = YAML.load_file(dot_lono)
+          config["blueprint_name"] == blueprint
+        end
+        result.full_gem_path if result
+      end
+
+      # Returns: Array of Blueprint::Info. Example:
+      #
+      #   [#<Lono::Blueprint::Info:0x0000561e620e0548
+      #     @name="ecs-spot-fleet",
+      #     @path="/full/path/to/blueprint/ecs-spot-demo">,
+      #   #<Lono::Blueprint::Info:0x0000561e61e132c0
+      #     @name="ec2",
+      #     @path="/full/path/to/blueprint/ec2">]
+      def all_project_blueprint_infos
+        infos = []
+        Dir.glob("#{Lono.root}/blueprints/*").select do |p|
+          dot_lono = dot_meta_path(p)
+          next unless File.exist?(dot_lono)
+          config = YAML.load_file(dot_lono)
+          infos << Info.new(config["blueprint_name"], p)
+        end
+        infos
+      end
+
+      # Only the blueprint specs
+      def specs
+        specs = Bundler.load.specs
+        specs.select do |spec|
+          File.exist?(dot_meta_path(spec))
+        end
+      end
+      memoize :specs
+
+      def dot_meta_path(source)
+        if source.is_a?(String) # path to folder
+          "#{source}/.meta/config.yml"
+        else # spec
+          "#{source.full_gem_path}/.meta/config.yml"
+        end
+      end
+
+      def bundler_version_check!
+        return unless Bundler.bundler_major_version >= 1 # LockfileParser only works for Bundler version 2+
+
+        puts "ERROR: The bundler version detected is too old. Please use bundler 2+".color(:red)
+        puts "Current detected bundler version is #{Bundler.bundler_major_version}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/lono/blueprint/helper.rb

@@ -0,0 +1,18 @@
+class Lono::Blueprint
+  module Helper
+    extend Memoist
+
+    def user_info
+      git_author_name = git_installed? ? `git config user.name`.chomp : ""
+      git_user_email = git_installed? ? `git config user.email`.chomp : ""
+      github_username = git_installed? ? `git config github.user`.chomp : ""
+
+      {
+        :author           => git_author_name.empty? ? "TODO: Write your name" : git_author_name,
+        :email            => git_user_email.empty? ? "TODO: Write your email address" : git_user_email,
+        :github_username  => github_username.empty? ? "[USERNAME]" : github_username,
+      }
+    end
+    memoize :user_info
+  end
+end