right_agent 0.6.6 → 0.9.3

data/spec/idempotent_request_spec.rb

@@ -44,11 +44,13 @@ describe RightScale::IdempotentRequest do
   end
 
   context ':targets option' do
-    context 'when :targets=>nil' do
+
+    context 'when :targets => nil' do
       it 'should send target-less requests' do
         request = RightScale::IdempotentRequest.new('type', 'payload')
         flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.non_delivery('test')).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
         request.run
       end
@@ -56,9 +58,10 @@ describe RightScale::IdempotentRequest do
 
     context 'when one target is specified' do
       it 'should send a targeted request' do
-        request = RightScale::IdempotentRequest.new('type', 'payload', :targets=>[1])
+        request = RightScale::IdempotentRequest.new('type', 'payload', :targets => [1])
         flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', 1, Proc).
             and_yield(RightScale::OperationResult.non_delivery('test')).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
         request.run
       end
@@ -66,71 +69,238 @@ describe RightScale::IdempotentRequest do
 
     context 'when many targets are specified' do
       it 'should choose a random target' do
-        request = RightScale::IdempotentRequest.new('type', 'payload', :targets=>[1, 2, 3])
+        request = RightScale::IdempotentRequest.new('type', 'payload', :targets => [1, 2, 3])
         flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).and_return do |type, payload, tgt, block|
           type.should == 'type'
           payload.should == 'payload'
-          [1,2,3].should include(tgt)
+          [1, 2, 3].should include(tgt)
           block.call(RightScale::OperationResult.non_delivery('test'))
         end
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
         request.run
       end
     end
-  end
 
-  it 'should retry non-delivery responses' do
-    request = RightScale::IdempotentRequest.new('type', 'payload')
-    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
-        and_yield(RightScale::OperationResult.non_delivery('test')).once
-    flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
-    request.run
   end
 
-  it 'should retry retry responses' do
-    request = RightScale::IdempotentRequest.new('type', 'payload')
-    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
-        and_yield(RightScale::OperationResult.retry('test')).once
-    flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
-    request.run
-  end
+  context ':retry_on_error option' do
 
-  it 'should fail in case of error responses by default' do
-    request = RightScale::IdempotentRequest.new('type', 'payload')
-    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
-        and_yield(RightScale::OperationResult.error('test')).once
-    flexmock(request).should_receive(:fail).once
-    request.run
-  end
+    context 'when not specified' do
+      it 'should fail if receives error response' do
+        request = RightScale::IdempotentRequest.new('type', 'payload')
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.error('test')).once
+        flexmock(request).should_receive(:fail).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        request.run
+      end
+    end
+    
+    context 'when specified as true' do
+      it 'should retry if receives error response' do
+        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_on_error => true)
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.error('test')).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        request.run
+      end
+
+      it 'should ignore duplicate responses' do
+        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_on_error => true)
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).and_return do |t, p, tgt, b|
+          5.times { b.call(RightScale::OperationResult.success('test')) }
+        end
+        flexmock(request).should_receive(:fail).never
+        flexmock(request).should_receive(:succeed).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).never
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        request.run
+      end
+
+      it 'should never retry after cancel response' do
+        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_on_error => true)
+        flexmock(RightScale::Log).should_receive(:info).with("Request type canceled (enough already)").once
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.cancel('enough already')).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).never
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        request.run
+      end
+    end
 
-  it 'should retry error responses when told to' do
-    request = RightScale::IdempotentRequest.new('type', 'payload', :retry_on_error => true)
-    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
-        and_yield(RightScale::OperationResult.error('test')).once
-    flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
-    request.run
   end
 
