simplygenius-atmos 0.7.0

data/lib/atmos/generator_factory.rb

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,27 @@
+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

data/lib/atmos/ipc_actions/ping.rb

@@ -0,0 +1,19 @@
+require_relative '../../atmos'
+require 'open3'
+require 'os'
+
+module Atmos
+  module IpcActions
+    class Ping
+      include GemLogger::LoggerSupport
+
+      def initialize()
+      end
+
+      def execute(**opts)
+        return opts.merge(action: 'pong')
+      end
+
+    end
+  end
+end

data/lib/atmos/logging.rb

@@ -0,0 +1,160 @@
+require 'logging'
+require 'gem_logger'
+require 'rainbow'
+require 'delegate'
+
+module Atmos
+  module Logging
+
+    module GemLoggerConcern
+      extend ActiveSupport::Concern
+
+      def logger
+        ::Logging.logger[self.class]
+      end
+
+      module ClassMethods
+        def logger
+          ::Logging.logger[self]
+        end
+      end
+    end
+
+    class CaptureStream < SimpleDelegator
+
+      def initialize(logger_name, appender, stream, color=nil)
+        super(stream)
+        @color = stream.tty? && color ? color : nil
+        @logger = ::Logging.logger[logger_name]
+        @logger.appenders = [appender]
+        @logger.additive = false
+      end
+
+      def strip_color(str)
+        str.gsub(/\e\[\d+m/, '')
+      end
+
+      def write(data)
+        @logger.info(strip_color(data))
+        if @color
+          count = 0
+          d = data.lines.each do |l|
+            cl = Kernel.send(:Rainbow, l).send(@color)
+            count += super(cl)
+          end
+          return count
+        else
+          return super(data)
+        end
+      end
+    end
+
+    def self.init_logger
+      return if @initialized
+      @initialized = true
+
+      ::Logging.format_as :inspect
+      ::Logging.backtrace true
+
+      ::Logging.color_scheme(
+          'bright',
+          lines: {
+              debug: :green,
+              info: :default,
+              warn: :yellow,
+              error: :red,
+              fatal: [:white, :on_red]
+          },
+          date: :blue,
+          logger: :cyan,
+          message: :magenta
+      )
+
+      ::Logging.logger.root.level = :info
+      GemLogger.configure do |config|
+        config.default_logger = ::Logging.logger.root
+        config.logger_concern = Atmos::Logging::GemLoggerConcern
+      end
+    end
+
+
+    def self.testing
+      @t
+    end
+
+    def self.testing=(t)
+      @t = t
+    end
+
+    def self.sio
+      ::Logging.logger.root.appenders.find {|a| a.name == 'sio' }
+    end
+
+    def self.contents
+      sio.try(:sio).try(:to_s)
+    end
+
+    def self.clear
+      sio.try(:clear)
+    end
+
+    def self.setup_logging(debug, color, logfile)
+      init_logger
+
+      ::Logging.logger.root.level = debug ? :debug : :info
+      appenders = []
+      detail_pattern = '[%d] %-5l %c{2} %m\n'
+      plain_pattern = '%m\n'
+
+      pattern_options = {
+          pattern: plain_pattern
+      }
+      if color
+        pattern_options[:color_scheme] = 'bright'
+      end
+
+      if self.testing
+
+        appender = ::Logging.appenders.string_io(
+            'sio',
+            layout: ::Logging.layouts.pattern(pattern_options)
+        )
+        appenders << appender
+
+      else
+
+        appender = ::Logging.appenders.stdout(
+            'stdout',
+            layout: ::Logging.layouts.pattern(pattern_options)
+        )
+        appenders << appender
+
+      end
+
+      # Do this after setting up stdout appender so we don't duplicate output
+      # to stdout with our capture
+      if logfile.present?
+
+        appender = ::Logging.appenders.file(
+            logfile,
+            truncate: true,
+            layout: ::Logging.layouts.pattern(pattern: detail_pattern)
+        )
+        appenders << appender
+
+        if ! $stdout.is_a? CaptureStream
+          $stdout = CaptureStream.new("stdout", appender, $stdout)
+          $stderr = CaptureStream.new("stderr", appender, $stderr, :red)
+          silence_warnings {
+            Object.const_set(:STDOUT, $stdout)
+            Object.const_set(:STDERR, $stderr)
+          }
+        end
+
+      end
+
+      ::Logging.logger.root.appenders = appenders
+    end
+
+  end
+end

data/lib/atmos/otp.rb

@@ -0,0 +1,61 @@
+require_relative '../atmos'
+require 'singleton'
+require 'rotp'
+
+module Atmos
+
+  class Otp
+    include Singleton
+    include GemLogger::LoggerSupport
+
+    def initialize
+      @secret_file = Atmos.config["otp.secret_file"] || "~/.atmos.yml"
+      @secret_file = File.expand_path(@secret_file)
+      yml_hash = YAML.load_file(@secret_file) rescue Hash.new
+      @secret_store = SettingsHash.new(yml_hash)
+      @secret_store[Atmos.config[:org]] ||= {}
+      @secret_store[Atmos.config[:org]][:otp] ||= {}
+      @scoped_secret_store = @secret_store[Atmos.config[:org]][:otp]
+    end
+
+    def add(name, secret)
+      old = @scoped_secret_store[name]
+      logger.info "Replacing OTP secret #{name}=#{old}" if old
+      @scoped_secret_store[name] = secret
+    end
+
+    def remove(name)
+      old = @scoped_secret_store.delete(name)
+      @otp.try(:delete, name)
+      logger.info "Removed OTP secret #{name}=#{old}" if old
+    end
+
+    def save
+      File.write(@secret_file, YAML.dump(@secret_store.to_hash))
+      File.chmod(0600, @secret_file)
+    end
+
+    def generate(name)
+      otp(name).try(:now)
+    end
+
+    private
+
+    def otp(name)
+      @otp ||= {}
+      @otp[name] ||= begin
+        secret =  @scoped_secret_store[name]
+        totp = nil
+        if secret
+          totp = ROTP::TOTP.new(secret)
+        else
+          logger.debug "OTP secret does not exist for '#{name}'"
+        end
+        totp
+      end
+    end
+
+  end
+
+end
+