uberinstaller 1.0.0

data/lib/uberinstaller/logger.rb

@@ -0,0 +1,113 @@
+# -*- encoding: utf-8 -*-
+
+require 'colored'
+require 'logger'
+
+module Uberinstaller
+
+  # Handle application log
+  module Loggable
+    # @!attribute [r] loggers
+    #   Hash of available loggers ( one for class in which logger is invoked )
+    @loggers = {}
+    # @!attribute [rw] log_path
+    #   Path in which log files are saved ( default STDOUT )
+    @log_path = STDOUT
+    # @!attribute [rw] level
+    #   Log level. Can be one of Logger::DEBUG, Logger::INFO, Logger::WARN, Logger::ERROR ( default Logger::ERROR )
+    @level = Logger::ERROR
+
+    # Global, memoized, lazy initialized instance of a logger
+    #
+    # This is the magical bit that gets mixed into your classes. Respond to Logger function.
+    # 
+    # @return [Object] an instance of the logger class
+    def logger
+      classname = (self.is_a? Module) ? self : self.class.name
+      @logger ||= Loggable.logger_for(classname)
+    end
+
+    class << self
+      # @!attribute [rw] level
+      #   Log output level. Can be one of Logger::DEBUG, Logger::INFO, Logger::WARN, Logger::ERROR ( default Logger::ERROR )
+      # @!attribute [rw] log_path
+      #   Path in which log files are saved ( default STDOUT )
+      attr_accessor :level, :log_path
+      
+      # Return the logger for a specific Class. If the instance is not found, creates it.
+      #
+      # @param classname [String] the name of the class for which a logger instance must be retrieved
+      # @return [Object] the instance of the logger class for the specified Class
+      def logger_for(classname)
+        @loggers[classname] ||= configure_logger_for(classname)
+      end
+
+      # Create and configure a logger for the specified Class
+      #
+      # @param classname [String] the name of the class for which a logger instance must be retrieved
+      # @return [Object] the instance of the logger class for the specified Class
+      def configure_logger_for(classname)
+        # handle case in which log path does not exists
+        begin
+          logger = Logger.new(@log_path)
+        rescue Errno::ENOENT
+          FileUtils.mkdir_p File.dirname @log_path
+          retry
+        end
+
+        logger.progname = classname
+        logger.level = @level
+        logger.formatter = proc { |severity, datetime, progname, msg|
+          case severity
+          when 'DEBUG'
+            spaciator = "    *"
+            after_space = ""
+            colored = "white"
+            extra = ""
+          when 'INFO'
+            spaciator = "   **"
+            after_space = " "
+            colored = ""
+            extra = ""
+          when 'WARN'
+            spaciator = "  ***"
+            after_space = " "
+            colored = "yellow"
+            extra = ""
+          when 'ERROR'
+            spaciator = " ****"
+            after_space = ""
+            colored = "red"
+            extra = ""
+          when 'FATAL'
+            spaciator = "*****"
+            after_space = ""
+            colored = "red"
+            extra = "bold"
+          else
+            spaciator = "     "
+            after_space = ""
+            colored = ""
+            extra = ""
+          end
+
+          formatted_output = " #{spaciator} [#{severity}]#{after_space} [#{datetime}] -- #{msg} { #{progname} }\n"
+          if @log_path == STDOUT or @log_path == STDERR
+            if colored.empty? 
+              formatted_output
+            else
+              if extra.empty?
+                formatted_output.send(colored)
+              else
+                formatted_output.send(colored).send(extra)
+              end
+            end
+          else
+            formatted_output
+          end
+        }
+        logger
+      end
+    end
+  end
+end

data/lib/uberinstaller/package_manager.rb

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+require 'uberinstaller/config'
+require 'uberinstaller/logger'
+
+module Uberinstaller
+  module PackageManager
+
+    # Create a new PackageManager instance based on the type
+    #
+    # @param type [String] the type of package manager to create instance for
+    def self.new(type)
+      case type
+      when 'git'    then package_manager = 'Git'
+      when 'local'  then package_manager = Uberinstaller::Config.local_package_manager
+      when 'remote' then package_manager = Uberinstaller::Config.remote_package_manager
+      end
+
+      ("Uberinstaller::PackageManager::" + package_manager).split('::').inject(Object) {|scope,name| scope.const_get(name)}.new
+    end
+  end
+end
+
+require 'uberinstaller/package_managers/base'
+require 'uberinstaller/package_managers/apt'
+require 'uberinstaller/package_managers/dpkg'
+require 'uberinstaller/package_managers/git'

