rbsim 0.0.3

data/lib/rbsim/statistics.rb

@@ -0,0 +1,77 @@
+module RBSim
+  class Statistics
+    UnknownStatsType = Class.new RuntimeError
+    attr_accessor :clock
+
+    def initialize
+      @counter_events = {}
+      @duration_events = {}
+      @saved_values = {}
+      @clock = 0
+    end
+
+    def event(type, params, time)
+      if type == :stats
+        @counter_events[params] ||= []
+        @counter_events[params] << time
+      elsif type == :save
+        tags = params[:tags]
+        value = params[:value]
+        @saved_values[tags] ||= {}
+        @saved_values[tags][time] ||= []
+        @saved_values[tags][time] << value
+      else
+        raise UnknownStatsType.new(type) unless [:start, :stop].include? type
+        @duration_events[params] ||= {}
+        @duration_events[params][type] ||= []
+        @duration_events[params][type] << time
+      end
+    end
+
+    def durations(filters = {})
+      return enum_for(:durations, filters) unless block_given?
+      data = @duration_events.select &events_filter(filters)
+      data.each do |tags, times|
+        starts_and_stops = times[:start].zip times[:stop]
+        starts_and_stops.each do |start, stop|
+          yield tags, start, stop
+        end
+      end
+    end
+
+    def counters(filters = {})
+      return enum_for(:counters, filters) unless block_given?
+      data = @counter_events.select &events_filter(filters)
+      data.each do |tags, events|
+        yield tags, events
+      end
+    end
+
+    def values(filters = {})
+      return enum_for(:values, filters) unless block_given?
+      data = @saved_values.select &events_filter(filters)
+      data.each do |tags, times_and_values|
+        times_and_values.each do |time, values|
+          yield tags, time, values
+        end
+      end
+    end
+
+    private
+
+    # generic event filter for all statistics
+    def events_filter(filters)
+      lambda do |tags, event_list|
+        filters.reduce(true) do |acc, filter_item|
+          filter_key, filter_value = filter_item;
+          if filter_value.is_a? Regexp
+            acc && tags.has_key?(filter_key) && tags[filter_key].to_s =~ filter_value
+          else
+            acc && tags[filter_key] == filter_value
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/rbsim/tokens.rb

@@ -0,0 +1,146 @@
+require 'rbsim/hlmodel'
+
+module RBSim
+  module Tokens
+
+    class ProcessToken < HLModel::Process
+      #include TCPN::TokenMethods
+    end
+
+    class RoutesToken < HLModel::Routes
+      #include TCPN::TokenMethods
+    end
+
+    class NetToken < HLModel::Net
+      #include TCPN::TokenMethods
+    end
+
+    class CPUToken < HLModel::Node::CPU
+      #include TCPN::TokenMethods
+    end
+
+    class Data
+      IncompleteDataDefinition = Class.new RuntimeError
+      attr_reader :data_id # id of data required to collect fragments
+      attr_reader :src, :dst, :src_node, :size, :type, :content, :id
+      attr_accessor :dst_node, :route
+      attr_accessor :fragments # no. of fragments this data was between
+
+      def initialize(data_id, node, process, opts)
+        @data_id = data_id
+        @src_node = node
+        @src = process
+        @dst = opts[:to]
+        [ :size, :type, :content].each do |a|
+          self.instance_variable_set "@#{a}".to_sym, opts[a]
+        end
+        if @size.nil?
+          raise IncompleteDataDefinition.new("Must define size of data package!");
+        end
+        if @dst.nil?
+          raise IncompleteDataDefinition.new("Must define destination of data package!");
+        end
+        @id = self.object_id
+      end
+
+      def to_s
+        v = [:src, :dst, :src_node, :size, :type, :content].map do |k|
+          "#{k}: #{self.send(k).inspect}"
+        end.join ', '
+        "{#{v}}"
+      end
+
+      def ==(o)
+        return false unless o.kind_of? Data
+        o.id == id
+      end
+
+      def has_next_net?
+        @route.has_next_net?
+      end
+
+    end
+
+    class DataToken < Data
+      #include TCPN::TokenMethods
+    end
+
+    class DataQueue
+      class CannotEnqueueDataError < RuntimeError
+        def initialize(data, message)
+          super message
+          @data = data
+        end
+
+        def to_s
+          super  + " " + @data.inspect
+        end
+      end
+
+      attr_reader :process_name, :process_tags
+      def initialize(process_name, process_tags = {})
+        @process_name = process_name
+        @process_tags = process_tags
+        @queue = []
+        @incomplete_data = Hash.new { { fragments: 0, data: nil } }
+      end
+
+      def put(o)
+        if o.fragments.nil?
+          raise CannotEnqueueDataError.new(o, "Tried to enqueue data without fragment count set!")
+        end
+        enqueue_fragment(o)
+        check_if_complete(o)
+      end
+
+      def get
+        @queue.shift
+      end
+
+      def length
+        @queue.length
+      end
+
+      def empty?
+        length == 0
+      end
+
+      private
+
+      def enqueue_fragment(o)
+        already_received = @incomplete_data[o.data_id]
+        already_received[:fragments] += 1
+        already_received[:data] ||= o
+        @incomplete_data[o.data_id] = already_received
+      end
+
+      def check_if_complete(o)
+        already_received = @incomplete_data[o.data_id]
+        if already_received[:fragments] == o.fragments
+          @incomplete_data.delete o.data_id
+          @queue << already_received[:data]
+        end
+      end
+
+    end
+
+    class DataQueueToken < DataQueue
+      #include TCPN::TokenMethods
+    end
+
+
+    class Event
+      attr_reader :process_id, :name, :args
+      def initialize(process_id, name, args)
+        @process_id = process_id
+        @name = name
+        @args = args
+      end
+    end
+
+    class EventToken < Event
+      #include TCPN::TokenMethods
+    end
+
+  end
+end

