squall 0.0.3 → 1.0.0

data/spec/squall/virtual_machine_spec.rb

@@ -0,0 +1,471 @@
+require 'spec_helper'
+
+describe Squall::VirtualMachine do
+  before(:each) do
+    default_config
+    @virtual_machine = Squall::VirtualMachine.new
+    @valid = {:label => 'testmachine', :hypervisor_id => 5, :hostname => 'testmachine', :memory => 512, :cpus => 1,
+              :cpu_shares => 10, :primary_disk_size => 10}
+    @keys = ["monthly_bandwidth_used", "cpus", "label", "created_at", "operating_system_distro",
+      "cpu_shares", "operating_system", "template_id", "allowed_swap", "local_remote_access_port",
+      "memory", "updated_at", "allow_resize_without_reboot", "recovery_mode", "hypervisor_id", "id",
+      "xen_id", "user_id", "total_disk_size", "booted", "hostname", "template_label", "identifier",
+      "initial_root_password", "min_disk_size", "remote_access_password", "built", "locked", "ip_addresses"]
+  end
+
+  describe "#list" do
+    use_vcr_cassette "virtual_machine/list"
+
+    it "returns a virtual_machine list" do
+      virtual_machines = @virtual_machine.list
+      virtual_machines.size.should be(2)
+    end
+
+    it "contains first virtual_machines data" do
+      virtual_machine = @virtual_machine.list.first
+      virtual_machine.keys.should include(*@keys)
+      virtual_machine['label'].should == 'ohhai.server.com'
+    end
+  end
+
+  describe "#show" do
+    use_vcr_cassette "virtual_machine/show"
+    it "requires an id" do
+      expect { @virtual_machine.show }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.show(404) }.to raise_error(Squall::NotFound)
+    end
+
+    it "returns a virtual_machine" do
+      virtual_machine = @virtual_machine.show(1)
+      virtual_machine.keys.should include(*@keys)
+      virtual_machine['label'].should == 'bob'
+    end
+  end
+
+  describe "#create" do
+    use_vcr_cassette "virtual_machine/create"
+    #  validates :label, :hypervisor_id, :hostname, :memory, :cpus, :presence => true
+    it "requires label" do
+      requires_attr(:label) { @virtual_machine.create }
+    end
+
+    it "requires hypervisor_id" do
+      requires_attr(:hypervisor_id) { @virtual_machine.create(:label => @valid[:label]) }
+    end
+
+    it "requires hostname" do
+      requires_attr(:hostname) {
+        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id])
+      }
+    end
+
+    it "requires memory" do
+      requires_attr(:memory) {
+        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id], :hostname => @valid[:hostname])
+      }
+    end
+
+    it "requires cpus" do
+      requires_attr(:cpus) {
+        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id], :hostname => @valid[:hostname],
+                                :memory => @valid[:memory])
+      }
+    end
+
+    it "requires cpu_shares" do
+      requires_attr(:cpu_shares) {
+        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id], :hostname => @valid[:hostname],
+                                :memory => @valid[:memory], :cpus => @valid[:cpu_shares])
+      }
+    end
+
+    it "requires primary_disk_size" do
+      requires_attr(:primary_disk_size) {
+        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id],
+                                :hostname => @valid[:hostname], :memory => @valid[:memory], :cpus => @valid[:cpu_shares],
+                                :cpu_shares => @valid[:cpu_shares])
+      }
+    end
+
+    it "raises error on unknown params" do
+      expect {
+        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id], :hostname => @valid[:hostname],
+                                :memory => @valid[:memory], :cpus => @valid[:cpus], :cpu_shares => @valid[:cpu_shares], :what => 'what')
+      }.to raise_error(ArgumentError, 'Missing required params: primary_disk_size')
+    end
+
+    it "allows all optional params" do
+      optional = [:cpu_shares,
+                  :swap_disk_size,
+                  :primary_network_id,
+                  :required_automatic_backup,
+                  :rate_limit,
+                  :required_ip_address_assignment,
+                  :required_virtual_machine_build,
+                  :admin_note,
+                  :note,
+                  :allowed_hot_migrate,
+                  :template_id,
+                  :initial_root_password
+      ]
+
+      @virtual_machine.should_receive(:request).exactly(optional.size).times.and_return Hash.new('virtual_machine' => [])
+      optional.each do |k,v|
+        @virtual_machine.create(@valid.merge(k.to_sym => v))
+      end
+    end
+
+    it "creates a virtual_machine" do
+      virtual_machine = @virtual_machine.create(@valid)
+      @valid.each do |k,v|
+        virtual_machine[k].should == @valid[k.to_s]
+      end
+    end
+  end
+
+  describe "#build" do
+    use_vcr_cassette "virtual_machine/build"
+    it "requires an id" do
+      expect { @virtual_machine.build }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "accepts :template_id and :required_startup" do
+      hash = [:post, "/virtual_machines/1/build.json", {:query=>{:virtual_machine=>{:template_id=>1, :required_startup=>1}}}]
+      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
+      @virtual_machine.build(1, :template_id => 1, :required_startup => 1)
+    end
+
+    it "raises error on unknown params" do
+      expect { @virtual_machine.build(1, :asdf => 1) }.to raise_error(ArgumentError, 'Unknown params: asdf')
+      @virtual_machine.success.should be_false
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.build(404) }.to raise_error(Squall::NotFound)
+      @virtual_machine.success.should be_false
+    end
+
+    it "builds the VM" do
+      build = @virtual_machine.build(72)
+
+      @virtual_machine.success.should be_true
+      build['label'].should == 'Testingagain'
+    end
+  end
+
+  describe "#edit" do
+    use_vcr_cassette "virtual_machine/edit"
+
+    it "requires an id" do
+      expect { @virtual_machine.edit }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "raises error on unknown params" do
+      expect { @virtual_machine.edit(1, :blah => 1) }.to raise_error(ArgumentError, 'Unknown params: blah')
+      @virtual_machine.success.should be_false
+    end
+
+    it "404s on not found" do
+      expect { @virtual_machine.edit(404, :label => 1) }.to raise_error(Squall::NotFound)
+    end
+
+    it "accepts all valid keys" do
+      keys = [:label,
+              :hypervisor_id,
+              :hostname,
+              :memory,
+              :cpus,
+              :cpu_shares,
+              :primary_disk_size,
+              :cpu_shares,
+              :swap_disk_size,
+              :primary_network_id,
+              :required_automatic_backup,
+              :rate_limit,
+              :required_ip_address_assignment,
+              :required_virtual_machine_build,
+              :admin_note,
+              :note,
+              :allowed_hot_migrate,
+              :template_id,
+              :initial_root_password
+      ]
+      keys.each do |k|
+        opts = @virtual_machine.default_params(k.to_sym => 1)
+        args = [:put, '/virtual_machines/1.json', opts]
+        @virtual_machine.should_receive(:request).with(*args).once.and_return([])
+        @virtual_machine.edit(1, k.to_sym => 1 )
+      end
+    end
+
+    it "updates the label" do
+      @virtual_machine.edit(1, :label => 'testing')
+      @virtual_machine.success.should be_true
+    end
+  end
+
+  describe "#change_owner" do
+    use_vcr_cassette "virtual_machine/change_owner"
+    it "requires an id" do
+      expect { @virtual_machine.change_owner }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "requires a user_id" do
+      expect { @virtual_machine.change_owner 1 }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "404s on not found" do
+      expect { @virtual_machine.change_owner(404, 1) }.to raise_error(Squall::NotFound)
+      @virtual_machine.success.should be_false
+    end
+
+    it "returns error on unknown user" do
+      expect { @virtual_machine.change_owner(1, 404) }.to raise_error(Squall::ServerError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "changes the user" do
+      result = @virtual_machine.change_owner(1, 2)
+      @virtual_machine.success.should be_true
+
+      result['user_id'].should == 2
+    end
+  end
+
+  describe "#change_password" do
+    use_vcr_cassette "virtual_machine/change_password"
+    it "requires an id" do
+      expect { @virtual_machine.change_password }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "requires a password" do
+      expect { @virtual_machine.change_password 1 }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "404s on not found" do
+      expect { @virtual_machine.change_password(404, 'password') }.to raise_error(Squall::NotFound)
+      @virtual_machine.success.should be_false
+    end
+
+    it "changes the password" do
+      result = @virtual_machine.change_password(1, 'passwordsareimportant')
+      @virtual_machine.success.should be_true
+    end
+  end
+
+  describe "#migrate" do
+    use_vcr_cassette "virtual_machine/migrate"
+    it "requires an id" do
+      expect { @virtual_machine.migrate }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "requires a destination" do
+      requires_attr(:destination) { @virtual_machine.migrate 1 }
+      @virtual_machine.success.should be_false
+    end
+
+    it "accepts cold_migrate_on_rollback" do
+      hash = [:post, "/virtual_machines/1/migrate.json", {:query => {:destination => 1, :cold_migrate_on_rollback => 1} }]
+      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
+      @virtual_machine.migrate 1, :destination => 1, :cold_migrate_on_rollback => 1
+    end
+
+    it "404s on not found" do
+      expect { @virtual_machine.migrate(404, :destination => 1) }.to raise_error(Squall::NotFound)
+      @virtual_machine.success.should be_false
+    end
+
+    it "returns error on unknown destination" do
+      pending "Broken in OnApp" do
+        expect { @virtual_machine.migrate(1, :destination => 404) }.to raise_error(Squall::ServerError)
+        @virtual_machine.success.should be_false
+      end
+    end
+
+    it "changes the destination" do
+      pending "Broken in OnApp" do
+        result = @virtual_machine.migrate(1, :destination => 2)
+        @virtual_machine.success.should be_true
+        result['hypervisor_id'].should == 2
+      end
+    end
+  end
+
+  describe "#delete" do
+    use_vcr_cassette "virtual_machine/delete"
+    it "requires an id" do
+      expect { @virtual_machine.delete }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.delete(404) }.to raise_error(Squall::NotFound)
+    end
+
+    it "deletes a virtual_machine" do
+      virtual_machine = @virtual_machine.delete(2)
+      @virtual_machine.success.should be_true
+    end
+  end
+
+  describe "#resize" do
+    use_vcr_cassette "virtual_machine/resize"
+    it "requires an id" do
+      expect { @virtual_machine.resize }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.resize(404, :memory => 1) }.to raise_error(Squall::NotFound)
+    end
+
+    it "requires memory" do
+      @virtual_machine.stub(:request)
+      requires_attr(:memory) { @virtual_machine.resize(1) }
+    end
+
+    it "accepts allow_migration" do
+      hash = [:post, "/virtual_machines/1/resize.json",  @virtual_machine.default_params(:memory => 1, :allow_migration => 1)]
+      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
+      @virtual_machine.resize 1, :memory => 1, :allow_migration => 1
+    end
+
+    it "resizes a virtual_machine" do
+      virtual_machine = @virtual_machine.resize(2, :memory => 1000)
+      @virtual_machine.success.should be_true
+
+      virtual_machine['memory'].should == 1000
+    end
+  end
+
+  describe "#suspend" do
+    use_vcr_cassette "virtual_machine/suspend"
+    it "requires an id" do
+      expect { @virtual_machine.suspend }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.suspend(404) }.to raise_error(Squall::NotFound)
+    end
+
+    it "suspends a virtual_machine" do
+      virtual_machine = @virtual_machine.suspend(1)
+      virtual_machine['suspended'].should be_true
+    end
+  end
+
+  describe "#unsuspend" do
+    use_vcr_cassette "virtual_machine/unsuspend"
+    it "requires an id" do
+      expect { @virtual_machine.unsuspend }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.unsuspend(404) }.to raise_error(Squall::NotFound)
+    end
+
+    it "unsuspends a virtual_machine" do
+      virtual_machine = @virtual_machine.unsuspend(1)
+      virtual_machine['suspended'].should be_false
+    end
+  end
+
+  describe "#unlock" do
+    use_vcr_cassette "virtual_machine/unlock"
+    it "requires an id" do
+      expect { @virtual_machine.unlock }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.unlock(404) }.to raise_error(Squall::NotFound)
+    end
+
+    it "unlocks a virtual_machine" do
+      virtual_machine = @virtual_machine.unlock(1)
+      virtual_machine['locked'].should be_false
+    end
+  end
+
+  describe "#startup" do
+    use_vcr_cassette "virtual_machine/startup"
+    it "requires an id" do
+      expect { @virtual_machine.startup }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.startup(404) }.to raise_error(Squall::NotFound)
+      @virtual_machine.success.should be_false
+    end
+
+    it "startups a virtual_machine" do
+      @virtual_machine.startup(1)
+      @virtual_machine.success.should be_true
+    end
+  end
+
+  describe "#shutdown" do
+    use_vcr_cassette "virtual_machine/shutdown"
+    it "requires an id" do
+      expect { @virtual_machine.shutdown }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.shutdown(404) }.to raise_error(Squall::NotFound)
+      @virtual_machine.success.should be_false
+    end
+
+    it "will shutdown a virtual_machine" do
+      virtual_machine = @virtual_machine.shutdown(1)
+      @virtual_machine.success.should be_true
+      virtual_machine['id'].should == 1
+    end
+  end
+
+  describe "#stop" do
+    use_vcr_cassette "virtual_machine/stop"
+    it "requires an id" do
+      expect { @virtual_machine.stop }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.stop(404) }.to raise_error(Squall::NotFound)
+      @virtual_machine.success.should be_false
+    end
+
+    it "will stop a virtual_machine" do
+      virtual_machine = @virtual_machine.stop(1)
+      @virtual_machine.success.should be_true
+      virtual_machine['id'].should == 1
+    end
+  end
+
+  describe "#reboot" do
+    use_vcr_cassette "virtual_machine/reboot"
+    it "requires an id" do
+      expect { @virtual_machine.reboot }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.reboot(404) }.to raise_error(Squall::NotFound)
+      @virtual_machine.success.should be_false
+    end
+
+    it "will reboot a virtual_machine" do
+      virtual_machine = @virtual_machine.reboot(1)
+      @virtual_machine.success.should be_true
+      virtual_machine['id'].should == 1
+    end
+  end
+end

