rbsim 0.0.3

data/spec/hlmodel/process_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+
+describe RBSim::HLModel::Process do
+  let :block do
+      Proc.new do
+      end
+  end
+
+  subject do
+    process = RBSim::HLModel::Process.new(:test_process)
+    process.node = :node01
+    process
+  end
+
+  its(:name){ should eq :test_process }
+
+
+  context "not assigned to node" do
+    subject do
+      process = RBSim::HLModel::Process.new(:not_assigned_process)
+      process
+    end
+    it "raises error and does not serve system events" do
+      subject.enqueue_event :delay_for, 100
+      expect { subject.serve_system_event :delay_for }.to raise_error RuntimeError
+    end
+    it "raises error and does not serve user events" do
+      subject.on_event :data do
+      end
+      subject.enqueue_event :data
+      expect { subject.serve_user_event }.to raise_error RuntimeError
+    end
+  end
+
+  # Here is basic usage example
+  it "serves user events in order" do
+    subject.on_event :be_glad do |process, who|
+      "I am glad #{who}"
+    end
+    subject.on_event :be_happy do |process, who|
+      "I am happy #{who}"
+    end
+    subject.enqueue_event :be_happy, "Jack"
+    subject.enqueue_event :be_glad, "John"
+    subject.enqueue_event :be_happy, "John"
+    expect(subject.serve_user_event).to eq "I am happy Jack"
+    expect(subject.serve_user_event).to eq "I am glad John"
+    expect(subject.serve_user_event).to eq "I am happy John"
+  end
+
+  it "serves system events" do
+    sysevent1 = subject.system_event_names[0]
+    sysevent2 = subject.system_event_names[1]
+    subject.enqueue_event sysevent1, block: block, param2: 123
+    subject.enqueue_event sysevent2, time: 1000
+    expect(subject.serve_system_event sysevent1).
+      to eq({ name: sysevent1, args: { block: block, param2: 123 } })
+    expect(subject.serve_system_event sysevent2).
+      to eq({ name: sysevent2, args: { time: 1000 } })
+  end
+
+  it "has generic event handler for :data_received event" do
+    data = "for this test anything representing received data"
+    subject.enqueue_event :data_received, data
+    expect(subject.has_event? :data_received).to be true
+    expect{ subject.serve_user_event }.not_to raise_error
+  end
+
+  context "with program name given" do
+    subject { RBSim::HLModel::Process.new(:test_process, :apache_webserver) }
+    its(:program){ should eq :apache_webserver }
+  end
+
+  describe "#on_event" do
+    it "registers new event handler" do
+      expect {
+        subject.on_event :example_event, &block
+      }.to change(subject, :handlers_size).by(1)
+    end
+  end
+
+  describe "#enqueue_event" do
+    it "puts user event in event queue" do
+      subject.on_event :example_event, &block
+      expect {
+        subject.enqueue_event :example_event, param1: 123, param2: 345
+      }.to change(subject, :event_queue_size).by(1)
+    end
+    it "puts system event in event queue" do
+      system_event = subject.system_event_names.first
+      expect {
+        subject.enqueue_event system_event
+      }.to change(subject, :event_queue_size).by(1)
+    end
+    it "does not enqueue user event if has no handler" do
+      expect {
+        subject.enqueue_event :nonexistent_event, params: 23
+      }.to raise_error RuntimeError
+    end
+  end
+
+
+  describe "#serve_user_event" do
+    before :each do
+      subject.on_event :example_event, &block
+    end
+    it "serves first event from queue calling event handler" do
+      expect(block).to receive(:call).with(subject, { param1: 123, param2: 345 })
+      subject.enqueue_event :example_event, param1: 123, param2: 345
+      subject.serve_user_event
+    end
+    it "removes served event from queue" do
+      subject.enqueue_event :example_event
+      expect{ subject.serve_user_event }.to change(subject, :event_queue_size).by(-1)
+    end
+    it "refuses to serve system event" do
+      system_event = subject.system_event_names.first
+      subject.enqueue_event system_event
+      expect { subject.serve_user_event }.to raise_error RuntimeError
+    end
+  end
+
+  describe "#serve_system_event" do
+    let(:sysevent1){ subject.system_event_names[0] }
+    let(:sysevent2){ subject.system_event_names[1] }
+    it "serves first event from queue" do
+      subject.enqueue_event sysevent1, param1: 123, param2: 345
+      expect(subject.serve_system_event sysevent1).to eq({name: sysevent1, args: { param1: 123, param2: 345 } })
+    end
+    it "removes served event from queue" do
+      subject.enqueue_event sysevent1
+      expect{ subject.serve_system_event sysevent1 }.to change(subject, :event_queue_size).by(-1)
+    end
+    it "refuses to serve user event" do
+      subject.on_event :user_event do
+      end
+      subject.enqueue_event :user_event
+      expect { subject.serve_system_event :user_event}.to raise_error RuntimeError
+    end
+    it "raises error when event names do not match" do
+      subject.enqueue_event sysevent1
+      subject.enqueue_event sysevent2
+      expect{ subject.serve_system_event sysevent2 }.to raise_error RuntimeError
+    end
+
+  end
+
+  describe "#has_event?" do
+    before :each do
+      subject.on_event :example_event, &block
+    end
+
+    context "without event name" do
+      it "is true if user event is first in event queue" do
+        subject.enqueue_event :example_event
+        expect(subject.has_event?).to be true
+      end
+
+      it "is false if event queue is empty" do
+        expect(subject.has_event?).to be false
+      end
+
+      it "is true if system event is first in queue" do
+        system_event = subject.system_event_names.first
+        subject.enqueue_event system_event
+        expect(subject.has_event?).to be true
+      end
+    end
+
+    context "with event name" do
+      it "is false if event queue is empty" do
+        expect(subject.has_event? :example_event).to be false
+      end
+
+      it "is true if user event with given name is first in event queue" do
+        subject.enqueue_event :example_event
+        expect(subject.has_event? :example_event).to be true
+      end
+
+      it "is true if system event with given name is first in event queue" do
+        system_event = subject.system_event_names.first
+        subject.enqueue_event system_event
+        expect(subject.has_event? system_event).to be true
+      end
+
+      it "is false if user event with given name is not first in event queue" do
+        subject.enqueue_event :example_event
+        expect(subject.has_event? :other_event).to be false
+      end
+
+      it "is false if system event with given name is not first in event queue" do
+        system_event = subject.system_event_names[0]
+        other_system_event = subject.system_event_names[1]
+        subject.enqueue_event system_event
+        expect(subject.has_event? other_system_event).to be false
+      end
+    end
+  end
+
+  describe "#has_user_event?" do
+    before :each do
+      subject.on_event :example_event, &block
+    end
+
+    it "is true if user event is first in event queue" do
+      subject.enqueue_event :example_event
+      expect(subject.has_user_event?).to be true
+    end
+
+    it "is false if event queue is empty" do
+      expect(subject.has_user_event?).to be false
+    end
+
+    it "is false if system event is first in queue" do
+      system_event = subject.system_event_names.first
+      subject.enqueue_event system_event
+      expect(subject.has_user_event?).to be false
+    end
+  end
+
+  describe "#has_system_event?" do
+    before :each do
+      subject.on_event :example_event, &block
+    end
+
+    it "is false if user event is first in event queue" do
+      subject.enqueue_event :example_event
+      expect(subject.has_system_event?).to be false
+    end
+
+    it "is false if event queue is empty" do
+      expect(subject.has_system_event?).to be false
+    end
+
+    it "is true if system event is first in queue" do
+      system_event = subject.system_event_names.first
+      subject.enqueue_event system_event
+      expect(subject.has_system_event?).to be true
+    end
+  end
+
+end

