terraspace-bundler 0.1.0 → 0.2.0

data/lib/terraspace_bundler/info.rb

@@ -0,0 +1,25 @@
+module TerraspaceBundler
+  class Info < TB::CLI::Base
+    def run
+      name = @options[:mod]
+      found = lockfile.mods.find { |m| m.name == @options[:mod] }
+      if found
+        show(found)
+      else
+        logger.info "Could not find module in #{TB.config.lockfile}: #{name}".color(:red)
+      end
+    end
+
+    def show(mod)
+      props = mod.props.reject { |k,v| k == :name }.stringify_keys # for sort
+      puts "#{mod.name}:"
+      props.keys.sort.each do |k|
+        puts "    #{k}: #{props[k]}"
+      end
+    end
+
+    def lockfile
+      Lockfile.instance
+    end
+  end
+end

data/lib/terraspace_bundler/installer.rb

@@ -1,45 +1,27 @@
 module TerraspaceBundler
   class Installer < CLI::Base
-    extend Memoist
-
-    def initialize(options={})
-      super
-      @download = options[:download].nil? ? true : options[:download]
-    end
-
     def run
-      Setup.new(@options).setup!
-      download
-      export
-      logger.info "Modules saved to #{TB.config.export_path}"
+      Syncer.new(@options).run
+      Exporter.new(@options).run
+      finish_message
     end
 
-    def download
-      return unless @download
-
-      if File.exist?(TB.config.lockfile)
-        puts "Bundling modules from #{TB.config.lockfile}..."
-      else
-        Updater.new(@options).run(without_install: true) # creates Terrafile.lock
+    def finish_message
+      no_modules_found = true
+      export_paths.each do |export_path|
+        found = Dir.exist?(export_path) && !Dir.empty?(export_path)
+        next unless found
+        logger.info  "Modules saved to #{export_path}"
+        no_modules_found = false
       end
 
-      Syncer.new(mods).run
+      logger.info("No modules were found.") if no_modules_found
     end
 
-    def export
-      locked_mods.each(&:export)
-    end
-
-    def mods
-      locked_mods.map(&:to_mod)
-    end
-    memoize :mods
-
-    def locked_mods
-      data = YAML.load_file(TB.config.lockfile).deep_symbolize_keys
-      data.map do |name, info|
-        Mod::Locked.new(name, info)
-      end
+    def export_paths
+      export_paths = Terrafile.instance.mods.map(&:export_to).compact.uniq
+      export_paths << TB.config.export_path
+      export_paths
     end
   end
 end

data/lib/terraspace_bundler/list.rb

@@ -0,0 +1,22 @@
+module TerraspaceBundler
+  class List < TB::CLI::Base
+    def run
+      file = TB.config.lockfile
+      unless File.exist?(file)
+        logger.info "No #{file} found".color(:red)
+        logger.info "Maybe run: terraspace bundle"
+        return
+      end
+
+      logger.info "Modules included by #{file}\n\n"
+      lockfile.mods.each do |mod|
+        logger.info "    #{mod.name}"
+      end
+      logger.info "\nUse `terraspace bundle info` to print more detailed information about a module"
+    end
+
+    def lockfile
+      Lockfile.instance
+    end
+  end
+end

data/lib/terraspace_bundler/lockfile.rb

@@ -0,0 +1,70 @@
+require "yaml"
+
+module TerraspaceBundler
+  class Lockfile
+    include Singleton
+    include TB::Util::Logging
+
+    # {"vpc"=>
+    #   {"sha"=>"52328b2b5197f9b95e3005cfcfb99595040ee45b",
+    #   "source"=>"org/terraform-aws-vpc",
+    #   "url"=>"git@github.com:org/terraform-aws-vpc"},
+    # "instance"=>
+    #   {"sha"=>"570cca3ea7b25e3af1961dc57b27ca2c129b934a",
+    #   "source"=>"org/terraform-aws-instance",
+    #   "url"=>"git@github.com:org/terraform-aws-instance"}}
+    @@mods = nil
+    def mods
+      return @@mods if @@mods
+      lockfile = TB.config.lockfile
+      mods = File.exist?(lockfile) ? YAML.load_file(lockfile) : []
+      @@mods = mods.map do |name, props|
+        new_mod(name, props)
+      end
+    end
+
+    def new_mod(name, props)
+      Mod.new(props.merge(name: name))
+    end
+
+    # update (if version mismatch) or create (if missing)
+    def sync(mod)
+      changed = changed?(mod)
+      logger.debug "Detecting change for mod #{mod.name} changed #{changed.inspect}"
+      replace!(mod) if changed
+    end
+
+    # mod built from Terrafile
+    def changed?(mod)
+      # missing module case
+      found = mods.find { |locked_mod| locked_mod.name == mod.name }
+      unless found
+        logger.debug "Replacing mod: #{mod.name}. Not found in Terrafile.lock"
+        return true
+      end
+
+      comparer = VersionComparer.new(found, mod)
+      comparer.run
+      logger.debug(comparer.reason) if comparer.reason
+      comparer.changed?
+    end
+
+    def replace!(mod)
+      # mods are immediately fresh from writing to @@mods directly
+      @@mods.delete_if { |m| m.name == mod.name }
+      @@mods << mod
+      @@mods.sort_by!(&:name)
+    end
+
+    def prune(removed_mods)
+      removals = removed_mods.map(&:name)
+      @@mods.delete_if { |m| removals.include?(m.name) }
+    end
+
+    class << self
+      def write
+        Yamler.write(@@mods) if @@mods
+      end
+    end
+  end
+end

