slotz 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1829fa39dcca433a7c74867bde89d53f70447c4c72c7abd54fb7ef4e68a73c87
+  data.tar.gz: acc87fb694a334b2fbaabf99bb4c608ee6fd9fa168f4f143c2087fd4e86e4f2d
+SHA512:
+  metadata.gz: cae56d7e4293d7b3152dd353127ef550b089fefb49aea0e3b83cb48e41a67fee0f9a3e7d2f2166872791ceebcabe5066039ecb5969f64063e4a8358fd0ef2a68
+  data.tar.gz: 05e01352f292781b59cd23cc4fc0ae665ff718d4c1451c8afefdbcd1c9c3c9149e1bc9ccc6cab42ee97d3a89fbd9a3b62d9f61b67c9de671760a2a9438c62ea1

data/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+gem 'rake', '13.0.3'
+
+group :docs do
+    gem 'yard'
+    gem 'redcarpet'
+end
+
+group :spec do
+    gem 'rspec'
+end
+
+group :prof do
+    gem 'benchmark-ips'
+    gem 'memory_profiler'
+end
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,29 @@
+# License
+
+    Copyright (C) 2025, Anastasios Laskos <mailto:anastasios.laskos@gmail.com>
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without modification,
+    are permitted provided that the following conditions are met:
+
+        * Redistributions of source code must retain the above copyright notice,
+          this list of conditions and the following disclaimer.
+
+        * Redistributions in binary form must reproduce the above copyright notice,
+          this list of conditions and the following disclaimer in the documentation
+          and/or other materials provided with the distribution.
+
+        * Neither the name of the copyright holder nor the names of its contributors
+          may be used to endorse or promote products derived from this software
+          without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+    ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+    ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,3 @@
+# Slotz
+
+TBD/WiP

data/lib/slotz/options.rb

@@ -0,0 +1,13 @@
+module Slotz
+
+    # class Options
+    #
+    #     attr_reader :max_slots
+    #
+    #     def initialize( options = {} )
+    #         @max_slots = options[:max_slots]
+    #     end
+    #
+    # end
+
+end

data/lib/slotz/reservation.rb

@@ -0,0 +1,43 @@
+module Slotz
+
+class Reservation < Module
+
+    attr_reader :disk
+    attr_reader :memory
+    attr_reader :cores
+
+    def initialize( provision )
+        @provision = provision
+
+        ObjectSpace.define_finalizer(self, proc {
+            Slotz::RESERVED[:disk]   -= self.class.disk
+            Slotz::RESERVED[:memory] -= self.class.memory
+            Slotz::RESERVED[:cores]  -= self.class.cores
+        })
+    end
+
+    def included( base )
+        provisions = @provision
+        base.class_eval do
+            @disk   = provisions[:disk]
+            def self.disk
+                @disk
+            end
+
+            @memory = provisions[:memory]
+            def self.memory
+                @memory
+            end
+
+            @cores  = provisions[:cores]
+            def self.cores
+                @cores
+            end
+        end
+
+        Slotz.filter base
+    end
+
+end
+
+end

data/lib/slotz/system/application.rb

@@ -0,0 +1,40 @@
+module Slotz
+
+    class Application
+
+        attr_reader :klass
+        attr_reader :requirements
+
+        def initialize( klass, requirements = {} )
+            @klass        = klass
+            @requirements = requirements
+
+            Slotz.occupy self
+        end
+
+        def disk
+            @requirements[:disk]
+        end
+
+        def remaining_disk
+
+        end
+
+        def cores
+            @requirements[:cores]
+        end
+
+        def remaining_cores
+
+        end
+
+        def memory
+            @requirements[:memory]
+        end
+
+        def remaining_memory
+
+        end
+    end
+
+end

data/lib/slotz/system/platforms/base.rb

@@ -0,0 +1,74 @@
+require 'concurrent'
+require 'tmpdir'
+
+module Slotz
+
+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
+            Dir.tmpdir
+        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

data/lib/slotz/system/platforms/linux.rb

