rbsim 0.0.3

data/spec/integration/process_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe "Application process activity" do
+
+  module ProcessActivitySpec
+    class CPU
+      attr_accessor :node, :performance
+      def initialize(node, performance)
+        @node, @performance = node, performance
+      end
+    end
+
+    class CPUToken < CPU
+      #include TCPN::TokenMethods
+    end
+
+  end
+
+  let :hlmodel do
+    RBSim.dsl do
+      new_process :worker do
+        on_event :data do |volume|
+          delay_for 100
+          cpu do |c|
+            12/c.performance
+          end
+          new_process :child do
+            delay_for 500
+            cpu do |c|
+              450/c.performance
+            end
+            send_data to: :worker, size: 1024, type: :hi, content: 'hello!'
+          end
+        end
+        delay_for 100
+        cpu do |cpu|
+          100/cpu.performance
+        end
+        register_event :data, delay: 200, args: 1000
+        log "a log message here"
+      end
+    end
+  end
+
+  let(:process_token) { hlmodel.processes[:worker] }
+  let(:data_queue) { RBSim::Tokens::DataQueueToken.new(process_token.name) }
+
+  # FIXME: marking for TCPN should be set by DSL!
+  let :tcpn do
+    process_token.node = :node01
+    cpu_token = ProcessActivitySpec::CPUToken.new(:node01, 10)
+    mapping_token = { ts: 0, val: { process_token.name => process_token.node } }
+
+
+    tcpn = FastTCPN.read 'tcpn/model/application.rb'
+
+    tcpn.add_marking_for 'CPU', cpu_token
+    tcpn.add_marking_for 'process', process_token
+    tcpn.add_marking_for 'mapping', mapping_token
+    tcpn.add_marking_for 'data to receive', data_queue
+    tcpn
+  end
+
+  it "produces correct transition firing sequence and final TCPN marking" do
+    transitions = []
+    tcpn.cb_for :transition, :after do |t, e|
+      transitions << e.transition
+    end
+
+    tcpn.sim
+
+    expect(transitions).to eq ["event::delay_for",
+                               "event::cpu",
+                               "event::cpu_finished",
+                               "event::register_event",
+                               "event::log",
+                               "event::enqueue_event",
+                               "event::serve_user",
+                               "event::delay_for",
+                               "event::cpu",
+                               "event::cpu_finished",
+                               "event::new_process",
+                               "event::delay_for",
+                               "event::cpu",
+                               "event::cpu_finished",
+                               "event::send_data"
+                              ]
+    # mapping token should be updated after new
+    # process is created
+    mapping = tcpn.marking_for('mapping').first[:val]
+    expect(mapping[:child]).to eq(:node01)
+
+    # do we have data to send token in proper place?
+    data = tcpn.marking_for('data to send').first[:val]
+    expect(data.dst).to eq(:worker)
+  end
+
+  it "receives data" do
+    data = RBSim::Tokens::DataToken.new(867545, :node01, :process01, to: :child, size: 1234)
+    data.fragments = 1
+    data_queue.put data
+    received_data = false
+    transitions = []
+    tcpn.cb_for :transition, :before do |t, e|
+      transitions << e.transition
+      if e.transition == 'event::serve_user' && e.binding['process'].value.has_event?(:data_received)
+        received_data = true
+      end
+    end
+
+    tcpn.sim
+
+    expect(transitions).to include("event::data_received")
+    expect(received_data).to be true
+  end
+
+end

data/spec/integration/rbsim_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+require 'tempfile'
+
+describe RBSim do
+
+  describe "#model" do
+    it "passes its params to the loaded model" do
+      o = Object.new
+      expect(o).to receive(:to_s)
+      m = RBSim.model name: :apache, run: true do |params|
+        o.to_s
+        expect(params[:name]).to eq :apache
+        expect(params[:run]).to be true
+      end
+      m.hlmodel
+    end
+  end
+
+  describe "#read" do
+    it "reads model from file" do
+      file = Tempfile.new "rbsim_model_test"
+      file.write "program :prg do;end"
+      file.close
+      m = RBSim.read file.path
+      file.unlink
+      expect(m.hlmodel.programs).to have_key :prg
+    end
+
+    it "passes params to the model from file as 'params' variable" do
+      file = Tempfile.new "rbsim_model_test"
+      file.write "program params[:name] do;end"
+      file.close
+      m = RBSim.read file.path, name: :prg
+      file.unlink
+      expect(m.hlmodel.programs).to have_key :prg
+    end
+
+  end
+end