-  it 'should ignore responses that arrive post-cancel' do
-    request = RightScale::IdempotentRequest.new('type', 'payload')
-    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
-        and_yield(RightScale::OperationResult.success('test')).once
-    flexmock(request).should_receive(:fail).once
-    flexmock(request).should_receive(:succeed).never
-    flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).never
-    request.cancel('test')
-    request.run
+  context ':retry_delay options' do
+
+    context 'when using default settings' do
+      it 'should retry non-delivery responses' do
+        request = RightScale::IdempotentRequest.new('type', 'payload')
+        flexmock(RightScale::Log).should_receive(:info).with(/Retrying in 5 seconds/).once
+        flexmock(RightScale::Log).should_receive(:info).with("Request non-delivery (test) for type").once
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.non_delivery('test')).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        request.run
+      end
+
+      it 'should retry retry responses' do
+        request = RightScale::IdempotentRequest.new('type', 'payload')
+        flexmock(RightScale::Log).should_receive(:info).with(/Retrying in 5 seconds/).once
+        flexmock(RightScale::Log).should_receive(:info).with("Request type failed (test) and should be retried").once
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.retry('test')).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        request.run
+      end
+
+      it 'should log default retry reason if none given' do
+        request = RightScale::IdempotentRequest.new('type', 'payload')
+        flexmock(RightScale::Log).should_receive(:info).with(/Retrying in 5 seconds/).once
+        flexmock(RightScale::Log).should_receive(:info).with("Request type failed (RightScale not ready) and should be retried").once
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.retry).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        request.run
+      end
+
+      it 'should ignore responses that arrive post-cancel' do
+        request = RightScale::IdempotentRequest.new('type', 'payload')
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.success('test')).once
+        flexmock(request).should_receive(:fail).once
+        flexmock(request).should_receive(:succeed).never
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).never
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        request.cancel('test')
+        request.run
+      end
+
+      it 'should never retry after cancel response' do
+        request = RightScale::IdempotentRequest.new('type', 'payload')
+        flexmock(RightScale::Log).should_receive(:info).with("Request type canceled (enough already)").once
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.cancel('enough already')).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).never
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        request.run
+      end
+    end
+
+    context 'when a :retry_delay is specified' do
+      it 'should control the initial retry delay' do
+        retry_delay = 10
+        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_delay => retry_delay)
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.retry('test')).once
+        flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:next_tick).never
+        request.run
+      end
+
+      it 'should treat -1 as meaning no delay' do
+        retry_delay = -1
+        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_delay => retry_delay)
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.retry('test')).once
+        flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).never
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:next_tick).once
+        request.run
+      end
+    end
+
+    context 'when a :retry_delay_count is specified' do
+      it 'should limit the number of retries using the :retry_delay value' do
+        retry_delay = 10
+        retry_delay_count = 1
+        backoff_factor = RightScale::IdempotentRequest::RETRY_BACKOFF_FACTOR
+        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_delay => retry_delay,
+                                                    :retry_delay_count => retry_delay_count)
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.retry('test')).twice
+        flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).and_yield.once
+        flexmock(EM).should_receive(:add_timer).with(retry_delay * backoff_factor, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:next_tick).never
+        request.run
+      end
+
+      it 'should backoff as delay time increases' do
+        retry_delay = 10
+        retry_delay_count = 2
+        max_retry_delay = 30
+        backoff_factor = RightScale::IdempotentRequest::RETRY_BACKOFF_FACTOR
+        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_delay => retry_delay,
+                                                    :retry_delay_count => retry_delay_count,
+                                                    :max_retry_delay => max_retry_delay)
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.retry('test')).times(4)
+        flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).and_yield.twice
+        flexmock(EM).should_receive(:add_timer).with(retry_delay * backoff_factor, Proc).and_yield.once
+        flexmock(EM).should_receive(:add_timer).with(max_retry_delay, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:next_tick).never
+        request.run
+        request.instance_variable_get(:@retry_delay_count).should == retry_delay_count / 2
+      end
+    end
+
+    context 'when a :max_retry_delay is specified' do
+      it 'should limit the retry delay total backoff' do
+        retry_delay = 10
+        retry_delay_count = 1
+        max_retry_delay = 30
+        backoff_factor = RightScale::IdempotentRequest::RETRY_BACKOFF_FACTOR
+        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_delay => retry_delay,
+                                                    :retry_delay_count => retry_delay_count,
+                                                    :max_retry_delay => max_retry_delay)
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.retry('test')).times(3)
+        flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).and_yield.once
+        flexmock(EM).should_receive(:add_timer).with(retry_delay * backoff_factor, Proc).and_yield.once
+        flexmock(EM).should_receive(:add_timer).with(max_retry_delay, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:next_tick).never
+        request.run
+      end
+    end
+
   end
 
