upman-daemon 0.0.3

data/bin/upman

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+options = {:action => :run}
+
+options = {}
+version = "0.0.1"
+daemonize_help = "run daemonized in the background (default: true)"
+pidfile_help = "the pid filename (default: /var/run/upman.pid)"
+logfile_help = "the log filename (default: /var/log/upman.log)"
+include_help = "an additional $LOAD_PATH"
+debug_help = "set $DEBUG to true"
+warn_help = "enable warnings"
+
+op = OptionParser.new
+op.banner = "An example of how to daemonize upman."
+op.separator ""
+op.separator "Usage: upman [options]"
+op.separator ""
+
+op.separator "Process options:"
+op.on("-d", "--daemonize", daemonize_help) { options[:daemonize] = true }
+op.on("-p", "--pid PIDFILE", pidfile_help) { |value| options[:pidfile] = value }
+op.on("-l", "--log LOGFILE", logfile_help) { |value| options[:logfile] = value }
+op.separator ""
+
+op.separator "Ruby options:"
+op.on("-I", "--include PATH", include_help) { |value| $LOAD_PATH.unshift(*value.split(":").map { |v| File.expand_path(v) }) }
+op.on("--debug", debug_help) { $DEBUG = true }
+op.on("--warn", warn_help) { $-w = true }
+op.separator ""
+
+op.separator "Common options:"
+op.on("-h", "--help") { puts op.to_s; exit }
+op.on("-v", "--version") { puts version; exit }
+op.separator ""
+
+op.parse!(ARGV)
+require_relative '../lib/upman' unless options[:action] == :help
+
+case options[:action]
+when :help then
+  puts op.to_s
+when :version then
+  puts Upman::Core::Version.VERSION
+else
+  Upman.run!(options)
+end

data/lib/upman/core/config.rb

@@ -0,0 +1,34 @@
+module Upman
+  module Core
+    module Config
+      extend self
+      using SymbolizeHelper
+
+      @_config = {}
+      attr_reader :_config
+
+      def load!(filename, options = {})
+        newsets = YAML::load_file(filename).deep_symbolize_keys
+        newsets = newsets[options[:env].to_sym] if options[:env] && newsets[options[:env].to_sym]
+        deep_merge!(@_config, newsets)
+      end
+
+      def get!(key)
+        return @_config[key]
+      end
+
+      # Deep merging of hashes
+      # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
+      def deep_merge!(target, data)
+        merger = proc {|key, v1, v2|
+          Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2}
+        target.merge! data, &merger
+      end
+
+      def method_missing(name, *args, &block)
+        @_config[name.to_sym] ||
+            fail(NoMethodError, "unknown configuration root #{name}", caller)
+      end
+    end
+  end
+end

data/lib/upman/core/daemon.rb

@@ -0,0 +1,157 @@
+require 'fileutils'
+require 'thread'
+
+module Upman
+  module Core
+    class Daemon
+
+      include ::Upman::Utils::Helper
+
+      attr_reader :options, :quit
+
+      def initialize(options)
+        @options = options
+        options[:logfile] = File.expand_path(logfile) if logfile? # daemonization might change CWD so expand any relative paths in advance
+        options[:pidfile] = File.expand_path(pidfile) if pidfile? # (ditto)
+
+
+      end
+
+      def daemonize?
+        options[:daemonize]
+      end
+
+      def logfile
+        options[:logfile]
+      end
+
+      def pidfile
+        options[:pidfile]
+      end
+
+      def logfile?
+        !logfile.nil?
+      end
+
+      def pidfile?
+        !pidfile.nil?
+      end
+
+
+      #--------------------------------------------------------------------------
+
+      def run!
+
+        check_pid
+        daemonize if daemonize?
+        write_pid
+        trap_signals
+
+        if logfile?
+          redirect_output
+        elsif daemonize?
+          suppress_output
+        end
+
+        api = Upman::Utils::Api.new
+        unless api.check_connection
+          return nil
+        end
+
+        threads = []
+
+        Thread.abort_on_exception = true
+
+        threads << Thread.new do
+          server = Upman::Server::Socket.new
+          server.run!
+        end
+
+        threads << Thread.new do
+          worker = Upman::Core::Worker.new
+          worker.run!
+        end
+
+        trap("INT") do
+          warn "CTRL+C - Shutdown all threads"
+          threads.each { |t| Thread.kill t }
+          exit 130
+        end
+
+        threads.each { |t| t.join }
+
+      end
+
+      #==========================================================================
+      # DAEMONIZING, PID MANAGEMENT, and OUTPUT REDIRECTION
+      #==========================================================================
+
+      def daemonize
+        exit if fork
+        Process.setsid
+        exit if fork
+        Dir.chdir "/"
+      end
+
+      def redirect_output
+        FileUtils.mkdir_p(File.dirname(logfile), :mode => 0755)
+        FileUtils.touch logfile
+        File.chmod(0644, logfile)
+        $stderr.reopen(logfile, 'a')
+        $stdout.reopen($stderr)
+        $stdout.sync = $stderr.sync = true
+      end
+
+      def suppress_output
+        $stderr.reopen('/dev/null', 'a')
+        $stdout.reopen($stderr)
+      end
+
+      def write_pid
+        if pidfile?
+          begin
+            File.open(pidfile, ::File::CREAT | ::File::EXCL | ::File::WRONLY) {|f| f.write("#{Process.pid}")}
+            at_exit {File.delete(pidfile) if File.exists?(pidfile)}
+          rescue Errno::EEXIST
+            check_pid
+            retry
+          end
+        end
+      end
+
+      def check_pid
+        if pidfile?
+          case pid_status(pidfile)
+          when :running, :not_owned
+            puts "A server is already running. Check #{pidfile}"
+            exit(1)
+          when :dead
+            File.delete(pidfile)
+          end
+        end
+      end
+
+      def pid_status(pidfile)
+        return :exited unless File.exists?(pidfile)
+        pid = ::File.read(pidfile).to_i
+        return :dead if pid == 0
+        Process.kill(0, pid)
+        :running
+      rescue Errno::ESRCH
+        :dead
+      rescue Errno::EPERM
+        :not_owned
+      end
+
+      #==========================================================================
+      # SIGNAL HANDLING
+      #==========================================================================
+
+      def trap_signals
+        trap(:QUIT) do # graceful shutdown
+          @quit = true
+        end
+      end
+    end
+  end
+end