@@ -0,0 +1,26 @@
+require_relative 'mixins/unix'
+
+module Slotz
+
+class System
+module Platforms
+class Linux < Base
+    include Mixins::Unix
+
+    # @return   [Integer]
+    #   Amount of free RAM in bytes.
+    def memory_free
+        memory.available_bytes
+    end
+
+    class <<self
+        def current?
+            Slotz::System.linux?
+        end
+    end
+
+end
+
+end
+end
+end

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

@@ -0,0 +1,46 @@
+require 'vmstat'
+
+module Slotz
+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/slotz/system/platforms/osx.rb

@@ -0,0 +1,25 @@
+require_relative 'mixins/unix'
+
+module Slotz
+
+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?
+            Slotz::System.mac?
+        end
+    end
+
+end
+end
+end
+end

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

@@ -0,0 +1,81 @@
+module Slotz
+
+class System
+module Platforms
+
+class Windows < Base
+
+    class <<self
+        def current?
+            Slotz::System.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/slotz/system/platforms.rb

@@ -0,0 +1,12 @@
+module Slotz
+
+class System
+module Platforms
+
+end
+end
+end
+
+Dir.glob( "#{File.dirname(__FILE__)}/**/*.rb" ).each do |platform|
+    require platform
+end

data/lib/slotz/system.rb

@@ -0,0 +1,241 @@
+require_relative 'system/platforms/base'
+require 'singleton'
+require 'set'
+
+module Slotz
+
+class System
+    include Singleton
+
+    # @return   [Bool]
+    def self.windows?
+        @is_windows ||= Gem.win_platform?
+    end
+
+    # @return   [Bool]
+    def self.linux?
+        @is_linux ||= RbConfig::CONFIG['host_os'] =~ /linux/
+    end
+
+    # @return   [Bool]
+    def self.mac?
+        @is_mac ||= RbConfig::CONFIG['host_os'] =~ /darwin|mac os/i
+    end
+
+    # @return   [Array<Platforms::Base>]
+    attr_reader :platforms
+
+    # @return   [Slots]
+    attr_reader :slots
+
+    attr_accessor :max_slots
+
+    def initialize
+        @platforms = []
+        @pids      = Set.new
+    end
+
+    def use( pid )
+        @pids << pid
+        pid
+    end
+
+    # @return   [Integer]
+    #   Amount of new applications 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 = 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 applications that can be safely run in parallel, currently.
+    #   The decision is based on the available resources alone.
+    def available_auto( requirements )
+        [ available_in_memory( requirements[:memory] ),
+          available_in_cpu( requirements[:cores] ),
+          available_in_disk( requirements[:disk] ) ].min
+    end
+
+    # @return   [Integer]
+    #   Amount of instances that are currently alive.
+    def used
+        Slotz.applications.size
+    end
+
+    # @return   [Integer]
+    #   Amount of scans that can be safely run in parallel, in total.
+    def total
+        used + available
+    end
+
+    def fits?( requirements )
+        available_auto( requirements )
+    end
+
+    # @return   [Integer]
+    #   Amount of processes 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( memory )
+        return Float::INFINITY if memory.to_i == 0
+        (unallocated_memory / memory).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( cores )
+        @system.cpu_count - used
+    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_requirement( application )
+        application.disk.to_i
+    end
+
+    # @return   [Fixnum]
+    #   Amount of memory (in bytes) to allocate.
+    def memory_requirement( application )
+        application.memory.to_i
+    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
+        @pids.clear
+        @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/slotz/version.rb

@@ -0,0 +1,3 @@
+module Slotz
+    VERSION = '0.1'
+end

data/lib/slotz.rb

@@ -0,0 +1,35 @@
+module Slotz
+    require_relative 'slotz/version'
+    require_relative 'slotz/options'
+    require_relative 'slotz/system'
+    require_relative 'slotz/reservation'
+
+    RESERVED = {
+      disk:   0,
+      memory: 0,
+      cores:  0
+    }
+
+    def self.filter( reservation )
+        # fail 'Max utilization.' if Slotz::System.max_utilization?
+
+        if RESERVED[:disk] + reservation.disk <= System.disk_space_free
+            RESERVED[:disk] += reservation.disk
+        else
+            fail 'Not enough disk resources.'
+        end
+
+        if RESERVED[:memory] + reservation.memory <= System.memory_free
+            RESERVED[:memory] += reservation.memory
+        else
+            fail 'Not enough memory resources.'
+        end
+
+        # if RESERVED[:cores] + requirements[:cores] <= System.cores
+        #     RESERVED[:cores]  += requirements[:cores]
+        # else
+        #     fail 'Not enough CPU resources.'
+        # end
+    end
+
+end

