cuboid 0.0.0 → 0.0.1alpha

data/lib/cuboid/system/slots.rb

@@ -0,0 +1,143 @@
+module Cuboid
+
+class System
+class Slots
+
+    def initialize( system )
+        @system = system
+        @pids   = Set.new
+    end
+
+    def reset
+        @pids.clear
+    end
+
+    def use( pid )
+        @pids << pid
+        pid
+    end
+
+    # @return   [Integer]
+    #   Amount of new scans that can be safely run in parallel, currently.
+    #   User option will override decision based on system resources.
+    def available
+        # Manual mode, user gave us a value.
+        if (max_slots = Options.system.max_slots)
+            max_slots - used
+
+        # Auto-mode, pick the safest restriction, RAM vs CPU.
+        else
+            available_auto
+        end
+    end
+
+    # @return   [Integer]
+    #   Amount of new scans that can be safely run in parallel, currently.
+    #   The decision is based on the available resources alone.
+    def available_auto
+        [ available_in_memory, available_in_cpu, available_in_disk ].min
+    end
+
+    # @return   [Integer]
+    #   Amount of instances that are currently alive.
+    def used
+        @pids.select! { |pid| Processes::Manager.alive? pid }
+        @pids.size
+    end
+
+    # @return   [Integer]
+    #   Amount of scans that can be safely run in parallel, in total.
+    def total
+        used + available
+    end
+
+    # @return   [Integer]
+    #   Amount of scans we can fit into the available memory.
+    #
+    #   Works based on slots, available memory isn't currently available OS
+    #   memory but memory that is unallocated.
+    def available_in_memory
+        return Float::INFINITY if memory_size == 0
+        (unallocated_memory / memory_size).to_i
+    end
+
+    # @return   [Integer]
+    #   Amount of CPU cores that are available.
+    #
+    #   Well, they may not be really available, other stuff on the machine could
+    #   be using them to a considerable extent, but we can only do so much.
+    def available_in_cpu
+        @system.cpu_count - used
+    end
+
+    # @return   [Integer]
+    #   Amount of scans we can fit into the available disk space.
+    #
+    #   Works based on slots, available space isn't currently available OS
+    #   disk space but space that is unallocated.
+    def available_in_disk
+        return Float::INFINITY if disk_space == 0
+        (unallocated_disk_space / disk_space).to_i
+    end
+
+    # @param    [Integer]   pid
+    #
+    # @return   [Integer]
+    #   Remaining memory for the scan, in bytes.
+    def remaining_memory_for( pid )
+        [memory_size - @system.memory_for_process_group( pid ), 0].max
+    end
+
+    # @return   [Integer]
+    #   Amount of memory (in bytes) available for future scans.
+    def unallocated_memory
+        # Available memory right now.
+        available_mem = @system.memory_free
+
+        # Remove allocated memory to figure out how much we can really spare.
+        @pids.each do |pid|
+            # Mark the remaining allocated memory as unavailable.
+            available_mem -= remaining_memory_for( pid )
+        end
+
+        available_mem
+    end
+
+    # @param    [Integer]   pid
+    #
+    # @return   [Integer]
+    #   Remaining disk space for the scan, in bytes.
+    def remaining_disk_space_for( pid )
+        [disk_space - @system.disk_space_for_process( pid ), 0].max
+    end
+
+    # @return   [Integer]
+    #   Amount of disk space (in bytes) available for future scans.
+    def unallocated_disk_space
+        # Available space right now.
+        available_space = @system.disk_space_free
+
+        # Remove allocated space to figure out how much we can really spare.
+        @pids.each do |pid|
+            # Mark the remaining allocated space as unavailable.
+            available_space -= remaining_disk_space_for( pid )
+        end
+
+        available_space
+    end
+
+    def disk_space
+        return 0 if !Cuboid::Application.application
+        Cuboid::Application.application.max_disk.to_i
+    end
+
+    # @return   [Fixnum]
+    #   Amount of memory (in bytes) to allocate to each scan.
+    def memory_size
+        return 0 if !Cuboid::Application.application
+        Cuboid::Application.application.max_memory.to_i
+    end
+
+end
+end
+end