-  it 'should ignore duplicate responses' do
-    request = RightScale::IdempotentRequest.new('type', 'payload', :retry_on_error => true)
-    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).and_return do |t, p, tgt, b|
-      5.times { b.call(RightScale::OperationResult.success('test')) }
+  context ':timeout option' do
+    context 'when disable timeout' do
+      it 'should not timeout' do
+        request = RightScale::IdempotentRequest.new('type', 'payload', :timeout => -1)
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).once
+        flexmock(EM).should_receive(:add_timer).never
+        request.run
+      end
+    end
+
+    context 'when a timeout is specified' do
+      it 'should time the response' do
+        timeout = 10
+        request = RightScale::IdempotentRequest.new('type', 'payload', :timeout => timeout)
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(timeout, Proc).once
+        request.run
+      end
+
+      it 'should log a message when timeout' do
+        timeout = 10
+        request = RightScale::IdempotentRequest.new('type', 'payload', :timeout => timeout)
+        flexmock(RightScale::Log).should_receive(:info).with("Request type timed out after 10 seconds").once
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(timeout, Proc).and_yield.once
+        request.run
+      end
     end
-    flexmock(request).should_receive(:fail).never
-    flexmock(request).should_receive(:succeed).once
-    flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, nil, Proc).never
-    request.run
   end
 
 end

data/spec/operation_result_spec.rb

@@ -140,6 +140,13 @@ describe RightScale::OperationResult do
       result.non_delivery?.should be_true
       result.content.should == "Non-delivery"
     end
+
+    it "should store cancel content value and respond to cancel query" do
+      result = RightScale::OperationResult.cancel("Cancel")
+      result.kind_of?(RightScale::OperationResult).should be_true
+      result.cancel?.should be_true
+      result.content.should == "Cancel"
+    end
   end
 
   describe "when converting result to string" do
@@ -160,12 +167,24 @@ describe RightScale::OperationResult do
       result.status.should == "error"
     end
 
+    it "should display retry reason" do
+      result = RightScale::OperationResult.retry("because")
+      result.to_s.should == "retry (because)"
+      result.status.should == "retry"
+    end
+
     it "should display non-delivery reason" do
       result = RightScale::OperationResult.non_delivery(RightScale::OperationResult::TTL_EXPIRATION)
       result.to_s.should == "non-delivery (TTL expiration)"
       result.status.should == "non-delivery"
     end
 
+    it "should display cancel reason" do
+      result = RightScale::OperationResult.cancel("enough already")
+      result.to_s.should == "cancel (enough already)"
+      result.status.should == "cancel"
+    end
+
   end
 
 end

data/spec/packets_spec.rb

@@ -65,7 +65,7 @@ describe "Packet: Base class" do
     packet.to_s(filter = nil, version = :send_version).should == "[test_packet v5]"
   end
 
-  it "should convert to string including duration if filtered and size is also known" do
+  it "should convert to string including duration if filtered and size known" do
     packet = TestPacket.new(1, 0.042122, 323)
     packet.to_s(filter = nil).should == "[test_packet] (323 bytes, 0.042 sec)"
     packet.to_s(filter = []).should == "[test_packet] (323 bytes)"
@@ -74,6 +74,17 @@ describe "Packet: Base class" do
     packet.to_s(filter = [:duration]).should == "[test_packet]"
   end
 
+  it "should convert to string including local duration if filtered and size known" do
+    flexmock(Time).should_receive(:now).and_return(Time.at(1000000), Time.at(1000000.012))
+    packet = TestPacket.new(1, nil, 323)
+    packet.received_at = Time.now.to_f
+    packet.to_s(filter = nil).should == "[test_packet] (323 bytes, 0.012 sec)"
+    packet.to_s(filter = []).should == "[test_packet] (323 bytes)"
+    packet.to_s(filter = [:local_duration]).should == "[test_packet] (323 bytes, 0.012 sec)"
+    packet = TestPacket.new(1)
+    packet.to_s(filter = [:local_duration]).should == "[test_packet]"
+  end
+
   it "should convert floating point values to decimal digit string with at least two digit precision" do
     packet = TestPacket.new(1)
     packet.enough_precision(100.5).should == "101"
@@ -125,6 +136,12 @@ describe "Packet: Base class" do
       packet.to_msgpack.should_not =~ /cls_attr/
     end
 
+    it "should not dump excluded instance variables" do
+      packet = TestPacket.new(382)
+      packet.received_at = Time.now.to_f
+      packet.to_msgpack.should_not =~ /received_at/
+    end
+
     it "should remove '@' from instance variables" do
       packet = TestPacket.new(2)
       packet.to_msgpack.should_not =~ /@attr1/