data/slotz.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+Gem::Specification.new do |s|
+    require_relative File.expand_path( File.dirname( __FILE__ ) ) + '/lib/slotz/version'
+
+    s.name              = 'slotz'
+    s.version           = Slotz::VERSION
+    s.date              = Time.now.strftime( '%Y-%m-%d' )
+    s.summary           = 'An application-centric, decentralised and distributed computing solution. '
+
+    s.homepage          = 'https://github.com/qadron/cuboid'
+    s.email             = 'tasos.laskos@gmail.com'
+    s.authors           = [ 'Tasos Laskos' ]
+    s.licenses          = ['MIT']
+
+    s.files            += Dir.glob( 'config/**/**' )
+    s.files            += Dir.glob( 'lib/**/**' )
+    s.files            += Dir.glob( 'logs/**/**' )
+    s.files            += Dir.glob( 'components/**/**' )
+    s.files            += Dir.glob( 'spec/**/**' )
+    s.files            += %w(Gemfile slotz.gemspec)
+    s.test_files        = Dir.glob( 'spec/**/**' )
+
+    s.extra_rdoc_files  = %w(README.md LICENSE.md)
+
+    s.rdoc_options      = [ '--charset=UTF-8' ]
+
+    s.add_dependency 'awesome_print',       '1.9.2'
+
+    # Don't specify version, messes with the packages since they always grab the
+    # latest one.
+    s.add_dependency 'bundler'
+
+    s.add_dependency 'concurrent-ruby'
+    s.add_dependency 'vmstat',              '~> 2.3.1'
+    s.add_dependency 'sys-proctable',       '~> 1.3.0'
+
+    s.description = <<DESCRIPTION
+DESCRIPTION
+
+end

data/spec/slotz/system/platforms/linux_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Slotz::System::Platforms::Linux do
+    it_should_behave_like 'Slotz::System::Platforms::Mixins::Unix'
+
+    describe '#memory_free' do
+        it 'returns the amount of free memory' do
+            o = Object.new
+            expect(o).to receive(:available_bytes).and_return(1000)
+            expect(subject).to receive(:memory).at_least(:once).and_return(o)
+
+            expect(subject.memory_free).to eq 1000
+        end
+    end
+
+    describe '.current?' do
+        context 'when running on Linux' do
+            it 'returns true' do
+                expect(Slotz::System).to receive(:linux?).and_return( true )
+                expect(described_class).to be_current
+            end
+        end
+
+        context 'when not running on Linux' do
+            it 'returns false' do
+                expect(Slotz::System).to receive(:linux?).and_return( false )
+                expect(described_class).to_not be_current
+            end
+        end
+    end
+end

data/spec/slotz/system/platforms/osx_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Slotz::System::Platforms::OSX do
+    it_should_behave_like 'Slotz::System::Platforms::Mixins::Unix'
+
+    describe '#memory_free' do
+        it 'returns the amount of free memory' do
+            o = Object.new
+            expect(o).to receive(:free).and_return(1000)
+            expect(o).to receive(:pagesize).and_return(4096)
+            expect(subject).to receive(:memory).at_least(:once).and_return(o)
+
+            expect(subject.memory_free).to eq 4096000
+        end
+    end
+
+    describe '.current?' do
+        context 'when running on OSX' do
+            it 'returns true' do
+                expect(Slotz::System).to receive(:mac?).and_return( true )
+                expect(described_class).to be_current
+            end
+        end
+
+        context 'when not running on OSX' do
+            it 'returns false' do
+                expect(Slotz::System).to receive(:mac?).and_return( false )
+                expect(described_class).to_not be_current
+            end
+        end
+    end
+end