data/spec/squall_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Squall do
+  describe "VERSION" do
+    it "has a valid format" do
+      Squall::VERSION.should match /\d+/
+    end
+  end
+
+  describe "#config" do
+    it "yields a configuration with a block" do
+      Squall.should_receive(:config).and_yield(Squall::Config.new)
+      Squall.config { |c| c }
+    end
+
+    it "returns the config after yield" do
+      Squall.config { |c| c }.should == {}
+      Squall.config.should == {}
+    end
+
+
+    it "returns the config without a block" do
+      Squall.config.should == {}
+    end
+
+    it "sets the base URI" do
+      Squall.config { |c| c.base_uri 'hi'}
+      Squall.config.should_not be_empty
+      Squall.config[:base_uri] == 'hi'
+    end
+  end
+
+  describe "#reset" do
+    it "resets the configuration to defaults" do
+      default_config
+      Squall.config.should_not be_empty
+      Squall.reset_config
+      Squall.config.should be_empty
+    end
+  end
+
+  describe "#config_file" do
+    it "defaults to ~/.squall" do
+      file = File.join(ENV['HOME'], '.squall.yml')
+      config = {'username' => 'test', 'password' => 'pass', 'base_uri' => 'http://example.com'}
+
+      File.stub(:exists?).and_return(true)
+      YAML.should_receive(:load_file).with(file).and_return(config)
+
+      Squall.configuration_file.should be_nil
+      Squall.config_file
+      Squall.configuration_file.should == file
+    end
+
+    it "returns an error if the file doesn't exist" do
+      expect { Squall.config_file '/tmp/missing.yml'}.to raise_error(ArgumentError, "Config file doesn't exist '/tmp/missing.yml'")
+    end
+
+    it "loads the yaml" do
+      File.stub(:exists?).and_return(true)
+      config = {'username' => 'test', 'password' => 'pass', 'base_uri' => 'http://example.com'}
+      YAML.should_receive(:load_file).with('/tmp/exists.yml').and_return(config)
+      Squall.config_file '/tmp/exists.yml'
+      Squall.config.should include(:username => config['username'], :password => config['password'], :base_uri => config['base_uri'])
+    end
+  end
+end