data/spec/hlmodel/route_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "HLModel::Route" do
+
+    subject { RBSim::HLModel::Route.new :node01, :node02, [ :net01, :net02 ] }
+
+    describe "#next_net" do
+      it "iterates over subsequent net segments" do
+        expect(subject.next_net).to eq :net01
+        expect(subject.next_net).to eq :net02
+        expect{ subject.next_net }.to raise_error StopIteration
+      end
+    end
+
+    describe "#has_next_net?" do
+      it "is true if there are more nets to go" do
+        expect(subject.has_next_net?).to be true
+      end
+
+      it "is false it there are no more nets to go" do
+        2.times { subject.next_net }
+        expect(subject.has_next_net?).to be false
+      end
+    end
+
+    describe "#reverse!" do
+      context "twoway route" do
+        subject { RBSim::HLModel::Route.new :node01, :node02, [ :net01, :net02 ], true }
+        it "is reversed" do
+          src = subject.src
+          dst = subject.dst
+          subject.reverse!
+          expect(subject.src).to eq dst
+          expect(subject.dst).to eq src
+          expect(subject.next_net).to eq :net02
+          expect(subject.next_net).to eq :net01
+        end
+      end
+      context "oneway route" do
+        subject { model.routes[0] }
+        it "raises error" do
+          expect{ subject.reverse! }.to raise_error
+        end
+      end
+    end
+
+end