data/lib/uberinstaller/package_managers/apt.rb

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+require 'uberinstaller/package_manager'
+
+module Uberinstaller
+  module PackageManager
+    # Apt-Get Package manager
+    class Apt < Base
+
+      def set_commands
+        @commands[:add_repository] = "apt-add-repository -y" 
+        @commands[:install] = "DEBIAN_FRONTEND=gnome apt-get install -y" 
+        @commands[:update] = "apt-get update" 
+        @commands[:upgrade] = "apt-get upgrade" 
+      end
+    end
+  end
+end

data/lib/uberinstaller/package_managers/base.rb

@@ -0,0 +1,87 @@
+# -*- encoding: utf-8 -*-
+
+require 'uberinstaller/config'
+require 'uberinstaller/logger'
+
+require 'open3'
+
+module Uberinstaller
+  module PackageManager
+    class Base
+      include Loggable
+
+      attr_reader :commands
+
+      # Create the package manager
+      def initialize
+        @commands = Hash.new
+        @commands = {
+          :add_repository => nil,
+          :info => nil,
+          :install => nil,
+          :search => nil,
+          :update => nil,
+          :upgrade => nil
+        }
+
+        set_commands
+      end
+
+      # This method is a stub, here only for reference
+      #
+      # In every subclass of PackageManager::Base this method must be redefined
+      # specifying the package manager specific command ( see Apt and Dpkg for
+      # example )
+      def set_commands; end
+
+      # Print to log for debug purposes
+      #
+      # @param action [String] the action that is being performed
+      # @param args [Array] an array of arguments for the specified action
+      def debug(action, args = [])
+        logger.debug "action : #{action}"
+        logger.debug "args   : #{args.join(', ')}" unless args.empty?
+        logger.debug "command: #{make_command(action, args)}"
+      end
+
+      # Creates a command putting together action and arguments
+      #
+      # @param action [String] the action that is being performed
+      # @param args [Array] an array of arguments for the specified action
+      def make_command(action, args = [])
+        command = @commands[action.to_sym]
+        command += " '" + args.join(' ') + "'" unless args.empty?
+
+        command
+      end
+
+      # All execution is handled dinamically via this function
+      #
+      # If the method called is in the @commands Hash, the specified action is
+      # performed, otherwise a NoMethodError exception
+      #
+      # @raise [NoMethodError] if the method specified is not available
+      def method_missing(m, *args, &block)
+        if @commands.has_key? m
+          debug m, args
+
+          unless Config.dry_run
+            Open3.popen3(make_command(m, args)) { |stdin, stdout, stderr, wait_thr|
+              pid = wait_thr.pid # pid of the started process.
+              logger.debug "Running pid: #{pid}"
+
+              logger.debug stdout.readlines
+
+              exit_status = wait_thr.value.to_i # Process::Status object returned.
+              logger.debug "Exit status: #{exit_status}"
+              logger.error 'Some error happended during execution:' unless exit_status == 0
+              logger.error stderr.readlines unless exit_status == 0
+            }
+          end
+        else
+          raise NoMethodError
+        end
+      end  
+    end
+  end
+end

data/lib/uberinstaller/package_managers/dpkg.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+require 'uberinstaller/package_manager'
+
+module Uberinstaller
+  module PackageManager
+    # Dpkg package manager
+    class Dpkg < Base
+
+      def set_commands
+        @commands[:install] = "dpkg -i"
+      end
+    end
+  end
+end

data/lib/uberinstaller/package_managers/git.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+require 'uberinstaller/package_manager'
+
+module Uberinstaller
+  module PackageManager
+    # Git package manager ( a little bit of a hack really )
+    class Git < Base
+
+      def set_commands
+        @commands[:install] = "git clone" 
+      end
+    end
+  end
+end

data/lib/uberinstaller/parser.rb

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+
+require 'uberinstaller/logger'
+require 'uberinstaller/exception'
+
+require 'json'
+
+module Uberinstaller
+  class Parser
+    include Loggable
+
+    # @!attribute [rw] file
+    #   the file to be parsed
+    # @!attribute [r] data
+    #   an Hash containing data after parsing
+    attr_accessor :file
+    attr_reader :data
+
+    # Create the parser
+    def initialize(file, perform_parse = true)
+      if File.exists?(file)
+        @file = file
+      else
+        raise Uberinstaller::Exception::ParserArgumentError, file
+      end
+
+      @json = nil
+      @data = nil
+
+      run if perform_parse
+      self
+    end
+
+    def debug
+      @json
+    end
+
+    def run
+      begin
+        @json = IO.read(@file)
+        # Comments are stripped out! FUCK YEAH!
+        @data = JSON.parse @json, :symbolize_names => true
+      rescue JSON::ParserError
+        raise Uberinstaller::Exception::JsonParseError, @file
+      else
+        @data
+      end
+    end
+
+  end
+end

data/lib/uberinstaller/platform.rb