data/lib/upman/core/extension_base.rb

@@ -0,0 +1,15 @@
+module Upman
+  module Core
+    class ExtensionBase
+
+      include Upman::Utils::Helper
+
+      def register
+        fail "There is no register method defined in this extension."
+      end
+
+
+
+    end
+  end
+end

data/lib/upman/core/worker.rb

@@ -0,0 +1,38 @@
+module Upman
+  module Core
+    class Worker
+
+      include Upman::Utils::Helper
+
+      def initialize
+        @stop_signal = true
+      end
+
+      def run!
+        _banner
+        while @stop_signal
+          self.perform
+          sleep(::Upman::Core::Config.daemon[:interval])
+        end
+
+      end
+
+      def shutdown
+        info "Stopping working thread"
+        @stop_signal = false
+      end
+
+
+      def perform
+        info "Doing some work"
+      end
+
+      private
+
+      def _banner
+        info "Running UpMan"
+      end
+
+    end
+  end
+end

data/lib/upman/extensions/get_install_history.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Upman
+  module Extensions
+    # Get install history on debian system
+    class GetInstallHistory < ::Upman::Core::ExtensionBase
+      REQUEST_PATH = 'getInstallHistory'
+
+      def register
+        Servlet
+      end
+
+      # Servlet action for WEBrick
+      class Servlet < ::Upman::Server::BaseServlet
+
+        attr_accessor :param_since
+
+        # rubocop:disable Naming/MethodName
+        def do_GET(request, response)
+          # rubocop:enable Naming/MethodName
+
+          super(request, response)
+
+          unless (@param_since = get_param('since', 'date', false))
+            return nil
+          end
+
+          if (body = perform_action)
+            response = ok(response, body)
+          end
+        end
+
+        def perform_action
+          result = []
+          i = 0
+          hist_lines = fetch_history.split("\n")
+          hist_lines.each do |history|
+            fill_up(result, i, hist_lines, history) if i.even?
+            i += 1
+          end
+          result.to_json
+        end
+
+        private
+
+        def fetch_history
+          command = '(zcat $(ls -tr /var/log/apt/history.log*.gz); '\
+                    'cat /var/log/apt/history.log) ' \
+                    '2>/dev/null | egrep \'^(Start-Date:|Commandline:)\' | '\
+                    'grep -v aptdaemon'
+          `#{command}`
+        end
+
+        def fill_up(result, line_index, hist_lines, history)
+          line = hist_lines[line_index + 1].sub('Commandline: ', '')
+          command = parse_command(line)
+          return nil if command.empty?
+
+          command[:start_date] = DateTime.parse(history.sub('Start-Date: ', ''))
+
+          if @param_since.instance_of?(Date)
+            if command[:start_date] >= @param_since
+              result.append command
+            end
+          else
+            result.append command
+          end
+        end
+
+        def parse_command(command_line)
+          package = {}
+          regexp = /(apt(-get)?)(( [\-\w]*)*) (install|upgrade|purge)(.*)?/
+          if (matches = command_line.match(regexp))
+            package[:action] = matches[5].strip
+
+            package[:options] = []
+            matches[3].split(' ').each { |name| package[:options].append name }
+
+            package[:packages] = []
+            matches[6].split(' ').each { |name| package[:packages].append name }
+          end
+          package
+        end
+      end
+    end
+  end
+end

