simplygenius-atmos 0.7.1 → 0.8.0

data/lib/atmos/generator.rb

@@ -1,199 +0,0 @@
-require_relative '../atmos'
-require_relative '../atmos/ui'
-require 'thor'
-require 'find'
-
-module Atmos
-
-  # From https://github.com/rubber/rubber/blob/master/lib/rubber/commands/vulcanize.rb
-  class Generator < Thor
-
-    include Thor::Actions
-
-    def initialize(*args, **opts)
-      super
-      @dependencies = opts[:dependencies]
-    end
-
-    no_commands do
-
-      include GemLogger::LoggerSupport
-      include Atmos::UI
-
-      TEMPLATES_SPEC_FILE = 'templates.yml'
-      TEMPLATES_ACTIONS_FILE = 'templates.rb'
-
-      def self.valid_templates
-        all_entries = []
-        source_paths_for_search.collect do |path|
-          entries = []
-          if Dir.exist?(path)
-            Find.find(path) do |f|
-              Find.prune if File.basename(f) =~  /(^\.)|svn|CVS/
-
-              template_spec = File.join(f, TEMPLATES_SPEC_FILE)
-              if File.exist?(template_spec)
-                entries << f.sub(/^#{path}\//, '')
-                Find.prune
-              end
-            end
-            all_entries << entries.sort
-          else
-            logger.warn("Sourcepath does not exist: #{path}")
-          end
-        end
-
-        return all_entries.flatten
-      end
-
-      def valid_templates
-        self.class.valid_templates
-      end
-
-      def generate(template_names)
-        seen = Set.new
-        Array(template_names).each do |template_name|
-          template_dependencies = find_dependencies(template_name)
-          template_dependencies << template_name
-          template_dependencies.each do |tname|
-            apply_template(tname) unless seen.include?(tname)
-            seen << tname
-          end
-        end
-      end
-
-    end
-
-    protected
-
-    def template_dir(name)
-      template_dir = nil
-      source_path = nil
-      source_paths.each do |sp|
-        potential_template_dir = File.join(sp, name, '')
-        template_spec = File.join(sp, name, TEMPLATES_SPEC_FILE)
-        if File.exist?(template_spec) && File.directory?(potential_template_dir)
-          template_dir = potential_template_dir
-          source_path = sp
-          break
-        end
-      end
-
-      unless template_dir.present?
-        raise ArgumentError.new("Invalid template #{name}, use one of: #{valid_templates.join(', ')}")
-      end
-
-      return template_dir, source_path
-    end
-
-    def find_dependencies(name, seen=[])
-      template_dir, source_path = template_dir(name)
-
-      return [] unless @dependencies
-
-      if seen.include?(name)
-          seen << name
-          raise ArgumentError.new("Circular template dependency: #{seen.to_a.join(" => ")}")
-      end
-      seen << name
-
-      template_conf = load_template_config(template_dir)
-      template_dependencies = Set.new(Array(template_conf['dependent_templates'] || []))
-
-      template_dependencies.clone.each do |dep|
-        template_dependencies.merge(find_dependencies(dep, seen.dup))
-      end
-
-      return template_dependencies.to_a
-    end
-
-    def apply_template(name)
-      template_dir, source_path = template_dir(name)
-      logger.debug("Applying template '#{name}' from '#{template_dir}' in sourcepath '#{source_path}'")
-      template_conf = load_template_config(template_dir)
-
-      extra_generator_steps_file = File.join(template_dir, TEMPLATES_ACTIONS_FILE)
-
-      Find.find(template_dir) do |f|
-        Find.prune if f == File.join(template_dir, TEMPLATES_SPEC_FILE)  # don't copy over templates.yml
-        Find.prune if f == extra_generator_steps_file # don't copy over templates.rb
-
-        # Using File.join(x, '') to ensure trailing slash to make sure we end
-        # up with a relative path
-        template_rel = f.gsub(/#{File.join(template_dir, '')}/, '')
-        source_rel = f.gsub(/#{File.join(source_path, '')}/, '')
-        dest_rel   = source_rel.gsub(/^#{File.join(name, '')}/, '')
-
-        # prune non-directories at top level (the top level directory is the
-        # template dir itself)
-        if f !~ /\// && ! File.directory?(f)
-          Find.prune
-        end
-
-        # Only include optional files when their conditions eval to true
-        optional = template_conf['optional'][template_rel] rescue nil
-        if optional
-          exclude = ! eval(optional)
-          logger.debug("Optional template '#{template_rel}' with condition: '#{optional}', excluding=#{exclude}")
-          Find.prune if exclude
-        end
-
-        logger.debug("Template '#{source_rel}' => '#{dest_rel}'")
-        if File.directory?(f)
-          empty_directory(dest_rel)
-        else
-          copy_file(source_rel, dest_rel, mode: :preserve)
-        end
-      end
-
-      if File.exist? extra_generator_steps_file
-        eval File.read(extra_generator_steps_file), binding, extra_generator_steps_file
-      end
-    end
-
-    def load_template_config(template_dir)
-      YAML.load(File.read(File.join(template_dir, 'templates.yml'))) || {} rescue {}
-    end
-
-    def raw_config(yml_file)
-      @raw_configs ||= {}
-      @raw_configs[yml_file] ||= SettingsHash.new((YAML.load_file(yml_file) rescue {}))
-    end
-
-    def add_config(yml_file, key, value, additive: true)
-      new_yml = SettingsHash.add_config(yml_file, key, value, additive: additive)
-      create_file yml_file, new_yml
-      @raw_configs.delete(yml_file) if @raw_configs
-    end
-
-    def get_config(yml_file, key)
-      config = raw_config(yml_file)
-      config.notation_get(key)
-    end
-
-    def config_present?(yml_file, key, value=nil)
-      val = get_config(yml_file, key)
-
-      result = val.present?
-      if value && result
-        if val.is_a?(Array)
-          result = Array(value).all? {|v| val.include?(v) }
-        else
-          result = (val == value)
-        end
-      end
-
-      return result
-    end
-
-    # TODO make a context object for these actions, and populate it with things
-    # like template_dir from within apply
-    def new_keys?(src_yml_file, dest_yml_file)
-      src = raw_config(src_yml_file).keys.sort
-      dest = raw_config(dest_yml_file).keys.sort
-      (src - dest).size > 0
-    end
-
-  end
-
-end

data/lib/atmos/generator_factory.rb

@@ -1,93 +0,0 @@
-require_relative '../atmos'
-require_relative '../atmos/generator'
-require 'tmpdir'
-require 'fileutils'
-require 'git'
-require 'open-uri'
-require 'zip'
-
-module Atmos
-  class GeneratorFactory
-    include GemLogger::LoggerSupport
-
-    def self.create(sourcepaths, **opts)
-      expanded_sourcepaths = expand_sourcepaths(sourcepaths)
-      klass = Class.new(Atmos::Generator) do
-        source_paths.concat(expanded_sourcepaths)
-      end
-
-      g = klass.new([], **opts)
-      return g
-    end
-
-    def self.expand_sourcepaths(sourcepaths)
-      expanded_sourcepaths = []
-      sourcepaths.each do |sourcepath|
-
-        if sourcepath =~ /(\.git)|(\.zip)(#.*)?$/
-
-          logger.debug("Using archive sourcepath")
-
-          tmpdir = Dir.mktmpdir("atmos-templates-")
-          at_exit { FileUtils.remove_entry(tmpdir) }
-
-          template_subdir = ''
-          if sourcepath =~ /([^#]*)#([^#]*)/
-            sourcepath = Regexp.last_match[1]
-            template_subdir = Regexp.last_match[2]
-            logger.debug("Using archive subdirectory for templates: #{template_subdir}")
-          end
-
-          if sourcepath =~ /.git$/
-
-            begin
-              logger.debug("Cloning git archive to tmpdir")
-
-              g = Git.clone(sourcepath, 'atmos-checkout', depth: 1, path: tmpdir)
-              local_template_path = File.join(g.dir.path, template_subdir)
-
-              expanded_sourcepaths << local_template_path
-              logger.debug("Using git sourcepath: #{local_template_path}")
-            rescue => e
-              logger.log_exception(e, level: :debug)
-              logger.warn("Could not read from git archive, ignoring sourcepath: #{sourcepath}")
-            end
-
-          elsif sourcepath =~ /.zip$/
-
-            begin
-              logger.debug("Cloning zip archive to tmpdir")
-
-              open(sourcepath, 'rb') do |io|
-                Zip::File.open_buffer(io) do |zip_file|
-                  zip_file.each do |f|
-                    fpath = File.join(tmpdir, f.name)
-                    f.extract(fpath)
-                  end
-                end
-              end
-
-              local_template_path = File.join(tmpdir, template_subdir)
-              expanded_sourcepaths << local_template_path
-              logger.debug("Using zip sourcepath: #{local_template_path}")
-            rescue => e
-              logger.log_exception(e, level: :debug)
-              logger.warn("Could not read from zip archive, ignoring sourcepath: #{sourcepath}")
-            end
-
-          end
-
-        else
-
-          logger.debug("Using local sourcepath: #{sourcepath}")
-          expanded_sourcepaths << sourcepath
-
-        end
-
-      end
-
-      return expanded_sourcepaths
-    end
-
-  end
-end

data/lib/atmos/ipc.rb

@@ -1,132 +0,0 @@
-require_relative '../atmos'
-require 'fileutils'
-require 'hashie'
-
-module Atmos
-  class Ipc
-    include GemLogger::LoggerSupport
-
-    def initialize(sock_dir=Dir.tmpdir)
-      @sock_dir = sock_dir
-    end
-
-    def listen(&block)
-      raise "Already listening" if @server
-
-      begin
-        @socket_path = File.join(@sock_dir, 'atmos-ipc')
-        FileUtils.rm_f(@socket_path)
-        @server = UNIXServer.open(@socket_path)
-      rescue ArgumentError => e
-        if e.message =~ /too long unix socket path/ && @sock_dir != Dir.tmpdir
-          logger.warn("Using tmp for ipc socket as path too long: #{@socket_path}")
-          @sock_dir = Dir.tmpdir
-          retry
-        end
-      end
-
-      begin
-        thread = Thread.new { run }
-        block.call(@socket_path)
-      ensure
-        @server.close
-        FileUtils.rm_f(@socket_path)
-        @server = nil
-      end
-    end
-
-    def generate_client_script
-      script_file = File.join(@sock_dir, 'atmos_ipc.rb')
-      File.write(script_file, <<~EOF
-        #!/usr/bin/env ruby
-        require 'socket'
-        UNIXSocket.open('#{@socket_path}') {|c| c.puts(ARGV[0] || $stdin.read); puts c.gets }
-      EOF
-      )
-      FileUtils.chmod('+x', script_file)
-      return script_file
-    end
-
-    private
-
-    def run
-      logger.debug("Starting ipc thread")
-      begin
-        while @server && sock = @server.accept
-          logger.debug("An ipc client connected")
-          line = sock.gets
-          logger.debug("Got ipc message: #{line.inspect}")
-          response = {}
-
-          begin
-            msg = JSON.parse(line)
-            msg = Hashie.symbolize_keys(msg)
-
-            # enabled by default if enabled is not set (e.g. from provisioner local-exec)
-            enabled = msg[:enabled].nil? ? true : ["true", "1"].include?(msg[:enabled].to_s)
-
-            if enabled
-              logger.debug("Dispatching IPC action")
-              response = dispatch(msg)
-            else
-              response[:message] = "IPC action is not enabled"
-              logger.debug(response[:error])
-            end
-          rescue => e
-            logger.log_exception(e, "Failed to parse ipc message")
-            response[:error] = "Failed to parse ipc message #{e.message}"
-          end
-
-          respond(sock, response)
-          sock.close
-        end
-      rescue IOError, EOFError, Errno::EBADF
-        nil
-      rescue Exception => e
-        logger.log_exception(e, "Ipc failure")
-      end
-    end
-
-    def close
-      @server.close if @server rescue nil
-    end
-
-    def load_action(name)
-      action = nil
-      logger.debug("Loading ipc action: #{name}")
-      begin
-        require "atmos/ipc_actions/#{name}"
-        action = "Atmos::IpcActions::#{name.camelize}".constantize
-        logger.debug("Loaded ipc action #{name}")
-      rescue LoadError, NameError => e
-        logger.log_exception(e, "Failed to load ipc action")
-      end
-      return action
-    end
-
-    def dispatch(msg)
-      response = {}
-      action = load_action(msg[:action])
-      if action.nil?
-        response[:error] = "Unsupported ipc action: #{msg.to_hash.inspect}"
-        logger.warn(response[:error])
-      else
-        begin
-          response = action.new().execute(**msg)
-        rescue => e
-          response[:error] = "Failure while executing ipc action: #{e.message}"
-          logger.log_exception(e, "Failure while executing ipc action")
-        end
-      end
-      return response
-    end
-
-    def respond(sock, response)
-      msg = JSON.generate(response)
-      logger.debug("Sending ipc response: #{msg.inspect}")
-      sock.puts(msg)
-      sock.flush
-    end
-
-  end
-end

data/lib/atmos/ipc_actions/notify.rb

@@ -1,27 +0,0 @@
-require_relative '../../atmos'
-require_relative '../../atmos/ui'
-
-module Atmos
-  module IpcActions
-    class Notify
-      include GemLogger::LoggerSupport
-      include Atmos::UI
-
-      def initialize()
-      end
-
-      def execute(**opts)
-
-        result = {
-            'stdout' => '',
-            'success' => ''
-        }
-
-        return result if Atmos.config["ipc.notify.disable"].to_s == "true"
-        return notify(**opts)
-
-      end
-
-    end
-  end
-end