data/lib/terraspace_bundler/lockfile/version_comparer.rb

@@ -0,0 +1,43 @@
+class TerraspaceBundler::Lockfile
+  class VersionComparer
+    attr_reader :reason, :changed
+    def initialize(locked, current)
+      @locked, @current = locked, current
+      @changed = false
+    end
+
+    def changed?
+      @changed
+    end
+
+    def run
+      @changed = false
+      strict_versions = %w[subfolder ref tag export_to]
+      strict_versions.each do |version|
+        @changed = @locked.send(version) != @current.send(version)
+        if @changed
+          @reason = reason_message(version)
+          return @changed
+        end
+      end
+
+      # Loose version checks work a little different. If not set it explicitly, they will not be checked.
+      # Will use locked version in Terrafile.lock in this case.
+      # Note: Also, check the sha last since it triggers a git fetch.
+      loose_versions = %w[branch sha]
+      loose_versions.each do |version|
+        @changed = @current.send(version) && @current.send(version) != @locked.send(version)
+        if @changed
+          @reason = reason_message(version)
+          return @changed
+        end
+      end
+
+      @changed
+    end
+
+    def reason_message(version)
+      "Replacing mod: #{@current.name}. #{version} is different in Terrafile and Terrafile.lock"
+    end
+  end
+end

data/lib/terraspace_bundler/lockfile/yamler.rb

@@ -0,0 +1,37 @@
+require "yaml"
+
+class TerraspaceBundler::Lockfile
+  class Yamler
+    def initialize(mods)
+      @mods = mods.sort_by(&:name)
+    end
+
+    def dump
+      YAML.dump(data.deep_stringify_keys)
+    end
+
+    def data
+      @mods.inject({}) do |acc, mod|
+        acc.merge(item(mod))
+      end
+    end
+
+    def item(mod)
+      props = mod.props.dup # passthrough: name, url, version, ref, tag, branch etc
+      props.delete(:name) # different structure in Terrafile.lock YAML
+      props[:sha] = mod.sha
+      props.delete_if { |k,v| v.nil? }
+      { mod.name => props }
+    end
+
+    def write
+      IO.write(TB.config.lockfile, dump)
+    end
+
+    class << self
+      def write(mods)
+        new(mods).write
+      end
+    end
+  end
+end

data/lib/terraspace_bundler/logger.rb

@@ -2,25 +2,5 @@ require 'logger'
 
 module TerraspaceBundler
   class Logger < ::Logger
-    # Only need to override the add method as the other calls all lead to it.
-    def add(severity, message = nil, progname = nil)
-      # Taken from Logger#add source
-      # https://ruby-doc.org/stdlib-2.5.1/libdoc/logger/rdoc/Logger.html#method-i-add
-      if message.nil?
-        if block_given?
-          message = yield
-        else
-          message = progname
-          progname = @progname
-        end
-      end
-
-      super # original logic
-    end
-
-    # plain formatting
-    def format_message(severity, timestamp, progname, msg)
-      "#{msg}\n"
-    end
   end
 end

data/lib/terraspace_bundler/logger/formatter.rb

@@ -0,0 +1,7 @@
+class TerraspaceBundler::Logger
+  class Formatter < ::Logger::Formatter
+    def call(severity, time, progname, msg)
+      msg =~ /\n$/ ? msg : "#{msg}\n"
+    end
+  end
+end

data/lib/terraspace_bundler/mod.rb

@@ -1,85 +1,53 @@
 module TerraspaceBundler
   class Mod