@@ -157,6 +174,12 @@ describe "Packet: Base class" do
       packet.to_json.should_not =~ /cls_attr/
     end
 
+    it "should not dump excluded instance variables" do
+      packet = TestPacket.new(382)
+      packet.received_at = Time.now.to_f
+      packet.to_json.should_not =~ /received_at/
+    end
+
     it "should remove '@' from instance variables" do
       packet = TestPacket.new(2)
       packet.to_json.should_not =~ /@attr1/
@@ -251,6 +274,15 @@ describe "Packet: Request" do
     MessagePack.load(packet.to_msgpack).send_version.should == RightScale::Packet::DEFAULT_VERSION
     JSON.load(packet.to_json).send_version.should == RightScale::Packet::DEFAULT_VERSION
   end
+
+  it "should handle either a single target or an array" do
+    packet = RightScale::Request.new('/some/foo', 'payload', :target => "target1")
+    packet.token = 123
+    packet.to_s([:target]).should == '[request] <> <123> /some/foo, target target1'
+    packet = RightScale::Request.new('/some/foo', 'payload', :target => ["target1", "target2"])
+    packet.token = 123
+    packet.to_s([:target]).should == "[request] <> <123> /some/foo, target [target1, target2]"
+  end
 end
 
 
@@ -331,6 +363,15 @@ describe "Packet: Push" do
     MessagePack.load(packet.to_msgpack).send_version.should == RightScale::Packet::DEFAULT_VERSION
     JSON.load(packet.to_json).send_version.should == RightScale::Packet::DEFAULT_VERSION
   end
+
+  it "should handle either a single target or an array" do
+    packet = RightScale::Push.new('/some/foo', 'payload', :target => "target1")
+    packet.token = 123
+    packet.to_s([:target]).should == '[push] <> <123> /some/foo, target target1'
+    packet = RightScale::Push.new('/some/foo', 'payload', :target => ["target1", "target2"])
+    packet.token = 123
+    packet.to_s([:target]).should == "[push] <> <123> /some/foo, target [target1, target2]"
+  end
 end
 
 

data/spec/platform/darwin.rb

@@ -0,0 +1,11 @@
+module RightScale
+  describe Platform do
+    subject { RightScale::Platform }
+    
+    context :installer do
+      context :install do
+        specify { lambda { subject.installer.install([]) }.should raise_exception }
+      end
+    end
+  end
+end

data/spec/platform/linux.rb

@@ -0,0 +1,23 @@
+module RightScale
+  describe Platform do
+    
+    context :installer do
+      context :install do
+        it 'should succeed if no packages are specified' do
+          packages = []
+          RightScale::Platform.installer.install(packages).should == true
+        end
+        
+        it 'should succeed if all packages install successfully' do
+          packages = ['syslog-ng']
+          RightScale::Platform.installer.install(packages).should == true
+        end
+        
+        it 'should fail if one more packages are not found' do
+          packages = ['jdk-6u26-linux-x64']
+          lambda { RightScale::Platform.installer.install(packages) }.should raise_error
+        end
+      end
+    end
+  end
+end

data/spec/platform/linux_volume_manager_spec.rb

@@ -32,10 +32,10 @@ if RightScale::Platform.linux?
       context :parse_volumes do
         it 'can parse volumes from blkid output' do
           blkid_resp = <<EOF