data/spec/vcr_cassettes/hypervisor/create.yml

@@ -0,0 +1,77 @@
+--- 
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://user:pass@www.example.com:80/settings/hypervisors.json?hypervisor[ip_address]=123.123.123.123&hypervisor[hypervisor_type]=xen&hypervisor[label]=Testing
+    body: 
+    headers: 
+      content-type: 
+      - application/json
+      authorization: 
+      - Basic WHAT
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 422
+      message: Unprocessable Entity
+    headers: 
+      x-ua-compatible: 
+      - IE=Edge,chrome=1
+      x-powered-by: 
+      - Phusion Passenger (mod_rails/mod_rack) 3.0.1
+      content-type: 
+      - application/json; charset=utf-8
+      date: 
+      - Fri, 15 Apr 2011 20:51:38 GMT
+      server: 
+      - Apache/2.2.3 (CentOS)
+      x-runtime: 
+      - "0.009919"
+      set-cookie: 
+      - _onapp_session=WHAT; path=/; HttpOnly
+      cache-control: 
+      - no-cache
+      status: 
+      - "422"
+      transfer-encoding: 
+      - chunked
+    body: "{\"label\":[\"has already been taken\"],\"ip_address\":[\"has already been taken\"]}"
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://user:pass@www.example.com:80/settings/hypervisors.json?hypervisor[ip_address]=126.126.126.126&hypervisor[hypervisor_type]=xen&hypervisor[label]=Brand%20new
+    body: 
+    headers: 
+      content-type: 
+      - application/json
+      authorization: 
+      - Basic WHAT
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 201
+      message: Created
+    headers: 
+      x-ua-compatible: 
+      - IE=Edge,chrome=1
+      location: 
+      - http://www.example.com/settings/hypervisors/3
+      x-powered-by: 
+      - Phusion Passenger (mod_rails/mod_rack) 3.0.1
+      content-type: 
+      - application/json; charset=utf-8
+      x-runtime: 
+      - "0.016771"
+      server: 
+      - Apache/2.2.3 (CentOS)
+      date: 
+      - Fri, 15 Apr 2011 20:52:02 GMT
+      set-cookie: 
+      - _onapp_session=WHAT; path=/; HttpOnly
+      status: 
+      - "201"
+      cache-control: 
+      - no-cache
+      transfer-encoding: 
+      - chunked
+    body: "{\"hypervisor\":{\"called_in_at\":null,\"label\":\"Brand new\",\"created_at\":\"2011-04-15T20:52:02Z\",\"spare\":false,\"hypervisor_type\":\"xen\",\"updated_at\":\"2011-04-15T20:52:02Z\",\"enabled\":true,\"hypervisor_group_id\":null,\"id\":3,\"xen_info\":null,\"failure_count\":0,\"health\":null,\"memory_overhead\":464,\"ip_address\":\"126.126.126.126\",\"locked\":false,\"online\":false}}"
+    http_version: "1.1"