@@ -0,0 +1,103 @@
+# -*- encoding: utf-8 -*-
+
+require 'uberinstaller/logger'
+
+require 'hash_keyword_args'
+
+module Uberinstaller
+  # http://stackoverflow.com/questions/170956/how-can-i-find-which-operating-system-my-ruby-program-is-running-on
+  class Platform
+    include Loggable
+
+    # @!attribute [r] architecture
+    #   OS architecture information
+    # @!attribute [r] lsb
+    #   LSB module information
+    # @!attribute [r] uname
+    #   `uname` calls results
+    attr_reader :architecture, :lsb, :uname
+    
+    # Get platform, detect ubuntu, detect ubuntu version, save lsb params
+    # 
+    # @param opts [Hash]
+    #  :lsb => the file containing LSB information
+    def initialize(opts = {})
+      @opts = opts.keyword_args(:lsb => '/etc/lsb-release')
+      
+      @lsb = nil
+      @uname = nil
+      
+      get_lsb_informations
+      get_arch_informations
+
+      @architecture = @uname[:machine]
+    end
+
+    # Check if platform is Ubuntu
+    def is_ubuntu?
+      return @lsb[:id] == 'Ubuntu' if @lsb[:id]
+      logger.fatal 'lsb is not set, impossible to get OS information'
+      false
+    end
+
+    # Reverse of is_ubuntu?
+    def is_not_ubuntu?
+      !is_ubuntu?
+    end
+
+    # Reverse of is_64bit?
+    def is_32bit?
+      !is_64bit?
+    end
+
+    # Check if system is running 64 bit OS
+    def is_64bit?
+      return @uname[:machine] == 'x86_64' if @uname[:machine]
+      logger.fatal 'uname is not set, impossible to get machine information'
+      false
+    end
+
+    private
+      # Detect OS architecture information
+      #
+      # Using a call to `uname` try to detect architecture informations.
+      # `uname` must be available on the system
+      def get_arch_informations
+        @uname ||= Hash.new
+        IO.popen 'uname -m' do |io| @uname[:machine] = io.read.strip end
+        IO.popen 'uname -n' do |io| @uname[:host] = io.read.strip end
+        IO.popen 'uname -srv' do |io| @uname[:kernel] = io.read.strip end
+      end
+
+      # Get OS information from LSB
+      #
+      # LSB must be aavailable on the system
+      def get_lsb_informations
+        # http://stackoverflow.com/a/1236075/715002
+        IO.popen "cat #{@opts.lsb}" do |io|
+          io.each do |line|
+            unless line.include? 'cat:' # check for error
+              @lsb ||= Hash.new
+
+              if line.include? 'DISTRIB_ID'
+                @lsb[:id] = get_lsb_value line
+              elsif line.include? 'DISTRIB_RELEASE'
+                @lsb[:release] = get_lsb_value line
+              elsif line.include? 'DISTRIB_CODENAME'
+                @lsb[:codename] = get_lsb_value line
+              elsif line.include? 'DISTRIB_DESCRIPTION'
+                @lsb[:description] = get_lsb_value line
+              end
+            else
+              logger.fatal "Platform has no #{@opts.lsb}, so it is not supported"
+            end
+          end
+        end
+      end
+
+      # Handy method to retrieve values from LSB pairs
+      def get_lsb_value(string)
+        string.split('=')[1].strip
+      end
+  end
+end

data/lib/uberinstaller/runner.rb