data/lib/upman/extensions/get_installed_packages.rb

@@ -0,0 +1,49 @@
+module Upman
+  module Extensions
+    class GetInstalledPackages < ::Upman::Core::ExtensionBase
+      REQUEST_PATH = "getInstalledPackages"
+
+      def register
+        return Servlet
+      end
+
+      class Servlet < ::Upman::Server::BaseServlet
+
+        attr_accessor :requested
+
+        include ::Upman::Utils::Parser
+
+        # rubocop:disable Naming/MethodName
+        def do_GET(request, response)
+          # rubocop:enable Naming/MethodName
+
+          super(request, response)
+
+          @requested = get_param('requested', 'int')
+
+          if (body = perform_action)
+            response = ok(response, body)
+          end
+        end
+
+        def perform_action
+          result = []
+          extended_states = File.open('/var/lib/apt/extended_states', 'rb', &:read)
+          extended_states.split("\n\n").each do |chunk|
+            installed_packages = _get_hashed_values(chunk)
+            unless @requested.empty?
+              if installed_packages['auto_installed'] == @requested
+                result.append installed_packages
+              end
+            else
+              result.append installed_packages
+            end
+
+          end
+          result.to_json
+        end
+
+      end
+    end
+  end
+end

data/lib/upman/extensions/install_package.rb

@@ -0,0 +1,26 @@
+module Upman
+  module Extensions
+    class InstallPackage < ::Upman::Core::ExtensionBase
+
+      REQUEST_PATH = "installPackage"
+
+      def register
+        return Servlet
+      end
+
+      class Servlet < WEBrick::HTTPServlet::AbstractServlet
+        def do_GET request, response
+          response.status = 200
+          response['Content-Type'] = 'application/json'
+          response.body = self.perform_action
+        end
+
+
+        def perform_action
+          "installPackage"
+        end
+      end
+
+    end
+  end
+end

data/lib/upman/extensions/ping.rb

@@ -0,0 +1,28 @@
+module Upman
+  module Extensions
+    class Ping < ::Upman::Core::ExtensionBase
+     REQUEST_PATH = "ping"
+
+     def register
+       return Servlet
+     end
+
+     class Servlet < ::Upman::Server::BaseServlet
+
+       # rubocop:disable Naming/MethodName
+       def do_GET(request, response)
+         # rubocop:enable Naming/MethodName
+
+         super(request, response)
+
+         response = ok(response, perform_action)
+       end
+
+       def perform_action
+          "{\"pong\": true, \"message\": \"upman-#{::Upman::Version::VERSION} - Daemon is running\"}"
+        end
+      end
+
+    end
+  end
+end

data/lib/upman/server/base_servlet.rb

@@ -0,0 +1,65 @@
+module Upman
+  module Server
+    class BaseServlet < WEBrick::HTTPServlet::AbstractServlet
+
+      include ::Upman::Utils::Helper
+
+      attr_accessor :query, :response, :error_msg
+
+      def initialize(server, *options)
+        super(server, *options)
+      end
+
+      # rubocop:disable Naming/MethodName
+      def do_GET(_request, response)
+        # rubocop:enable Naming/MethodName
+
+        info "Process API request #{_request.path}"
+
+        @response = response
+        @query = _request.query
+      end
+
+      def ok(response, body)
+        response.status = 200
+        response['Content-Type'] = 'application/json'
+        response.body = body
+        response
+      end
+
+      def bad_request(response, body)
+        response.status = 400
+        response['Content-Type'] = 'application/json'
+        response.body = "{\"status\": \"bad_request\", \"message\": \"#{body}\"}"
+        response
+      end
+
+      def get_param(key, validate, require = false)
+        if @query.nil?
+          return ''
+        end
+
+        unless @query.include? key
+          unless require
+            return ''
+          else
+            return nil
+          end
+        end
+        unless validate.nil?
+          if validate == 'date'
+            begin
+              @query[key] = DateTime.parse(@query[key])
+            rescue
+              msg = "Invalid content for param #{key}, expected type: date - found #{@query[key]}"
+              bad_request(@response, msg)
+              fail msg
+              return false
+            end
+          end
+        end
+        @query[key]
+      end
+    end
+  end
+end