data/spec/vcr_cassettes/hypervisor/delete.yml

@@ -0,0 +1,77 @@
+--- 
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :delete
+    uri: http://user:pass@www.example.com:80/settings/hypervisors/404.json
+    body: 
+    headers: 
+      content-type: 
+      - application/json
+      authorization: 
+      - Basic WHAT
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 404
+      message: Not Found
+    headers: 
+      x-ua-compatible: 
+      - IE=Edge,chrome=1
+      x-powered-by: 
+      - Phusion Passenger (mod_rails/mod_rack) 3.0.1
+      content-type: 
+      - application/json; charset=utf-8
+      date: 
+      - Mon, 18 Apr 2011 17:13:08 GMT
+      server: 
+      - Apache/2.2.3 (CentOS)
+      x-runtime: 
+      - "0.117341"
+      set-cookie: 
+      - _onapp_session=WHAT; path=/; HttpOnly
+      cache-control: 
+      - no-cache
+      status: 
+      - "404"
+      transfer-encoding: 
+      - chunked
+    body: "{\"error\":\"Resource not found\"}"
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :delete
+    uri: http://user:pass@www.example.com:80/settings/hypervisors/3.json
+    body: 
+    headers: 
+      content-type: 
+      - application/json
+      authorization: 
+      - Basic WHAT
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      x-ua-compatible: 
+      - IE=Edge,chrome=1
+      etag: 
+      - "\"99914b932bd37a50b983c5e7c90ae93b\""
+      x-powered-by: 
+      - Phusion Passenger (mod_rails/mod_rack) 3.0.1
+      content-type: 
+      - application/json; charset=utf-8
+      x-runtime: 
+      - "0.192936"
+      server: 
+      - Apache/2.2.3 (CentOS)
+      date: 
+      - Mon, 18 Apr 2011 17:13:08 GMT
+      set-cookie: 
+      - _onapp_session=WHAT; path=/; HttpOnly
+      status: 
+      - "200"
+      cache-control: 
+      - max-age=0, private, must-revalidate
+      transfer-encoding: 
+      - chunked
+    body: "{}"
+    http_version: "1.1"