data/lib/cuboid/ui/output.rb

@@ -0,0 +1,52 @@
+module Cuboid
+module UI
+
+# The system needs an {OutputInterface interface} as a {Cuboid::UI::Output}
+# module and every UI should provide one.
+#
+# This one however is in case that one isn't available and it's basically
+# a black hole that will only print and log errors and nothing else.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+module Output
+    include OutputInterface
+
+    def print_error( message = '' )
+        msg = "#{caller_location} #{message}"
+
+        $stderr.puts msg
+        log_error msg
+    end
+
+    def print_bad(*)
+    end
+
+    def print_status(*)
+    end
+
+    def print_info(*)
+    end
+
+    def print_ok(*)
+    end
+
+    def print_debug(*)
+    end
+
+    def print_verbose(*)
+    end
+
+    def print_line(*)
+    end
+
+    private
+
+    def output_provider_file
+        __FILE__
+    end
+
+    extend self
+end
+
+end
+end

data/lib/cuboid/ui/output_interface.rb

@@ -0,0 +1,43 @@
+require 'cuboid/error'
+
+module Cuboid
+module UI
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class Error < Cuboid::Error
+end
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+module OutputInterface
+
+    # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+    class Error < Cuboid::UI::Error
+    end
+
+    require_relative 'output_interface/abstract'
+    require_relative 'output_interface/implemented'
+
+    require_relative 'output_interface/error_logging'
+    require_relative 'output_interface/controls'
+    require_relative 'output_interface/personalization'
+
+    # These output methods need to be implemented by the driving UI.
+    include Abstract
+    # These output method implementations depend on the Abstract ones.
+    include Implemented
+
+    include ErrorLogging
+    include Controls
+    include Personalization
+
+    # Must be called after the entire {Cuboid} environment has been loaded.
+    def self.initialize
+        Controls.initialize
+        ErrorLogging.initialize
+    end
+
+    extend self
+end
+
+end
+end

data/lib/cuboid/ui/output_interface/abstract.rb

@@ -0,0 +1,68 @@
+module Cuboid
+module UI
+module OutputInterface
+
+# These methods need to be implemented by the driving UI.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+module Abstract
+
+    class Error < Cuboid::UI::OutputInterface::Error
+
+        # Raised when trying to use an output method that has not been implemented.
+        class MissingImplementation < Error
+        end
+
+    end
+
+    # @abstract
+    def print_error( message = '' )
+        fail Error::MissingImplementation
+    end
+
+    # @abstract
+    def print_bad( message = '' )
+        fail Error::MissingImplementation
+    end
+
+    # @abstract
+    def print_status( message = '' )
+        fail Error::MissingImplementation
+    end
+
+    # @abstract
+    def print_info( message = '' )
+        fail Error::MissingImplementation
+    end
+
+    # @abstract
+    def print_ok( message = '' )
+        fail Error::MissingImplementation
+    end
+
+    # @abstract
+    def print_verbose( message = '' )
+        fail Error::MissingImplementation
+    end
+
+    # @abstract
+    def print_line( message = '' )
+        fail Error::MissingImplementation
+    end
+
+    # @abstract
+    def print_debug( message = '', level = 1 )
+        fail Error::MissingImplementation
+    end
+
+    # @abstract
+    def output_provider_file
+        # __FILE__
+        fail Error::MissingImplementation
+    end
+
+end
+
+end
+end
+end

data/lib/cuboid/ui/output_interface/controls.rb