data/lib/rbsim/version.rb

@@ -0,0 +1,3 @@
+module RBSim
+  VERSION = '0.0.3'
+end

data/new_process.rb

@@ -0,0 +1,49 @@
+require 'rbsim'
+
+# new_process statement example usage
+# use this to create specs!
+# This will be a kind of integration specs for dsl and hlmodel:
+# Test behavior of hlmodel defined by the DSL statements
+
+model = RBSim.dsl do
+  new_process :worker do
+    on_event :data do |volume|
+      delay_for 100
+      cpu do |c|
+        12/c.performance
+      end
+    end
+    delay_for 100
+    cpu do |cpu|
+      100/cpu.performance
+    end
+    register_event :data, 1000
+  end
+end
+
+puts "Model: "
+p model
+
+puts "="*60
+puts "Serving process events"
+p = model.processes[:worker]
+p.node = :node01
+
+puts "-"*60
+e = p.serve_system_event :delay_for
+puts "delay_for: #{e.inspect}"
+
+
+puts "-"*60
+cpu = Object.new
+def cpu.performance
+  20
+end
+e = p.serve_system_event :cpu
+puts "cpu: #{e.inspect} computed CPU delay: #{e[:args][:block].call cpu}"
+
+puts "-"*60
+puts "Process after serving user event :data (note event_queue modified by this event)"
+p.serve_user_event # returns process object (self)!
+puts p.inspect
+

data/rbsim.gemspec

@@ -0,0 +1,42 @@
+# Used this istruction to create the gem:
+# http://guides.rubygems.org/make-your-own-gem/
+# some things below were based on docile gem.
+
+$:.push File.expand_path('../lib', __FILE__)
+require 'rbsim/version'
+
+Gem::Specification.new do |s|
+  s.name = 'rbsim'
+  s.version = RBSim::VERSION
+  s.authors = ['Wojciech Rząsa']
+  s.email = %w(me@wojciechrzasa.pl)
+  s.homepage = 'https://github.com/wrzasa/rbsim'
+  s.summary = 'Distributed inftastructure and system simulator with convenient DSL.'
+  s.description = 'You can model your distributed infrastructora and application and simulate its behavior and observe its efficiency easily.'
+  s.license = 'GPL-3.0'
+
+  s.platform = 'ruby'
+  s.required_ruby_version = '~> 2.0'
+
+#  s.rubyforge_project = ''
+
+  s.files = `git ls-files -z`.split("\x0")
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+  s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.require_paths = %w(lib)
+
+  s.add_runtime_dependency 'docile', '~> 1.1'
+  s.add_runtime_dependency 'fast-tcpn', '~> 0'
+
+  # Running rspec tests from rake
+  s.add_development_dependency 'rspec', '~> 3.1'
+  s.add_development_dependency 'rspec-its', '~> 1.0'
+  s.add_development_dependency 'simplecov', '~> 0'
+
+  s.extra_rdoc_files << 'README.md'
+  s.rdoc_options << '--main' << 'README.md'
+  s.rdoc_options << '--title' << 'RBSim -- Distributed system modeling and simulation tool'
+  s.rdoc_options << '--line-numbers'
+  s.rdoc_options << '-A'
+  s.rdoc_options << '-x coverage'
+end

data/show_readme.rb

@@ -0,0 +1,15 @@
+if RUBY_ENGINE == 'jruby'
+  puts "Unfortunatelly as far as I know markdown does not work in JRuby, so this script won't work too."
+  exit
+end
+
+
+begin
+  require 'sinatra'
+
+  get '/' do
+    markdown File.read('README.md')
+  end
+rescue LoadError
+  puts "This script requires sinatra gem. You have to do:\ngem install sinatra"
+end