@@ -0,0 +1,218 @@
+# -*- encoding: utf-8 -*-
+
+require 'uberinstaller/logger'
+
+module Uberinstaller
+  class Runner
+    include Loggable
+
+    # @!attribute [r] packages
+    #   the list of packages after configuration file is parsed
+    # @!attribute [r] parser
+    #   the parser class used to parse configuration file
+    # @!attribute [r] platform
+    #   the platform on which UberInstaller is running
+    # @!attribute [r] unprocessed
+    #   check if the execution has already been done
+    attr_reader :packages, :parser, :platform, :unprocessed
+
+    # Initialize the Runner class
+    #
+    # @param file [String] the file name to be used for this execution
+    def initialize(file)
+      logger.info "Processing JSON file: #{file}"
+      
+      # check if element has already been processed
+      @unprocessed = true
+
+      @parser = Parser.new file
+      
+      @platform = Platform.new
+
+      logger.warn "Platform is not Ubuntu, please report any inconvenient behaviour" unless platform.is_ubuntu?
+      
+      verify_architecture
+      verify_os_version
+
+      # This dummy commander is used to launch before all and after all scripts
+      @global_commander = Commander.new("Dummy package", { :cmd => { :after => "all.sh", :before => "all.sh" }})
+
+      @packages = parser.data[:packages]
+
+      get_nested_json
+    end
+
+    def install
+      logger.info 'Installing packages...'
+
+      @packages.each do |p|
+        pkg_name = p[0].to_s
+        pkg = p[1]
+
+        installer = Installer.new(pkg_name, pkg)
+        commander = Commander.new(pkg_name, pkg)
+
+        logger.info "Installing #{pkg_name}"
+
+        commander.before
+
+        case pkg[:type]
+        when 'system'
+          begin 
+            installer.install 'system'
+          rescue Exception => e
+            logger.error e.message
+
+            pkg[:errors] = Array.new # add array to store errors
+            pkg[:errors] << e.message
+          end
+        when 'git'
+          begin
+            installer.install 'git'
+          rescue Exception => e
+            logger.error e.message
+            
+            pkg[:errors] = Array.new # add array to store errors
+            pkg[:errors] << e.message
+          end
+        when 'local'
+          begin
+            installer.install 'local'
+          rescue Exception::MultipleLocalFilesNotSupported => e
+            logger.error e.message
+            
+            pkg[:errors] = Array.new # add array to store errors
+            pkg[:errors] << e.message
+          end
+        else
+          logger.error "#{pkg_name} :type is not supported"
+        end
+
+        commander.after
+      end
+
+      logger.info 'Executing after all commands...'
+      @global_commander.after
+    end
+
+    # Preprocess all packages performing validation
+    def preprocess
+      logger.info 'Executing before all commands...'
+      @global_commander.before
+
+      logger.info 'Preprocessing packages...'
+      @packages.each do |p|
+        pkg_name = p[0].to_s
+        pkg = p[1]
+
+        logger.info "Package: #{pkg_name}"
+        logger.debug "Package content: #{pkg}"
+
+        # set pkg installation type based on existing key in the package definition
+        pkg[:type] = get_package_type pkg
+
+        installer = Installer.new(pkg_name, pkg)
+
+        case pkg[:type]
+        when 'system'
+          begin 
+            installer.preprocess 'system'
+          rescue Exception::InvalidPackage, Exception::InvalidPpa => e
+            logger.error e.message
+
+            pkg[:skip] = true
+            pkg[:errors] = Array.new # add array to store errors
+            pkg[:errors] << e.message
+          end
+        when 'git'
+          begin
+            installer.preprocess 'git'
+          rescue Exception::InvalidFolder, Exception::MissingUrl, Exception::InvalidUrl => e
+            logger.error e.message
+            
+            pkg[:skip] = true
+            pkg[:errors] = Array.new # add array to store errors
+            pkg[:errors] << e.message
+          end
+        when 'local'
+          begin
+            installer.preprocess 'local'
+          rescue Exception::MissingLocalPackage, Exception::InvalidLocalPackage => e
+            logger.error e.message
+            
+            pkg[:skip] = true
+            pkg[:errors] = Array.new # add array to store errors
+            pkg[:errors] << e.message
+          end
+        else
+          logger.error "#{pkg_name} :type is not supported"
+        end
+      end
+
+      PackageManager.new('remote').update
+    end
+
+    # Verify that platform architecture match the one specified in the config file
+    #
+    # @raise [Exception::WrongArchitecture] if the architecture do not match configuration file
+    def verify_architecture
+      if parser.data[:meta][:arch]
+        unless parser.data[:meta][:arch] == 'system'
+          logger.debug 'Verifying architecture...'
+
+          unless parser.data[:meta][:arch] == platform.architecture
+            raise Exception::WrongArchitecture, parser.data[:meta][:arch]
+          else
+            logger.info "Architecture match installation file requirements"
+          end
+        end
+      else
+        logger.warn "Installation file does not specify a required architecture"
+      end
+    end
+
+    # Verify that the OS version match the one specified in the config file
+    #
+    # @raise [Exception::WrongVersion] if the version do not match
+    def verify_os_version
+      raise Exception::WrongVersion, parser.data[:meta][:version] unless parser.data[:meta][:version] == platform.lsb[:codename]
+    end
+
+    private
+      def get_nested_json
+        nested_packages = Hash.new
+
+        @packages.each do |p|
+          pkg_name = p[0].to_s
+          pkg = p[1]
+
+          if pkg.has_key? :json
+            installer = Installer.new(pkg_name, pkg)
+
+            begin
+              installer.preprocess 'json'
+            rescue Exception::JsonFileNotFound, Exception::InvalidJson => e
+              logger.error e.message
+
+              pkg[:skip] = true
+              pkg[:errors] = Array.new # add array to store errors
+              pkg[:errors] << e.message
+            else
+              file = File.join Config.json_path, pkg[:json] + '.json'
+              parser = Parser.new(file)
+              data = parser.data[:packages].each { |p| p[1][:type] = get_package_type p[1] }
+              nested_packages.merge! data
+            end
+          end
+        end
+
+        @packages.merge! nested_packages
+      end
+
+      def get_package_type(pkg)
+        return 'system' if pkg.has_key? :system
+        return 'git' if pkg.has_key? :git
+        return 'local' if pkg.has_key? :local
+      end
+  end
+end