cuboid 0.0.0 → 0.0.3

data/lib/cuboid/system/platforms/mixins/unix.rb

@@ -0,0 +1,46 @@
+require 'vmstat'
+
+module Cuboid
+class System
+module Platforms
+module Mixins
+
+module Unix
+
+    # @param    [Integer]   pgid
+    #   Process group ID.
+    #
+    # @return   [Integer]
+    #   Amount of RAM in bytes used by the given GPID.
+    def memory_for_process_group( pgid )
+        rss = 0
+
+        _exec( "ps -o rss -g #{pgid}" ).split("\n")[1..-1].each do |rss_string|
+            rss += rss_string.to_i
+        end
+
+        rss * pagesize
+    end
+
+    # @return   [Integer]
+    #   Amount of free disk in bytes.
+    def disk_space_free
+        Vmstat.disk( disk_directory ).available_bytes
+    end
+
+    private
+
+    def pagesize
+        @pagesize ||= memory.pagesize
+    end
+
+    def memory
+        Vmstat.memory
+    end
+
+end
+
+end
+end
+end
+end

data/lib/cuboid/system/platforms/osx.rb

@@ -0,0 +1,25 @@
+require_relative 'mixins/unix'
+
+module Cuboid
+
+class System
+module Platforms
+class OSX < Base
+    include Mixins::Unix
+
+    # @return   [Integer]
+    #   Amount of free RAM in bytes.
+    def memory_free
+        pagesize * memory.free
+    end
+
+    class <<self
+        def current?
+            Cuboid.mac?
+        end
+    end
+
+end
+end
+end
+end

data/lib/cuboid/system/platforms/windows.rb

@@ -0,0 +1,81 @@
+module Cuboid
+
+class System
+module Platforms
+
+class Windows < Base
+
+    class <<self
+        def current?
+            Cuboid.windows?
+        end
+    end
+
+    # @return   [Integer]
+    #   Amount of free RAM in bytes.
+    def memory_free
+        result = wmi.ExecQuery(
+            'select AvailableBytes from Win32_PerfFormattedData_PerfOS_Memory'
+        )
+
+        memory = nil
+        result.each do |e|
+            memory = e.availableBytes.to_i
+            e.ole_free
+        end
+        result.ole_free
+
+        memory
+    end
+
+    # @param    [Integer]   pgid
+    #   Process group ID.
+    #
+    # @return   [Integer]
+    #   Amount of RAM in bytes used by the given GPID.
+    def memory_for_process_group( pgid )
+        processes = wmi.ExecQuery(
+            "select PrivatePageCount from win32_process where ProcessID='#{pgid}' or ParentProcessID='#{pgid}'"
+        )
+
+        memory = 0
+        processes.each do |process|
+            # Not actually pages but bytes, no idea why.
+            memory += process.privatePageCount.to_i
+            process.ole_free
+        end
+        processes.ole_free
+
+        memory
+    end
+
+    # @return   [Integer]
+    #   Amount of free disk in bytes.
+    def disk_space_free
+        device_id = disk_directory.split( '/' ).first
+
+        drives = wmi.ExecQuery(
+            "select FreeSpace from win32_LogicalDisk where DeviceID='#{device_id}'"
+        )
+
+        space = nil
+        drives.each do |drive|
+            space = drive.freeSpace.to_i
+            drive.ole_free
+        end
+        drives.ole_free
+
+        space
+    end
+
+    private
+
+    def wmi
+        @wmi ||= WIN32OLE.connect( 'winmgmts://' )
+    end
+
+end
+end
+end
+
+end

data/lib/cuboid/system/platforms.rb