-  /dev/xvdh1: SEC_TYPE="msdos" LABEL="METADATA" UUID="681B-8C5D" TYPE="vfat"
-  /dev/xvdb1: LABEL="SWAP-xvdb1" UUID="d51fcca0-6b10-4934-a572-f3898dfd8840" TYPE="swap"
-  /dev/xvda1: UUID="f4746f9c-0557-4406-9267-5e918e87ca2e" TYPE="ext3"
-  /dev/xvda2: UUID="14d88b9e-9fe6-4974-a8d6-180acdae4016" TYPE="ext3"
+/dev/xvdh1: SEC_TYPE="msdos" LABEL="METADATA" UUID="681B-8C5D" TYPE="vfat"
+/dev/xvdb1: LABEL="SWAP-xvdb1" UUID="d51fcca0-6b10-4934-a572-f3898dfd8840" TYPE="swap"
+/dev/xvda1: UUID="f4746f9c-0557-4406-9267-5e918e87ca2e" TYPE="ext3"
+/dev/xvda2: UUID="14d88b9e-9fe6-4974-a8d6-180acdae4016" TYPE="ext3"
 EOF
           volume_hash_ary = [
             {:device => "/dev/xvdh1", :sec_type => "msdos", :label => "METADATA", :uuid => "681B-8C5D", :type => "vfat", :filesystem => "vfat"},
@@ -61,10 +61,10 @@ EOF
 
         it 'can filter results with only one condition' do
           blkid_resp = <<EOF
-  /dev/xvdh1: SEC_TYPE="msdos" LABEL="METADATA" UUID="681B-8C5D" TYPE="vfat"
-  /dev/xvdb1: LABEL="SWAP-xvdb1" UUID="d51fcca0-6b10-4934-a572-f3898dfd8840" TYPE="swap"
-  /dev/xvda1: UUID="f4746f9c-0557-4406-9267-5e918e87ca2e" TYPE="ext3"
-  /dev/xvda2: UUID="14d88b9e-9fe6-4974-a8d6-180acdae4016" TYPE="ext3"
+/dev/xvdh1: SEC_TYPE="msdos" LABEL="METADATA" UUID="681B-8C5D" TYPE="vfat"
+/dev/xvdb1: LABEL="SWAP-xvdb1" UUID="d51fcca0-6b10-4934-a572-f3898dfd8840" TYPE="swap"
+/dev/xvda1: UUID="f4746f9c-0557-4406-9267-5e918e87ca2e" TYPE="ext3"
+/dev/xvda2: UUID="14d88b9e-9fe6-4974-a8d6-180acdae4016" TYPE="ext3"
 EOF
           volume_hash_ary = [
             {:device => "/dev/xvdh1", :sec_type => "msdos", :label => "METADATA", :uuid => "681B-8C5D", :type => "vfat", :filesystem => "vfat"}
@@ -77,10 +77,10 @@ EOF
 
         it 'can filter results with many conditions' do
           blkid_resp = <<EOF
-  /dev/xvdh1: SEC_TYPE="msdos" LABEL="METADATA" UUID="681B-8C5D" TYPE="vfat"
-  /dev/xvdb1: LABEL="SWAP-xvdb1" UUID="d51fcca0-6b10-4934-a572-f3898dfd8840" TYPE="swap"
-  /dev/xvda1: UUID="f4746f9c-0557-4406-9267-5e918e87ca2e" TYPE="ext3"
-  /dev/xvda2: UUID="14d88b9e-9fe6-4974-a8d6-180acdae4016" TYPE="ext3"
+/dev/xvdh1: SEC_TYPE="msdos" LABEL="METADATA" UUID="681B-8C5D" TYPE="vfat"
+/dev/xvdb1: LABEL="SWAP-xvdb1" UUID="d51fcca0-6b10-4934-a572-f3898dfd8840" TYPE="swap"
+/dev/xvda1: UUID="f4746f9c-0557-4406-9267-5e918e87ca2e" TYPE="ext3"
+/dev/xvda2: UUID="14d88b9e-9fe6-4974-a8d6-180acdae4016" TYPE="ext3"
 EOF
           volume_hash_ary = [
             {:device => "/dev/xvda1", :uuid => "f4746f9c-0557-4406-9267-5e918e87ca2e", :type => "ext3", :filesystem => "ext3"},
@@ -96,8 +96,8 @@ EOF
       context :mount_volume do
         it 'mounts the specified volume if it is not already mounted' do
           mount_resp = <<EOF
-  /dev/xvda2 on / type ext3 (rw,noatime,errors=remount-ro)
-  proc on /proc type proc (rw,noexec,nosuid,nodev)
+/dev/xvda2 on / type ext3 (rw,noatime,errors=remount-ro)
+proc on /proc type proc (rw,noexec,nosuid,nodev)
 EOF
 
           mount_popen_mock = flexmock(:read => mount_resp)
@@ -109,9 +109,9 @@ EOF
 
         it 'does not attempt to re-mount the volume' do
           mount_resp = <<EOF
-  /dev/xvda2 on / type ext3 (rw,noatime,errors=remount-ro)
-  proc on /proc type proc (rw,noexec,nosuid,nodev)
-  /dev/xvdh1 on /var/spool/softlayer type vfat (rw) [METADATA]
+/dev/xvda2 on / type ext3 (rw,noatime,errors=remount-ro)
+proc on /proc type proc (rw,noexec,nosuid,nodev)
+/dev/xvdh1 on /var/spool/softlayer type vfat (rw) [METADATA]
 EOF
 
           mount_popen_mock = flexmock(:read => mount_resp)
@@ -131,19 +131,19 @@ EOF
 
         it 'raises volume error when the device is already mounted to a different mountpoint' do
           mount_resp = <<EOF
-  /dev/xvda2 on / type ext3 (rw,noatime,errors=remount-ro)
-  proc on /proc type proc (rw,noexec,nosuid,nodev)
-  none on /sys type sysfs (rw,noexec,nosuid,nodev)
-  none on /sys/kernel/debug type debugfs (rw)
-  none on /sys/kernel/security type securityfs (rw)
-  none on /dev type devtmpfs (rw,mode=0755)
-  none on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=0620)
-  none on /dev/shm type tmpfs (rw,nosuid,nodev)
-  none on /var/run type tmpfs (rw,nosuid,mode=0755)
-  none on /var/lock type tmpfs (rw,noexec,nosuid,nodev)
-  none on /lib/init/rw type tmpfs (rw,nosuid,mode=0755)
-  /dev/xvda1 on /boot type ext3 (rw,noatime)
-  /dev/xvdh1 on /mnt type vfat (rw) [METADATA]
+/dev/xvda2 on / type ext3 (rw,noatime,errors=remount-ro)
+proc on /proc type proc (rw,noexec,nosuid,nodev)
+none on /sys type sysfs (rw,noexec,nosuid,nodev)
+none on /sys/kernel/debug type debugfs (rw)
+none on /sys/kernel/security type securityfs (rw)
+none on /dev type devtmpfs (rw,mode=0755)
+none on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=0620)
+none on /dev/shm type tmpfs (rw,nosuid,nodev)
+none on /var/run type tmpfs (rw,nosuid,mode=0755)
+none on /var/lock type tmpfs (rw,noexec,nosuid,nodev)
+none on /lib/init/rw type tmpfs (rw,nosuid,mode=0755)
+/dev/xvda1 on /boot type ext3 (rw,noatime)
+/dev/xvdh1 on /mnt type vfat (rw) [METADATA]
 EOF
 
           mount_popen_mock = flexmock(:read => mount_resp)
@@ -154,19 +154,19 @@ EOF
 
         it 'raises volume error when a different device is already mounted to the specified mountpoint' do
           mount_resp = <<EOF
-  /dev/xvda2 on / type ext3 (rw,noatime,errors=remount-ro)
-  proc on /proc type proc (rw,noexec,nosuid,nodev)
-  none on /sys type sysfs (rw,noexec,nosuid,nodev)
-  none on /sys/kernel/debug type debugfs (rw)
-  none on /sys/kernel/security type securityfs (rw)
-  none on /dev type devtmpfs (rw,mode=0755)
-  none on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=0620)
-  none on /dev/shm type tmpfs (rw,nosuid,nodev)
-  none on /var/run type tmpfs (rw,nosuid,mode=0755)
-  none on /var/lock type tmpfs (rw,noexec,nosuid,nodev)
-  none on /lib/init/rw type tmpfs (rw,nosuid,mode=0755)
-  /dev/xvda1 on /boot type ext3 (rw,noatime)
-  /dev/xvdh2 on /var/spool/softlayer type vfat (rw) [METADATA]
+/dev/xvda2 on / type ext3 (rw,noatime,errors=remount-ro)
+proc on /proc type proc (rw,noexec,nosuid,nodev)
+none on /sys type sysfs (rw,noexec,nosuid,nodev)
+none on /sys/kernel/debug type debugfs (rw)
+none on /sys/kernel/security type securityfs (rw)
+none on /dev type devtmpfs (rw,mode=0755)
+none on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=0620)
+none on /dev/shm type tmpfs (rw,nosuid,nodev)
+none on /var/run type tmpfs (rw,nosuid,mode=0755)
+none on /var/lock type tmpfs (rw,noexec,nosuid,nodev)
+none on /lib/init/rw type tmpfs (rw,nosuid,mode=0755)
+/dev/xvda1 on /boot type ext3 (rw,noatime)
+/dev/xvdh2 on /var/spool/softlayer type vfat (rw) [METADATA]
 EOF
 
           mount_popen_mock = flexmock(:read => mount_resp)