data/spec/hlmodel/routes_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe "HLModel::Routes" do
+
+  let(:routes) { RBSim::HLModel::Routes.new }
+
+  let(:oneway) { RBSim::HLModel::Route.new :node01, :node02, [ :net01, :net02 ] }
+  let(:twoway) { RBSim::HLModel::Route.new :node07, :node08, [ :net07, :net08 ], true }
+
+  describe "with oneway route" do
+    subject { routes.add oneway; routes }
+    it "finds the route" do
+      expect(subject.find(:node01, :node02)).to eq oneway
+    end
+    it "does not find reverse route" do
+      expect(subject.find(:node02, :node01)).to be nil
+    end
+  end
+
+  describe "with twoway route" do
+    subject { routes.add twoway; routes }
+    it "finds the route" do
+      expect(subject.find(:node07, :node08)).to eq twoway
+    end
+    it "finds reverse route" do
+      expect(subject.find(:node08, :node07)).to eq twoway.reverse!
+    end
+  end
+
+  describe "multiple routes for same endpoints" do
+    let(:oneway_alternative) { RBSim::HLModel::Route.new :node01, :node02, [ :net05, :net06 ] }
+    subject do
+      routes.add oneway
+      routes.add oneway_alternative
+      routes
+    end
+
+    # FIXME: how to test that it is random?
+    it "finds one of alternative routes" do
+      expect([oneway, oneway_alternative]).to include(subject.find :node01, :node02)
+    end
+  end
+
+end

