simplygenius-atmos 0.7.1 → 0.8.0

data/lib/simplygenius/atmos/ipc.rb

@@ -0,0 +1,136 @@
+require_relative '../atmos'
+require 'fileutils'
+require 'hashie'
+
+module SimplyGenius
+  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 "simplygenius/atmos/ipc_actions/#{name}"
+          action = "SimplyGenius::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
+end

data/lib/simplygenius/atmos/ipc_actions/notify.rb

@@ -0,0 +1,31 @@
+require_relative '../../atmos'
+require_relative '../../atmos/ui'
+
+module SimplyGenius
+  module Atmos
+    module IpcActions
+
+      class Notify
+        include GemLogger::LoggerSupport
+        include 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
+end

data/lib/simplygenius/atmos/ipc_actions/ping.rb

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

data/lib/simplygenius/atmos/logging.rb

@@ -0,0 +1,164 @@
+require 'logging'
+require 'gem_logger'
+require 'rainbow'
+require 'delegate'
+
+module SimplyGenius
+  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 = 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
+end

data/lib/simplygenius/atmos/otp.rb

@@ -0,0 +1,62 @@
+require_relative '../atmos'
+require 'singleton'
+require 'rotp'
+
+module SimplyGenius
+  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
+end

data/lib/simplygenius/atmos/plugin.rb

@@ -0,0 +1,27 @@
+require_relative '../atmos'
+require 'active_support/core_ext/class'
+
+Dir.glob(File.join(File.join(__dir__, 'plugins'), '*.rb')) do |f|
+  require_relative "plugins/#{File.basename(f).sub(/\.rb$/, "")}"
+end
+
+module SimplyGenius
+  module Atmos
+
+    class Plugin
+      include GemLogger::LoggerSupport
+
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      def register_output_filter(type, clazz)
+        Atmos.config.plugin_manager.register_output_filter(type, clazz)
+      end
+
+    end
+
+  end
+end