@@ -0,0 +1,84 @@
+module Cuboid
+module UI
+module OutputInterface
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+module Controls
+
+    def self.initialize
+        @@verbose = false
+        @@debug   = 0
+    end
+
+    # Enables {#print_verbose} messages.
+    #
+    # @see #verbose?
+    def verbose_on
+        @@verbose = true
+    end
+    alias :verbose :verbose_on
+
+    # Disables {#print_verbose} messages.
+    #
+    # @see #verbose?
+    def verbose_off
+        @@verbose = false
+    end
+
+    # @return    [Bool]
+    def verbose?
+        @@verbose
+    end
+
+    # Enables {#print_debug} messages.
+    #
+    # @param    [Integer]   level
+    #   Sets the debugging level.
+    #
+    # @see #debug?
+    def debug_on( level = 1 )
+        @@debug = level
+    end
+    alias :debug :debug_on
+
+    # Disables {#print_debug} messages.
+    #
+    # @see #debug?
+    def debug_off
+        @@debug = 0
+    end
+
+    # @return   [Integer]
+    #   Debugging level.
+    def debug_level
+        @@debug
+    end
+
+    # @param    [Integer]   level
+    #   Checks against this level.
+    #
+    # @return   [Bool]
+    #
+    # @see #debug
+    def debug?( level = 1 )
+        @@debug >= level
+    end
+
+    def debug_level_1?
+        debug? 1
+    end
+    def debug_level_2?
+        debug? 2
+    end
+    def debug_level_3?
+        debug? 3
+    end
+    def debug_level_4?
+        debug? 4
+    end
+
+end
+
+end
+end
+end

data/lib/cuboid/ui/output_interface/error_logging.rb

@@ -0,0 +1,119 @@
+module Cuboid
+module UI
+module OutputInterface
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+module ErrorLogging
+
+    def self.initialize
+        @@error_log_written_env = false
+
+        @@error_fd ||= nil
+        begin
+            @@error_fd.close if @@error_fd
+        rescue IOError
+        end
+
+        @@error_fd      = nil
+        @@error_buffer  = []
+        @@error_logfile = "#{Cuboid::Options.paths.logs}error-#{Process.pid}.log"
+    end
+
+    # @param    [String]    logfile
+    #   Location of the error log file.
+    def set_error_logfile( logfile )
+        @@error_logfile = logfile
+    end
+
+    # @return  [String]
+    #   Location of the error log file.
+    def error_logfile
+        @@error_logfile
+    end
+
+    def has_error_log?
+        File.exist? error_logfile
+    end
+
+    private
+
+    def error_log_fd
+        return @@error_fd if @@error_fd
+
+        @@error_fd = File.open( error_logfile, 'a' )
+        @@error_fd.sync = true
+
+        Kernel.at_exit do
+            begin
+                @@error_fd.close if @@error_fd
+            rescue IOError
+            end
+        end
+
+        @@error_fd
+
+    # Errno::EMFILE (too many open files) or something, nothing we can do
+    # about it except catch it to avoid a crash.
+    rescue SystemCallError => e
+        $stderr.puts "[#{e.class}] #{e}"
+        e.backtrace.each { |line| $stderr.puts line }
+        nil
+    end
+
+    # Logs an error message to the error log file.
+    #
+    # @param    [String]    str
+    def log_error( str = '' )
+        fd = error_log_fd
+
+        if !@@error_log_written_env
+            @@error_log_written_env = true
+
+            ['', "#{Time.now} " + ( '-' * 80 )].each do |s|
+
+                if fd
+                    fd.puts s
+                end
+
+                @@error_buffer << s
+            end
+
+            begin
+                h = {}
+                ENV.each { |k, v| h[k] = v }
+
+                options = Cuboid::Options.to_rpc_data.to_yaml
+
+                ['ENV:', h.to_yaml, '-' * 80, 'OPTIONS:', options].each do |s|
+
+                    if fd
+                        fd.puts s
+                    end
+
+                    @@error_buffer += s.split("\n")
+                end
+            rescue
+            end
+
+            if fd
+                fd.puts '-' * 80
+            end
+
+            @@error_buffer << '-' * 80
+        end
+
+        msg = "[#{Time.now}] #{str}"
+        @@error_buffer << msg
+
+        if fd
+            fd.puts msg
+        end
+
+        nil
+    end
+
+end
+
+end
+end
+end