data/spec/simulator/logger_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe RBSim::Simulator do
+  describe "#logger" do
+    let :model do
+      RBSim.model do
+        new_process :worker do
+          log "start"
+          delay_for 20.seconds
+          log "stop"
+        end
+
+        node :n1 do
+          cpu 100.miliseconds
+        end
+
+        put :worker, on: :n1
+
+      end
+    end
+
+    it "logs to default logger" do
+      expect { model.run }.to output("0.000: start\n20.000: stop\n").to_stdout
+    end
+
+    it "logs to custom logger" do
+      logs = []
+      model.logger do |clock, message|
+        logs << { time: clock, message: message }
+      end
+      model.run
+      expect(logs).to eq [ {time: 0, message: "start" }, {time: 20.seconds, message: "stop"} ]
+    end
+  end
+end

data/spec/simulator/stats_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe RBSim::Simulator do
+  describe "statistics" do
+    let :model do
+      RBSim.model do
+        new_process :worker do
+          stats_start tag: :work, group_name: 'worker'
+          delay_for 200
+          stats_stop tag: :work, group_name: 'worker'
+          delay_for 100
+          stats tag: :wait, group_name: 'worker'
+          delay_for 100
+          stats tag: :wait, group_name: 'worker'
+          stats_save 31415, tag: :queue_length, group_name: 'worker'
+        end
+
+        node :n1 do
+          cpu 100
+        end
+
+        put :worker, on: :n1
+
+      end
+    end
+
+    it "registers events in Statistisc" do
+      expect_any_instance_of(RBSim::Statistics).to receive(:event).with(:start, {tag: :work, group_name: 'worker'}, 0).once
+      expect_any_instance_of(RBSim::Statistics).to receive(:event).with(:stop, {tag: :work, group_name: 'worker'}, 200)
+      expect_any_instance_of(RBSim::Statistics).to receive(:event).with(:stats, {tag: :wait, group_name: 'worker'}, 300)
+      expect_any_instance_of(RBSim::Statistics).to receive(:event).with(:stats, {tag: :wait, group_name: 'worker'}, 400)
+      expect_any_instance_of(RBSim::Statistics).to receive(:event).with(:save, {value: 31415, tags: { tag: :queue_length, group_name: 'worker'} }, 400)
+      model.run
+    end
+
+    describe "net dropping packages" do
+      let :model do
+        RBSim.model do
+          new_process :sender do
+            10.times { send_data to: :receiver, size: 10, content: "Test message" }
+          end
+
+          new_process :receiver do
+          end
+
+          node :sender do
+            cpu 1
+          end
+
+          node :receiver do
+            cpu 1
+          end
+
+          net :net01, bw: 1024, drop: drop
+
+          put :sender, on: :sender
+          put :receiver, on: :receiver
+          route from: :sender, to: :receiver, via: [ :net01 ], toway: true
+        end
+      end
+
+      describe "when dropping" do
+        let(:drop) { 1 }
+
+        it "counts dropped" do
+
+          allow(RBSim::Statistics).to receive(:dropped_stats)
+          allow_any_instance_of(RBSim::Statistics).to receive(:event) do |*a|
+            if a[1..-2] == [:stats, {net: :net01, event: 'NET DROP'}]
+              RBSim::Statistics.dropped_stats
+            end
+          end
+          expect(RBSim::Statistics).to receive(:dropped_stats).exactly(10 * model.data_fragmentation).times
+          model.run
+        end
+      end
+
+      describe "when not dropping" do
+        let(:drop) { 1 }
+
+        it "counts dropped" do
+          expect_any_instance_of(RBSim::Statistics).not_to receive(:event).with(:stats, 
+                                                                            {tag: :net01, 
+                                                                             group_name: 'NET DROP'})
+          model.run
+        end
+      end
+    end
+
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+require 'rbsim'
+require 'rspec/its'
+
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  #config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/statistics_spec.rb