data/spec/integration/basic_simulation_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe "Basic simulation example" do
+  let :model do
+
+    m = RBSim.model do
+
+      program :wget do |opts|
+        sent = 0
+        on_event :send do
+          cpu do |cpu|
+            150/cpu.performance
+          end
+          send_data to: opts[:target], size: 1024, type: :request, content: sent
+          sent += 1
+          delay_for 5*rand
+          register_event :send if sent < opts[:count]
+        end
+
+        on_event :data_received do |data|
+          #log "Got data #{data} in process #{process.name}"
+          stats tag: :request_served, group_name: process.name
+        end
+
+        register_event :send
+      end
+
+      program :apache do
+        log "apache starting"
+        on_event :data_received do |data|
+          stats_start tag: :apache, group_name: process.name
+          cpu do |cpu|
+            100*data.size*rand / cpu.performance
+          end
+          send_data to: data.src, size: data.size * 10, type: :response, content: data.content
+          stats_stop tag: :apache, group_name: process.name
+        end
+      end
+
+      program :just_load_cpu do
+        cpu do |cpu|
+          10
+        end
+      end
+
+      program :just_send do
+        send_data to: process.name, size: 1024, type: :request, content: :nothing_important
+        on_event :data_received do
+        end
+      end
+
+      node :desktop do
+        cpu 100, tags: { custom_tag: 'cpu_name1' }
+      end
+
+      node :gandalf do
+        cpu 1400, tags: { custom_tag: 'cpu_name2' }
+      end
+
+      node :whatever do
+        cpu 100
+      end
+
+      new_process :client1, program: :wget, args: { target: :server, count: 10 }, tags: { kind: :client }
+      new_process :client2, program: :wget, args: { target: :server, count: 10 }, tags: { kind: :client }
+      new_process :server, program: :apache, args: 'apache1', tags: { kind: :server }
+      new_process :cpu_loader, program: :just_load_cpu
+      new_process :net_loader, program: :just_send
+
+      net :net01, bw: 1024, tags: { custom_tag: 'name1' }
+      net :net02, bw: 510, tags: { custom_tag: 'name2' }
+      net :no_tags, bw: 1024
+
+      route from: :desktop, to: :gandalf, via: [ :net01, :net02 ], twoway: true
+      route from: :whatever, to: :whatever, via: [ :no_tags ]
+
+      put :server, on: :gandalf
+      put :client1, on: :desktop
+      put :client2, on: :desktop
+      put :cpu_loader, on: :whatever
+      put :net_loader, on: :whatever
+
+    end
+
+    m.data_fragmentation = 2
+    m
+  end
+
+  it "serves all requests" do
+    expect{ model.run }.to output("0.000: apache starting\n").to_stdout
+    expect(model.stats[:application].counters(group_name: :client1, tag: :request_served).to_h.values.flatten.size).to eq 10
+    expect(model.stats[:application].counters(group_name: :client2, tag: :request_served).to_h.values.flatten.size).to eq 10
+  end
+
+  it "saves resource stats with tags" do
+    model.run
+    expect(model.stats[:resources].durations(resource: 'NET', custom_tag: 'name1').to_a).not_to be_empty
+    expect(model.stats[:resources].durations(resource: 'NET', custom_tag: 'name2').to_a).not_to be_empty
+    expect(model.stats[:resources].durations(resource: 'CPU', custom_tag: 'cpu_name1').to_a).not_to be_empty
+    expect(model.stats[:resources].durations(resource: 'CPU', custom_tag: 'cpu_name2').to_a).not_to be_empty
+    expect(model.stats[:resources].durations(resource: 'DATAQ WAIT', kind: :client).to_a).not_to be_empty
+    expect(model.stats[:resources].durations(resource: 'DATAQ WAIT', kind: :server).to_a).not_to be_empty
+  end
+end

data/spec/integration/net_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe "Network model" do
+
+  let :model do
+    RBSim.model do
+      new_process :sender do
+        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: 1
+
+      put :sender, on: :sender
+      put :receiver, on: :receiver
+      route from: :sender, to: :receiver, via: [ :net01 ], toway: true
+    end
+  end
+
+  it "checks if a packet should be dropped" do
+    # for the sake of cloning we don't have the object that will
+    # receive the message at the beginning of simulation
+    # twice, because stats calls it too and that also counts
+    #
+    # http://stackoverflow.com/questions/9800992/how-to-say-any-instance-should-receive-any-number-of-times-in-rspec
+    allow(RBSim::HLModel::Net).to receive(:drop?)
+    allow_any_instance_of(RBSim::HLModel::Net).to receive(:drop?) { |*a| RBSim::HLModel::Net.drop? *a }
+
+    # twice in TCPN (arc to data and arc to net) and while collecting statistics
+    expect(RBSim::HLModel::Net).to receive(:drop?).exactly(3 * model.data_fragmentation) #.and_return true
+    model.run
+  end
+
+end