-    extend Memoist
-    include TB::Util::Registry
+    extend PropsExtension
+    props :name, :source, :url, :subfolder, :type, :export_to
 
-    attr_reader :branch, :ref, :tag, :sha, :source
-    def initialize(data={}, global={})
-      @data, @global = data, global
-      @args = data[:args]
-      @options = data[:options]
-
-      # support variety of options, prefer version
-      @version = @options[:version]
-      @branch = @options[:branch]
-      @ref = @options[:ref]
-      @tag = @options[:tag]
-    end
-
-    def source
-      if @options[:source].split('/').size == 1
-        "#{org}/#{@options[:source]}"
-      else
-        @options[:source]
-      end
+    attr_reader :props, :version, :ref, :tag, :branch
+    def initialize(props={})
+      @props = props.symbolize_keys
+      # These props are used for version comparing by VersionComparer
+      @version, @ref, @tag, @branch = @props[:version], @props[:ref], @props[:tag], @props[:branch]
     end
 
-    def full_org
-      normalize_git_url(org)
+    def sha
+      # sha will already be set if coming from Terrafile.lock
+      # sha will be lazily fetch set if coming from Terrafile
+      @props[:sha] ||= fetch_sha
     end
 
-    def org
-      obtain_org(@options[:source], @global[:org])
+    def checkout_version
+      v = detected_version
+      v = "v#{v}" if type == "registry" && @version && !v.starts_with?("v")
+      v
     end
 
-    def url
-      normalize_url(source)
+    # use url instead of source because for registry modules, the repo name is different
+    def repo
+      url_words[-1]
     end
 
-    def normalize_url(source)
-      return registry_github if registry?(source)
-      normalize_git_url(source)
+    def org
+      url_words[-2] # second to last word
     end
 
-    def path
-      @options[:path]
+    def full_repo
+      "#{org}/#{repo}"
     end
 
-    def name
-      @args.first
+  private
+    def fetch_sha
+      downloader = Downloader.new(self)
+      downloader.run
+      downloader.sha
     end
-
-    def version
+    # support variety of options, prefer version
+    def detected_version
       @version || @ref || @tag || @branch
     end
 
-    def checkout_version
-      v = version
-      v = "v#{v}" if registry?(source) && @version && !v.starts_with?("v")
-      v
-    end
-
-    def sync
-      sync = Sync.new(self, url)
-      sync.run
-      @sha = sync.sha
-    end
-    memoize :sync
-
-    def normalize_git_url(s)
-      if git_url?(s)
-        s
-      else
-        "#{base_url}#{s}"
-      end
-    end
-
-    def base_url
-      @global[:base_url] || "git@github.com:"
-    end
-
-    def git_url?(s)
-      s.include?("http") || s.include?("git@")
+    def url_words
+      url.split('/')
     end
   end
 end

data/lib/terraspace_bundler/mod/downloader.rb

@@ -0,0 +1,55 @@
+class TerraspaceBundler::Mod
+  class Downloader
+    extend Memoist
+    include TB::Util::Git
+    include TB::Util::Logging
+    include TB::Mod::PathConcern
+
+    attr_reader :sha
+    def initialize(mod)
+      @mod = mod
+    end
+
+    def run
+      setup_tmp
+      org_path = "#{cache_root}/#{@mod.org}"
+      FileUtils.mkdir_p(org_path)
+
+      Dir.chdir(org_path) do
+        unless File.exist?(@mod.repo)
+          sh "git clone #{@mod.url}"
+        end
+
+        Dir.chdir(@mod.repo) do
+          git "pull"
+          git "submodule update --init"
+          stage
+        end
+      end
+    end
+
+    def stage
+      copy_to_stage
+      # TODO: if there's no master, need to checkout if its the default branch
+      checkout = @mod.checkout_version || "master"
+      switch_version(checkout)
+    end
+
+    def switch_version(version)
+      stage_path = stage_path("#{@mod.org}/#{@mod.repo}")
+      logger.debug "Within: #{stage_path}"
+      Dir.chdir(stage_path) do
+        git "checkout #{version}"
+        @sha = git("rev-parse HEAD").strip
+      end
+    end
+
+    def copy_to_stage
+      cache_path = cache_path("#{@mod.org}/#{@mod.repo}")
+      stage_path = stage_path("#{@mod.org}/#{@mod.repo}")
+      FileUtils.rm_rf(stage_path)
+      FileUtils.mkdir_p(File.dirname(stage_path))
+      FileUtils.cp_r(cache_path, stage_path)
+    end
+  end
+end