@@ -0,0 +1,300 @@
+require 'spec_helper'
+
+describe RBSim::Statistics do
+
+  describe "with hash based tags" do
+    describe "event counters" do
+      let :stats do
+        stats = RBSim::Statistics.new
+        stats.event :stats, { score: :hit, target: 'small' }, 100
+        stats.event :stats, { score: :hit, target: 'big' }, 300
+        stats.event :stats, { score: :miss, target: 'small' }, 500
+        stats.event :stats, { score: :hit, target: 'small' }, 500
+        stats.event :stats, { score: :miss, target: 'small' }, 500
+        stats.event :stats, { score: :hit, target: 'big' }, 900
+        stats.event :stats, { score: :hit3, target: 'big' }, 900
+        stats.event :stats, { score: :hit, target: 'big', value: 23 }, 900
+        stats.event :stats, { score: :hit, target: 'big', value: 230 }, 900
+        stats.event :stats, { score: :hit5, target: 'huge' }, 950
+        stats.clock = 1000
+        stats
+      end
+      subject { stats }
+
+      it "returns all counters" do
+        counters = subject.counters.to_h
+        expected_counters = {
+          { score: :hit, target: 'small' } => [ 100, 500 ],
+          { score: :hit, target: 'big' } => [ 300, 900 ],
+          { score: :hit, target: 'big', value: 23 } => [ 900 ],
+          { score: :hit, target: 'big', value: 230 } => [ 900 ],
+          { score: :miss, target: 'small' } => [ 500, 500 ],
+          { score: :hit3, target: 'big' } => [ 900 ],
+          { score: :hit5, target: 'huge' } => [ 950 ],
+        }
+        expect(counters).to eq expected_counters
+      end
+
+      it "filters counters by single tag" do
+        counters = subject.counters(score: :hit).to_h
+        expected_counters = {
+          { score: :hit, target: 'small' } => [ 100, 500 ],
+          { score: :hit, target: 'big' } => [ 300, 900 ],
+          { score: :hit, target: 'big', value: 23 } => [ 900 ],
+          { score: :hit, target: 'big', value: 230 } => [ 900 ],
+        }
+        expect(counters).to eq expected_counters
+      end
+
+      it "filters counters by two tags" do
+        counters = subject.counters(score: :hit, target: 'big').to_h
+        expected_counters = {
+          { score: :hit, target: 'big' } => [ 300, 900 ],
+          { score: :hit, target: 'big', value: 23 } => [ 900 ],
+          { score: :hit, target: 'big', value: 230 } => [ 900 ],
+        }
+        expect(counters).to eq expected_counters
+      end
+
+      it "filters counters by rare tag" do
+        counters = subject.counters(value: 23).to_h
+        expected_counters = {
+          { score: :hit, target: 'big', value: 23 } => [ 900 ],
+        }
+        expect(counters).to eq expected_counters
+      end
+
+      it "filters counters by regexp" do
+        counters = subject.counters(score: /hit.?/).to_h
+        expected_counters = {
+          { score: :hit, target: 'small' } => [ 100, 500 ],
+          { score: :hit, target: 'big' } => [ 300, 900 ],
+          { score: :hit, target: 'big', value: 23 } => [ 900 ],
+          { score: :hit, target: 'big', value: 230 } => [ 900 ],
+          { score: :hit3, target: 'big' } => [ 900 ],
+          { score: :hit5, target: 'huge' } => [ 950 ],
+        }
+        expect(counters).to eq expected_counters
+      end
+
+      it "filters counters by any regexp matching any value if key exists" do
+        counters = subject.counters(value: /.*/).to_h
+        expected_counters = {
+          { score: :hit, target: 'big', value: 23 } => [ 900 ],
+          { score: :hit, target: 'big', value: 230 } => [ 900 ],
+        }
+        expect(counters).to eq expected_counters
+      end
+
+    end
+
+    describe "correctly computes event duration" do
+      context "for correct data" do
+        let :stats do
+          stats = RBSim::Statistics.new
+          stats.event :start, { tag: :working, name: 'apache' }, 100
+          stats.event :start, { tag: :working, name: 'nginx'  }, 100
+
+          stats.event :start, { tag: :request, name: 'apache' }, 200
+          stats.event :stop,  { tag: :request, name: 'apache' }, 300
+          stats.event :start, { tag: :request, name: 'nginx'  }, 350
+          stats.event :start, { tag: :request, name: 'apache' }, 350
+          stats.event :stop,  { tag: :request, name: 'nginx'  }, 400
+          stats.event :stop,  { tag: :request, name: 'apache' }, 420
+          stats.event :start, { tag: :compute, name: 'apache', mod: :php }, 500
+          stats.event :stop,  { tag: :compute, name: 'apache', mod: :php }, 600
+
+          stats.event :stop,  { tag: :working, name: 'nginx'  }, 850
+          stats.event :stop,  { tag: :working, name: 'apache' }, 900
+          stats.clock = 1000
+
+          stats
+        end
+
+        subject { stats }
+
+        it "returns all durations" do
+          durations = subject.durations.to_a
+          expected_durations = [
+            [ { tag: :working, name: 'apache' }, 100, 900 ],
+            [ { tag: :working, name: 'nginx'  }, 100, 850 ],
+            [ { tag: :request, name: 'apache' }, 200, 300 ],
+            [ { tag: :request, name: 'apache' }, 350, 420 ],
+            [ { tag: :compute, name: 'apache', mod: :php }, 500, 600 ],
+            [ { tag: :request, name: 'nginx'  }, 350, 400 ],
+          ]
+          expect(durations).to match_array expected_durations
+        end
+
+        it "filters durations by single tag" do
+          durations = subject.durations(tag: :working).to_a
+          expected_durations = [
+            [ { tag: :working, name: 'apache' }, 100, 900 ],
+            [ { tag: :working, name: 'nginx'  }, 100, 850 ],
+          ]
+          expect(durations).to match_array expected_durations
+        end
+
+        it "filters durations by two tags" do
+          durations = subject.durations(tag: :request, name: 'apache').to_a
+          expected_durations = [
+            [ { tag: :request, name: 'apache' }, 200, 300 ],
+            [ { tag: :request, name: 'apache' }, 350, 420 ],
+          ]
+          expect(durations).to match_array expected_durations
+        end
+
+        it "filters durations by rare tag" do
+          durations = subject.durations(tag: :compute).to_a
+          expected_durations = [
+            [ { tag: :compute, name: 'apache', mod: :php }, 500, 600 ],
+          ]
+          expect(durations).to match_array expected_durations
+        end
+
+        it "filters durations by regexp" do
+          durations = subject.durations(tag: /r/).to_a
+          expected_durations = [
+            [ { tag: :working, name: 'apache' }, 100, 900 ],
+            [ { tag: :working, name: 'nginx'  }, 100, 850 ],
+            [ { tag: :request, name: 'apache' }, 200, 300 ],
+            [ { tag: :request, name: 'apache' }, 350, 420 ],
+            [ { tag: :request, name: 'nginx'  }, 350, 400 ],
+          ]
+          expect(durations).to match_array expected_durations
+        end
+
+        it "filters durations by any regexp matching any value if key exists" do
+          durations = subject.durations(mod: /.*/).to_a
+          expected_durations = [
+            [ { tag: :compute, name: 'apache', mod: :php }, 500, 600 ],
+          ]
+          expect(durations).to match_array expected_durations
+        end
+
+      end
+      context "for incorrect data" do
+        let :stats do
+          stats = RBSim::Statistics.new
+          stats.event :start, { tag: :request, name: 'apache' }, 200
+          stats.event :start, { tag: :request, name: 'apache' }, 300
+          stats.event :start, { tag: :request, name: 'apache' }, 400
+          stats.event :stop,  { tag: :request, name: 'apache' }, 450
+          stats.event :stop,  { tag: :request, name: 'apache' }, 550
+          stats.event :stop,  { tag: :request, name: 'apache' }, 650
+
+          stats.clock = 1000
+
+          stats
+        end
+
+        subject { stats }
+
+        it "correctly yields first start with first stop and so on" do
+          durations = subject.durations.to_a
+          expected_durations = [
+            [ { tag: :request, name: 'apache' }, 200, 450 ],
+            [ { tag: :request, name: 'apache' }, 300, 550 ],
+            [ { tag: :request, name: 'apache' }, 400, 650 ],
+          ]
+          expect(durations).to match_array expected_durations
+        end
+      end
+    end
+
+    describe "saves reported values" do
+      let :stats do
+        stats = RBSim::Statistics.new
+
+        stats.event :save, { value: 1024, tags: { tag: :queue_length, name: 'apache' } }, 100
+        stats.event :save, { value: 1524, tags: { tag: :queue_length, name: 'apache' } }, 100
+        stats.event :save, { value: 1024, tags: { tag: :queue_length, name: 'nginx'  } }, 100
+        stats.event :save, { value: 2048, tags: { tag: :queue_length, name: 'apache' } }, 200
+        stats.event :save, { value: 2048, tags: { tag: :queue_length, name: 'apache', mod: :php } }, 200
+        stats.event :save, { value: 2048, tags: { tag: :queue_length, name: 'nginx'  } }, 200
+        stats.event :save, { value: 2048, tags: { tag: :queue_length, name: 'nginx', mod: :php  } }, 300
+        stats.event :save, { value: 20,   tags: { tag: :wait_time, name: 'nginx'     } }, 350
+        stats.event :save, { value: 512,  tags: { tag: :queue_length, name: 'apache' } }, 400
+        stats.event :save, { value: 30,   tags: { tag: :wait_time, name: 'nginx'     } }, 400
+
+        stats.clock = 1000
+
+        stats
+      end
+
+      subject { stats }
+
+      it "returns all values" do
+        values = subject.values.to_a
+        expected_values = [
+          [ { tag: :queue_length, name: 'apache' }, 100, [ 1024, 1524 ] ],
+          [ { tag: :queue_length, name: 'nginx'  }, 100, [ 1024 ] ],
+          [ { tag: :queue_length, name: 'apache' }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'apache', mod: :php }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'nginx' }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'nginx', mod: :php }, 300, [ 2048 ] ],
+          [ { tag: :wait_time, name: 'nginx' }, 350, [ 20 ] ],
+          [ { tag: :queue_length, name: 'apache' }, 400, [ 512 ] ],
+          [ { tag: :wait_time, name: 'nginx' }, 400, [ 30 ] ],
+        ]
+        expect(values).to match_array expected_values
+      end
+
+      it "filters values by single tag" do
+        values = subject.values(tag: :queue_length).to_a
+        expected_values = [
+          [ { tag: :queue_length, name: 'apache' }, 100, [ 1024, 1524 ] ],
+          [ { tag: :queue_length, name: 'nginx'  }, 100, [ 1024 ] ],
+          [ { tag: :queue_length, name: 'apache' }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'apache', mod: :php }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'nginx' }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'nginx', mod: :php }, 300, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'apache' }, 400, [ 512 ] ],
+        ]
+        expect(values).to match_array expected_values
+      end
+
+      it "filters values by two tags" do
+        values = subject.values(tag: :queue_length, name: 'apache').to_a
+        expected_values = [
+          [ { tag: :queue_length, name: 'apache' }, 100, [ 1024, 1524 ] ],
+          [ { tag: :queue_length, name: 'apache' }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'apache', mod: :php }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'apache' }, 400, [ 512 ] ],
+        ]
+        expect(values).to match_array expected_values
+      end
+
+      it "filters values by rare tag" do
+        values = subject.values(mod: :php).to_a
+        expected_values = [
+          [ { tag: :queue_length, name: 'apache', mod: :php }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'nginx', mod: :php }, 300, [ 2048 ] ],
+        ]
+        expect(values).to match_array expected_values
+      end
+
+      it "filters values by regexp" do
+        values = subject.values(name: /^a.*/).to_a
+        expected_values = [
+          [ { tag: :queue_length, name: 'apache' }, 100, [ 1024, 1524 ] ],
+          [ { tag: :queue_length, name: 'apache' }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'apache', mod: :php }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'apache' }, 400, [ 512 ] ],
+        ]
+        expect(values).to match_array expected_values
+      end
+
+      it "filters values by any regexp matching any value if key exists" do
+        values = subject.values(mod: /.*/).to_a
+        expected_values = [
+          [ { tag: :queue_length, name: 'apache', mod: :php }, 200, [ 2048 ] ],
+          [ { tag: :queue_length, name: 'nginx', mod: :php }, 300, [ 2048 ] ],
+        ]
+        expect(values).to match_array expected_values
+      end
+
+    end
+  end
+
+end