@@ -0,0 +1,84 @@
+module Cuboid
+
+class System
+module Platforms
+
+class Base
+    class <<self
+
+        # @private
+        def inherited( platform )
+            System.register_platform platform
+        end
+
+        # @return   [Bool]
+        #   `true` if it's the current platform, `false` otherwise.
+        #
+        # @abstract
+        def current?
+            raise 'Missing implementation'
+        end
+    end
+
+    # @return   [Integer]
+    #   Amount of free RAM in bytes.
+    #
+    # @abstract
+    def memory_free
+        raise 'Missing implementation'
+    end
+
+    # @param    [Integer]   pgid
+    #   Process group ID.
+    #
+    # @return   [Integer]
+    #   Amount of RAM in bytes used by the given GPID.
+    #
+    # @abstract
+    def memory_for_process_group( pgid )
+        raise 'Missing implementation'
+    end
+
+    # @return   [Integer]
+    #   Amount of free disk in bytes.
+    #
+    # @abstract
+    def disk_space_free
+        raise 'Missing implementation'
+    end
+
+    # @return   [String
+    #   Location for temporary file storage.
+    def disk_directory
+        Options.paths.os_tmpdir
+    end
+
+    # @param    [Integer]   pid
+    #   Process ID.
+    #
+    # @return   [Integer]
+    #   Amount of disk in bytes used by the given PID.
+    def disk_space_for_process( pid )
+        Support::Database::Base.disk_space_for( pid )
+    end
+
+    # @return   [Integer]
+    #   Amount of CPU cores.
+    def cpu_count
+        Concurrent.processor_count
+    end
+
+    # @private
+    def _exec( cmd )
+        %x(#{cmd})
+    end
+
+end
+
+end
+end
+end
+
+Dir.glob( "#{File.dirname(__FILE__)}/**/*.rb" ).each do |platform|
+    require platform
+end

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/system.rb

@@ -0,0 +1,119 @@
+require_relative 'system/slots'
+
+module Cuboid
+
+class System
+    include Singleton
+
+    # @return   [Array<Platforms::Base>]
+    attr_reader :platforms
+
+    # @return   [Slots]
+    attr_reader :slots
+
+    def initialize
+        @platforms = []
+        @slots     = Slots.new( self )
+    end
+
+    # @return   [Float]
+    #   System utilization based on slots.
+    #
+    #   * `0.0` => No utilization.
+    #   * `1.0` => Max utilization.
+    def utilization
+        total_slots = System.slots.total
+        return 1.0 if total_slots == 0
+
+        System.slots.used / Float( total_slots )
+    end
+
+    # @return   [Bool]
+    def max_utilization?
+        utilization == 1
+    end
+
+    # @return   [Integer]
+    #   Amount of free RAM in bytes.
+    def memory_free
+        platform.memory_free
+    end
+
+    # @param    [Integer]   pgid
+    #   Process group ID.
+    #
+    # @return   [Integer]
+    #   Amount of RAM in bytes used by the given GPID.
+    def memory_for_process_group( pgid )
+        platform.memory_for_process_group( pgid )
+    end
+
+    # @return   [Integer]
+    #   Amount of free disk space in bytes.
+    def disk_space_free
+        platform.disk_space_free
+    end
+
+    # @return   [String
+    #   Location for temporary file storage.
+    def disk_directory
+        platform.disk_directory
+    end
+
+    # @param    [Integer]   pid
+    #   Process ID.
+    #
+    # @return   [Integer]
+    #   Amount of disk space in bytes used by the given PID.
+    def disk_space_for_process( pid )
+        platform.disk_space_for_process( pid )
+    end
+
+    # @return   [Integer]
+    #   Amount of CPU cores.
+    def cpu_count
+        @cpu_count ||= platform.cpu_count
+    end
+
+    # @return   [Platforms::Base]
+    def platform
+        return @platform if @platform
+
+        platforms.each do |klass|
+            next if !klass.current?
+
+            return @platform = klass.new
+        end
+
+        raise "Unsupported platform: #{RUBY_PLATFORM}"
+    end
+
+    # @private
+    def register_platform( platform )
+        platforms << platform
+    end
+
+    # @private
+    def reset
+        @cpu_count = nil
+        @platform  = nil
+    end
+
+    class <<self
+        def method_missing( sym, *args, &block )
+            if instance.respond_to?( sym )
+                instance.send( sym, *args, &block )
+            else
+                super( sym, *args, &block )
+            end
+        end
+
+        def respond_to?( *args )
+            super || instance.respond_to?( *args )
+        end
+    end
+
+end
+end
+
+require_relative 'system/platforms'

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/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