data/spec/slotz/system/platforms/windows_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Slotz::System::Platforms::Windows, if: Slotz::System.windows? do
+    it_should_behave_like 'Slotz::System::Platforms::Base'
+
+    subject { described_class.new }
+
+    describe '#memory_free' do
+        it 'returns the amount of free memory' do
+            expect(subject.memory_free).to be > 0
+        end
+    end
+
+    describe '#disk_space_free' do
+        it 'returns the amount of free disk space' do
+            expect(subject.disk_space_free).to be > 0
+        end
+    end
+
+    describe '#memory_for_process_group' do
+        it 'returns bytes of memory used by the group' do
+            expect(subject.memory_for_process_group( Process.pid )).to be > 0
+        end
+    end
+
+    describe '.current?' do
+        context 'when running on Windows' do
+            it 'returns true'do
+                expect(Slotz).to receive(:windows?).and_return( true )
+                expect(described_class).to be_current
+            end
+        end
+
+        context 'when not running on Windows' do
+            it 'returns false' do
+                expect(Slotz).to receive(:windows?).and_return( false )
+                expect(described_class).to_not be_current
+            end
+        end
+    end
+end

data/spec/slotz/system/slotz_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe Slotz do
+    subject { system }
+    let(:system) { Slotz::System.instance }
+
+    before :each do
+        subject.reset
+    end
+
+    describe '#available' do
+        context 'when OptionGroups::system#max_slots is set' do
+            before do
+                Slotz::System.max_slots = 5
+            end
+
+            it 'uses it to calculate available slots' do
+                expect(subject.available).to eq 5
+            end
+
+            context 'when some slots have been used' do
+                it 'subtracts them' do
+                    allow(subject).to receive(:used).and_return( 2 )
+                    expect(subject.available).to eq 3
+                end
+            end
+        end
+
+        context 'when OptionGroups::system#max_slots is not set' do
+            before do
+                Slotz::System.max_slots = nil
+            end
+
+            it 'uses #available_auto' do
+                pending
+                expect(subject).to receive(:available_auto).and_return( 25 )
+                expect(subject.available).to eq 25
+            end
+        end
+    end
+
+    describe '#available_auto' do
+        before do
+            Slotz::System.max_slots = nil
+        end
+
+        it 'calculates slots based on previously reserved resources' do
+            pending
+        end
+
+        context 'when restricted by memory' do
+            it 'bases the calculation on memory slots' do
+                pending
+            end
+        end
+
+        context 'when restricted by CPUs' do
+            it 'bases the calculation on CPU slots' do
+                pending
+            end
+        end
+
+        context 'when restricted by disk space' do
+            it 'bases the calculation on disk space' do
+                pending
+            end
+        end
+    end
+
+    describe '#used' do
+        it 'returns the amount of active instances' do
+            pending
+        end
+
+        context 'when a process dies' do
+            it 'gets removed from the count'
+        end
+    end
+
+    describe '#total' do
+        it 'sums up free and used slots' do
+            expect(subject).to receive(:available).and_return( 3 )
+            expect(subject).to receive(:used).and_return( 5 )
+
+            expect(subject.total).to eq 8
+        end
+    end
+
+    describe '#available_in_memory' do
+        it 'returns amount of free memory slots' do
+            pending
+        end
+    end
+
+    describe '#available_in_cpu' do
+        it 'returns amount of free CPUs splots' do
+            pending
+        end
+    end
+
+    describe '#unallocated_memory' do
+        context 'when there are no scans running' do
+            it 'returns the amount of free memory' do
+                pending
+            end
+        end
+
+        context 'when there are scans running' do
+            context 'using part of their allocation' do
+                it 'removes their allocated slots' do
+                    pending
+                end
+            end
+        end
+    end
+
+    describe '#remaining_memory_for' do
+        it 'returns the amount of allocated memory available to the scan' do
+            pending
+        end
+    end
+
+    describe '#unallocated_disk_space' do
+        context 'when there are no scans running' do
+            it 'returns the amount of free disk space' do
+                pending
+            end
+        end
+
+        context 'when there are scans running' do
+            context 'using part of their allocation' do
+                it 'removes their allocated slots' do
+                    pending
+                end
+            end
+        end
+    end
+
+    describe '#remaining_disk_space_for' do
+        it 'returns the amount of allocated disk space available to the scan' do
+            pending
+        end
+    end
+
+    describe '#memory_size' do
+        before do
+            # Slotz::Options.reset
+        end
+        let(:memory_size) { subject.memory_size }
+
+        it 'is approx 0.2GB with default options' do
+            pending
+        end
+    end
+end