data/sim.rb

@@ -0,0 +1,142 @@
+require 'rbsim'
+
+model = RBSim.model do
+
+  program :wget do |opts|
+    sent = 0
+    on_event :send do
+      cpu do |cpu|
+        (150 / cpu.performance).miliseconds
+      end
+      send_data to: opts[:target], size: 1024.bytes, type: :request, content: sent
+      log "Sent data in process #{process.name} #{sent}"
+      sent += 1
+      # delay_for 5.miliseconds
+      register_event :send, delay: 5.miliseconds if sent < opts[:count]
+    end
+
+    on_event :data_received do |data|
+      log "Got data #{data} in process #{process.name}"
+      stats :request_served, process.name
+    end
+
+    register_event :send
+  end
+
+  program :apache_static do
+    on_event :data_received do |data|
+      log "Got #{data.type} from: #{data.src}, size: #{data.size}, content: #{data.content}"
+      cpu do |cpu|
+        (100 * data.size.in_bytes / cpu.performance).miliseconds
+      end
+      send_data to: data.src, size: data.size * 10, type: :response, content: data.content
+      log "Responded to: #{data.src} with content: #{data.content}"
+    end
+  end
+
+  program :apache_php do |name|
+    on_event :data_received do |data|
+      stats_start :working, name
+      log "#{name} start #{data.type} from #{data.src} #{data.content}"
+      if data.type == :request
+        cpu do |cpu|
+          (100 * data.size.in_bytes / cpu.performance).miliseconds
+        end
+        send_data to: :db, size: data.size/10, type: :sql, content: { client: data.src, content: data.content }
+      else
+        cpu do |cpu|
+          (500*data.size / cpu.performance).miliseconds
+        end
+        send_data to: data.content[:client], size: data.size*2, type: :response, content: data.content[:content]
+      end
+      log "#{name} finished #{data.type} from #{data.src} #{data.content}"
+      stats_stop :working, name
+    end
+  end
+
+  program :mysql do
+    on_event :data_received do |data|
+      stats_start :query, :mysql
+      log "DB start #{data.src} #{data.content}"
+      delay_for (data.size.in_bytes * rand).miliseconds
+      cpu do |cpu|
+        (data.size / 10 * rand).miliseconds
+      end
+      send_data to: data.src, size: data.size*1000, type: :db_response, content: data.content
+      log "DB finish #{data.src} #{data.content}"
+      stats_stop :query, :mysql
+    end
+  end
+
+  node :desktop do
+    cpu 100
+  end
+
+  node :laptop do
+    cpu 100
+  end
+
+  node :gandalf do
+    cpu 140000
+    cpu 140000
+  end
+
+  node :dbserver do
+    cpu 500
+  end
+
+  new_process :client1, program: :wget, args: { target: :server1, count: 10 }
+  new_process :client2, program: :wget, args: { target: :server2, count: 10 }
+
+  new_process :server1, program: :apache_php, args: 'apache1'
+  new_process :server2, program: :apache_php, args: 'apache2'
+  new_process :db, program: :mysql
+
+  net :net01, bw: 1024.bps
+  net :net02, bw: 768.bps
+  net :lan, bw: 10240.bps
+
+  route from: :desktop, to: :gandalf, via: [ :net01, :net02 ], twoway: true
+  route from: :laptop, to: :gandalf, via: [ :net01, :net02 ], twoway: true
+  route from: :gandalf, to: :dbserver, via: [ :lan ], twoway: true
+
+  put :server1, on: :gandalf
+  put :server2, on: :gandalf
+  put :db, on: :dbserver
+
+  put :client1, on: :desktop
+  put :client2, on: :laptop
+
+end
+
+# TODO: modify CPU load event handling, to enable random CPU load time!
+# TODO: potrzebne gotowe narzędzie generujące raport obciążenia poszczególnych zasobów
+
+# TODO: use this proof-of-concept to embedd logger into RBSim!
+=begin
+model.simulator.cb_for :transition, :after do |t, e|
+#  puts ">> #{e.clock} #{e.transition}"##{e.binding.map {|k, v| "#{k}: #{v}" }}" #if e.clock > 90000
+  if e.transition == 'event::log'
+    message = e.binding[:process][:val].serve_system_event(:log)[:args]
+    puts "#{e.clock} #{message}"
+  end
+end
+=end
+
+#model.simulator.cb_for :clock, :after do |t, e|
+#  puts e.clock
+#end
+
+=begin
+model.logger do |clock, message|
+  puts "MY LOGGER: #{clock} #{message}"
+end
+=end
+
+model.run
+
+#p model.stats_summary
+#p model.stats_data
+
+model.stats_print
+