data/lib/upman/server/socket.rb

@@ -0,0 +1,66 @@
+require 'openssl'
+require 'webrick'
+require 'webrick/https'
+
+module Upman
+  module Server
+    class Socket
+
+      include ::Upman::Utils::Helper
+
+      include WEBrick
+
+      attr_reader :server
+
+      def initialize
+        @config = ::Upman::Core::Config.daemon
+
+      end
+
+      def run!
+
+        server = HTTPServer.new(
+            BindAddress: @config[:listen],
+            :Port => @config[:port],
+            :SSLEnable => @config[:ssl],
+            :debugger => false,
+            :daemonize => true,
+            :SSLPrivateKey => OpenSSL::PKey::RSA.new(
+                File.open(@config[:key]).read),
+            :SSLCertificate => OpenSSL::X509::Certificate.new(
+                File.open(@config[:cert]).read),
+            :SSLCertName => [["CN", WEBrick::Utils::getservername]],
+            Logger: WEBrick::Log.new("/dev/null"),
+            AccessLog: [],
+        )
+        _register_extensions(server)
+
+        protocol = @config[:ssl] ? 'https://' : 'http://'
+        info "Starting listener on #{protocol}#{@config[:listen]}:#{@config[:port]}"
+
+        server.start
+
+      end
+
+      private
+
+      def _dynload(str)
+        str.split('::').inject(Object) do |mod, class_name|
+          mod.const_get(class_name)
+        end
+      end
+
+
+      def _register_extensions(server)
+
+        @config[:extensions].each do |extension|
+          require_relative "../../upman/extensions/#{extension}"
+          ext_obj  = _dynload("Upman::Extensions::#{extension.split('_').map(&:capitalize).join('')}")
+          info "Register /#{ext_obj ::REQUEST_PATH}.do for Upman::Extensions::#{extension.split('_').map(&:capitalize).join('')}"
+          ext_class = ext_obj .new
+          server.mount "/#{ext_obj ::REQUEST_PATH}.do", ext_class.register
+        end
+      end
+    end
+  end
+end

data/lib/upman/utils/api.rb

@@ -0,0 +1,61 @@
+require 'rest-client'
+require 'json'
+
+module Upman
+  module Utils
+    class Api
+
+      include ::Upman::Utils::Helper
+
+      def check_connection
+        response = self.get "status"
+        if response.nil?
+           false
+        end
+
+        unless response.code == 200
+          fail "Could not connect to API endpoint"
+          false
+        end
+        success "API Endpoint connected to Forman #{JSON.parse(response.body)["version"]} using API v#{JSON.parse(response.body)["api_version"]}."
+        true
+      end
+
+
+      def post(api_endoint, data)
+        begin
+          RestClient::Request.execute method: :post, url: _url + api_endoint, data: data, content_type: :json, accept: :json, user: Upman::Core::Config.foreman_api[:username], password: Upman::Core::Config.foreman_api[:password]
+        rescue RestClient::Unauthorized
+          fail "API Endpoint could not validate your credentials. Please check username or password"
+        rescue OpenSSL::SSL::SSLError
+          fail "Could not establish a secure connection to our API Endpoint"
+        rescue RestClient::NotFound
+          fail "API Endpoint route could not found"
+        rescue Errno::ECONNREFUSED
+          fail "Can not connect to Foreman instance on #{_url}"
+        end
+
+      end
+
+      def get(api_endoint)
+        begin
+          RestClient::Request.execute method: :get, url: _url + api_endoint, content_type: :json, accept: :json, user: Upman::Core::Config.foreman_api[:username], password: Upman::Core::Config.foreman_api[:password]
+        rescue RestClient::Unauthorized
+          fail "API Endpoint could not validate your credentials. Please check username or password"
+        rescue OpenSSL::SSL::SSLError
+          fail "Could not establish a secure connection to our API Endpoint"
+        rescue RestClient::NotFound
+          fail "API Endpoint route could not found"
+        rescue Errno::ECONNREFUSED
+          fail "Can not connect to your Foreman instance on #{_url}"
+        end
+      end
+
+      def _url
+        config = ::Upman::Core::Config.foreman_api
+        protocol = config[:ssl] ? 'https://' : 'http://'
+        "#{protocol}#{config[:host]}:#{config[:port]}/api/v#{config[:api_version]}/"
+      end
+    end
+  end
+end

data/lib/upman/utils/files.rb

@@ -0,0 +1,7 @@
+module Upman
+  module Utils
+    class Files
+
+    end
+  end
+end