data/spec/slotz/system_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Slotz::System do
+    subject { described_class.instance }
+
+    describe '#memory_free' do
+        it 'delegates to #platform' do
+            expect(subject.platform).to receive(:memory_free).and_return(10)
+            expect(subject.memory_free).to eq 10
+        end
+    end
+
+    describe '#memory_for_process_group' do
+        it 'delegates to #platform' do
+            expect(subject.platform).to receive(:memory_for_process_group).with(123).and_return(10)
+            expect(subject.memory_for_process_group(123)).to eq 10
+        end
+    end
+
+    describe '#disk_space_free' do
+        it 'delegates to #platform' do
+            expect(subject.platform).to receive(:disk_space_free).and_return(10)
+            expect(subject.disk_space_free).to eq 10
+        end
+    end
+
+    describe '#disk_space_for_process' do
+        it 'delegates to #platform' do
+            expect(subject.platform).to receive(:disk_space_for_process).with(123).and_return(10)
+            expect(subject.disk_space_for_process(123)).to eq 10
+        end
+    end
+
+    describe '#disk_directory' do
+        it "delegates to #platform" do
+            expect(subject.platform).to receive(:disk_directory).and_return('10')
+            expect(subject.disk_directory).to eq '10'
+        end
+    end
+
+    describe '#cpu_count' do
+        it 'delegates to #platform' do
+            expect(subject.platform).to receive(:cpu_count).and_return(10)
+            expect(subject.cpu_count).to eq 10
+        end
+    end
+
+    describe '#platform' do
+        it 'returns the current platform' do
+            pending
+            platform_stub = Class.new do
+                def self.current?
+                    true
+                end
+            end
+
+            subject.platforms.unshift platform_stub
+
+            expect(subject.platform).to be_instance_of platform_stub
+
+            subject.platforms.delete platform_stub
+        end
+
+        context 'when the platform could not be identified' do
+            it 'raises error' do
+                pending
+                subject.platforms.each do |platform|
+                    expect(platform).to receive(:current?).and_return(false)
+                end
+
+                expect do
+                    subject.platform
+                end.to raise_error "Unsupported platform: #{RUBY_PLATFORM}"
+            end
+        end
+    end
+
+    describe '#platforms' do
+        it 'returns all supported platforms' do
+            pending
+            expect(subject.platforms.map(&:to_s).sort).to eq [
+                described_class::Platforms::Linux,
+                described_class::Platforms::OSX,
+                described_class::Platforms::Windows
+            ].map(&:to_s).sort
+        end
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+require_relative 'support/helpers/paths'
+
+Dir.glob( "#{support_path}/{lib,helpers,shared,factories}/**/*.rb" ).each { |f| require f }
+
+RSpec::Core::MemoizedHelpers.module_eval do
+    alias to should
+    alias to_not should_not
+end
+
+RSpec.configure do |config|
+    config.run_all_when_everything_filtered = true
+    config.color = true
+    config.add_formatter :documentation
+    config.alias_example_to :expect_it
+    config.filter_run_when_matching focus: true
+
+    config.mock_with :rspec do |mocks|
+        mocks.yield_receiver_to_any_instance_implementation_blocks = true
+    end
+
+    config.before( :each ) do
+        # reset_all
+    end
+
+    config.after( :each ) do
+        # cleanup_instances
+        # processes_killall
+    end
+    config.after( :all ) do
+        # killall
+    end
+end

data/spec/support/helpers/paths.rb

@@ -0,0 +1,15 @@
+def name_from_filename
+    File.basename( caller.first.split( ':' ).first, '_spec.rb' )
+end
+
+def spec_path
+    File.expand_path( File.dirname( File.absolute_path( __FILE__ )  ) + '/../../' ) + '/'
+end
+
+def support_path
+    "#{spec_path}support/"
+end
+
+def fixtures_path
+    "#{support_path}fixtures/"
+end

data/spec/support/shared/system/platforms/base.rb

@@ -0,0 +1,19 @@
+require 'tmpdir'
+
+shared_examples_for 'Slotz::System::Platforms::Base' do
+    subject { described_class.new }
+
+    describe '#disk_directory' do
+        it "delegates to #{Dir.tmpdir}" do
+            expect(subject.disk_directory).to eq Dir.tmpdir
+        end
+    end
+
+    describe '#cpu_count' do
+        it 'returns the amount of CPUs' do
+            expect(Concurrent).to receive(:processor_count).and_return(99)
+            expect(subject.cpu_count).to eq 99
+        end
+    end
+
+end

data/spec/support/shared/system/platforms/mixins/unix.rb

@@ -0,0 +1,37 @@
+shared_examples_for 'Slotz::System::Platforms::Mixins::Unix' do
+    it_should_behave_like 'Slotz::System::Platforms::Base'
+
+    subject { described_class.new }
+
+    describe '#memory_for_process_group' do
+        let(:ps) do
+            <<EOTXT
+   RSS
+109744
+ 63732
+ 62236
+ 63876
+ 62772
+ 62856
+ 64504
+EOTXT
+        end
+
+        it 'returns bytes of memory used by the group' do
+            expect(subject).to receive(:pagesize).and_return(4096)
+            expect(subject).to receive(:_exec).with('ps -o rss -g 123').and_return(ps)
+            expect(subject.memory_for_process_group( 123 )).to eq 2005893120
+        end
+    end
+
+    describe '#disk_space_free' do
+        it 'returns the amount of free disk space' do
+            o = Object.new
+            expect(o).to receive(:available_bytes).and_return(1000)
+            expect(Vmstat).to receive(:disk).with(Slotz::System.disk_directory).and_return(o)
+
+            expect(subject.disk_space_free).to eq 1000
+        end
+    end
+
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: slotz
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Tasos Laskos
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vmstat
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+- !ruby/object:Gem::Dependency
+  name: sys-proctable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+description: ''
+email: tasos.laskos@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.md
+files:
+- Gemfile
+- LICENSE.md
+- README.md
+- lib/slotz.rb
+- lib/slotz/options.rb
+- lib/slotz/reservation.rb
+- lib/slotz/system.rb
+- lib/slotz/system/application.rb
+- lib/slotz/system/platforms.rb
+- lib/slotz/system/platforms/base.rb
+- lib/slotz/system/platforms/linux.rb
+- lib/slotz/system/platforms/mixins/unix.rb
+- lib/slotz/system/platforms/osx.rb
+- lib/slotz/system/platforms/windows.rb
+- lib/slotz/version.rb
+- slotz.gemspec
+- spec/slotz/system/platforms/linux_spec.rb
+- spec/slotz/system/platforms/osx_spec.rb
+- spec/slotz/system/platforms/windows_spec.rb
+- spec/slotz/system/slotz_spec.rb
+- spec/slotz/system_spec.rb
+- spec/spec_helper.rb
+- spec/support/helpers/paths.rb
+- spec/support/shared/system/platforms/base.rb
+- spec/support/shared/system/platforms/mixins/unix.rb
+homepage: https://github.com/qadron/cuboid
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.22
+signing_key:
+specification_version: 4
+summary: An application-centric, decentralised and distributed computing solution.
+test_files:
+- spec/slotz/system/slotz_spec.rb
+- spec/slotz/system/platforms/osx_spec.rb
+- spec/slotz/system/platforms/linux_spec.rb
+- spec/slotz/system/platforms/windows_spec.rb
+- spec/slotz/system_spec.rb
+- spec/support/shared/system/platforms/base.rb
+- spec/support/shared/system/platforms/mixins/unix.rb
+- spec/support/helpers/paths.rb
+- spec/spec_helper.rb