vcloud-walker 3.1.1

data/spec/walk/catalogs_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'rspec/mocks'
+
+describe Vcloud::Walker::Resource::Catalogs do
+
+    it "should summarize catalogs" do
+      set_login_credential
+      mock_fog_item = double(:catalog_item,
+                       :id => "12345",
+                       :name => 'ubuntu 11.04',
+                       :description => 'image for ubuntu 11.04',
+                       :vapp_template_id => 'vapp-template-01')
+      mock_fog_catalog = double(:catalog,
+                          :id => 'catalog_id_1',
+                          :name => 'Default catalog',
+                          :description => 'default catalog for infrastructure',
+                          :catalog_items => double(:catalog_items, :all => [mock_fog_item]))
+
+      catalog_summary = Vcloud::Walker::Resource::Catalogs.new([mock_fog_catalog]).to_summary
+      catalog_summary.count.should == 1
+      catalog_summary.first[:items].count.should == 1
+      catalog_summary.should == [{
+                                     :id => "catalog_id_1",
+                                     :name => "Default catalog",
+                                     :description => "default catalog for infrastructure",
+                                     :items => [
+                                         {:id => "12345", :name => "ubuntu 11.04", :description => "image for ubuntu 11.04", :vapp_template_id => "vapp-template-01"}
+                                     ]
+                                 }]
+    end
+end

data/spec/walk/entity_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Vcloud
+  module Walker
+    module Resource
+
+      class TestData < Entity
+        attr_accessor :name
+
+        def initialize data
+          self.name = data.name
+        end
+      end
+
+      class TestDataCollection < Collection
+        def initialize coll
+          coll.each do |c|
+            self << Vcloud::Walker::Resource::TestData.new(c)
+          end
+        end
+
+      end
+
+      class TestClass < Entity
+        attr_accessor :test_data
+        attr_accessor :description
+
+        def initialize test
+          self.test_data   = TestDataCollection.new(test.collection)
+          self.description = test.description
+        end
+      end
+
+      class TestNestedEntity < Entity
+        attr_accessor :test_data
+        def initialize data
+          self.test_data = TestData.new(data)
+        end
+      end
+
+    end
+  end
+
+  describe Vcloud::Walker::Resource::Entity do
+    it 'should be able to nested collections inside entities' do
+      collection = [double(:name => 'collection 1'), double(:name => 'collection 2')]
+      test_class = Vcloud::Walker::Resource::TestClass.new(double(:description => 'test class desc', :collection => collection))
+
+      test_class.to_summary.should == {:test_data => [{:name => "collection 1"}, {:name => "collection 2"}], :description => "test class desc"}
+    end
+
+    it 'should summaries a class as a hash and remove @ from the symbol names' do
+      collection = [double(:name => 'collection 1'), double(:name => 'collection 2')]
+      test_class = Vcloud::Walker::Resource::TestClass.new(double(:description => 'test class desc', :collection => collection))
+      test_class.instance_variables.should eq([:@test_data, :@description])
+      test_summary = test_class.to_summary
+      test_summary.keys.should eq([:test_data, :description])
+    end
+
+    it 'should be able to nest entity inside entity' do
+      nested_entities = Vcloud::Walker::Resource::TestNestedEntity.new(double(:data, :name => 'Data 1'))
+      expect(nested_entities.to_summary).to eq({:test_data=>{:name=>"Data 1"}})
+
+    end
+
+  end
+end
+
+

data/spec/walk/gateway_ipsec_vpn_service_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe Vcloud::Walker::Resource::GatewayIpsecVpnService do
+  context "vpn service with single tunnel" do
+    before(:all) do
+      fog_vpn_service = {
+        IsEnabled: true,
+        Tunnel: {
+          Name: "ss_one",
+          Description: "desc one",
+          IpsecVpnThirdPartyPeer: {
+            PeerId: "1"
+          },
+          PeerIpAddress: "8.8.8.8",
+          PeerId: "1",
+          LocalIpAddress: "192.0.2.1",
+          LocalId: "1",
+          LocalSubnet: {
+            Name: "Default",
+            Gateway: "192.168.0.1",
+            Netmask: "255.255.0.0"
+          },
+          PeerSubnet: {
+            Name: "8.8.8.0/8",
+            Gateway: "8.8.8.0",
+            Netmask: "255.0.0.0"
+          },
+          SharedSecret: "DoNotDiscloseDoNotDiscloseDoNotDiscloseDoNotDiscloseDoNotDisclose",
+          SharedSecretEncrypted: "false",
+          EncryptionProtocol: "AES256",
+          Mtu: "1500",
+          AdditionalDetails: {
+            shared_network: true
+          },
+          IsEnabled: "true",
+          IsOperational: "false"
+        }
+      }
+
+      @gateway_vpn_service = Vcloud::Walker::Resource::GatewayIpsecVpnService.new(fog_vpn_service)
+    end
+    it "should report status of vpn service" do
+      expect(@gateway_vpn_service.IsEnabled).to eq(true)
+      expect(@gateway_vpn_service.Tunnels).not_to be_empty
+    end
+
+    context "report tunnel info" do
+      before(:all) do
+        @tunnel = @gateway_vpn_service.Tunnels.first
+      end
+
+      it "with peer details" do
+        expect(@tunnel[:PeerId]).to eq('1')
+        expect(@tunnel[:PeerIpAddress]).to eq('8.8.8.8')
+        expect(@tunnel[:PeerSubnet]).to eq({
+                                             Name: "8.8.8.0/8",
+                                             Gateway: "8.8.8.0",
+                                             Netmask: "255.0.0.0"
+                                           })
+      end
+
+      it "with local network details" do
+        expect(@tunnel[:LocalId]).to eq('1')
+        expect(@tunnel[:LocalIpAddress]).to eq('192.0.2.1')
+        expect(@tunnel[:LocalSubnet]).to eq({
+                                              Name: "Default",
+                                              Gateway: "192.168.0.1",
+                                              Netmask: "255.255.0.0"
+                                            })
+      end
+
+      it "with maximum transmission unit" do
+        expect(@tunnel[:Mtu]).to eq('1500')
+      end
+
+      it "with masked vpn shared secret information" do
+        expect(@tunnel[:SharedSecret]).to eq("*" * 65)
+        expect(@tunnel[:SharedSecretEncrypted]).to eq("******")
+        expect(@tunnel[:EncryptionProtocol]).to eq("******")
+      end
+
+      it "should skip any addditional vpn details provided by fog" do
+        expect(@tunnel[:AdditionalDetails]).to be_nil
+      end
+    end
+
+  end
+
+  it "should report vpn service with multiple tunnels" do
+    fog_vpn_service = {
+      IsEnabled: true,
+      Tunnel: [
+        {
+          Name: "remove vpn 1",
+          Description: "describe me",
+          IpsecVpnThirdPartyPeer: {
+            PeerId: "1"
+          },
+          PeerIpAddress: "8.8.8.8",
+          PeerId: "1",
+          LocalIpAddress: "192.0.2.1",
+          LocalId: "1",
+          LocalSubnet: {
+            Name: "Default",
+            Gateway: "192.168.0.1",
+            Netmask: "255.255.0.0"
+          },
+          PeerSubnet: {
+            Name: "8.8.8.0/8",
+            Gateway: "8.8.8.0",
+            Netmask: "255.0.0.0"
+          },
+          SharedSecret: "DoNotDiscloseDoNotDiscloseDoNotDiscloseDoNotDiscloseDoNotDisclose",
+          SharedSecretEncrypted: "false",
+          EncryptionProtocol: "AES256",
+          Mtu: "1500",
+          AdditionalDetails: {
+            shared_network: true
+          },
+          IsEnabled: "true",
+          IsOperational: "false"
+        },
+        {
+          Name: "remote vpn 2",
+          Description: "describe me",
+          IpsecVpnThirdPartyPeer: {
+            PeerId: "2"
+          },
+          PeerIpAddress: "8.8.4.4",
+          PeerId: "2",
+          LocalIpAddress: "172.26.2.3",
+          LocalId: "2",
+          LocalSubnet: {
+            Name: "Default",
+            Gateway: "192.168.0.1",
+            Netmask: "255.255.0.0"
+          },
+          PeerSubnet: {
+            Name: "8.8.4.4/8",
+            Gateway: "8.8.4.4",
+            Netmask: "255.0.0.0"
+          },
+          SharedSecret: "PrivyPrivyPrivyPrivyPrivyPrivyPrivyPrivyPrivyPrivy",
+          SharedSecretEncrypted: "false",
+          EncryptionProtocol: "AES256",
+          Mtu: "1500",
+          IsEnabled: "true",
+          IsOperational: "false"
+        }
+      ]
+    }
+
+    gateway_vpn_service = Vcloud::Walker::Resource::GatewayIpsecVpnService.new(fog_vpn_service)
+    expect(gateway_vpn_service.Tunnels.count).to eq(2)
+  end
+
+end

data/spec/walk/network_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'rspec/mocks'
+require 'fog'
+
+describe Vcloud::Walker::Resource::Networks do
+
+  context "Summary" do
+    before(:each) do
+      set_login_credential
+    end
+
+    it "should walk all networks within given org" do
+
+      mock_fog_network = mock_fog_network_object
+
+      networks = Vcloud::Walker::Resource::Networks.new([mock_fog_network, mock_fog_network])
+
+      networks.count.should == 2
+    end
+
+
+    it "should be happy with one network" do
+
+      mock_fog_network = mock_fog_network_object
+
+      networks = Vcloud::Walker::Resource::Networks.new([mock_fog_network])
+
+      networks.count.should == 1
+    end
+
+    it "should handle having no networks" do
+      networks = Vcloud::Walker::Resource::Networks.new([])
+
+      networks.count.should == 0
+    end
+
+
+    it "should map parameters of a network to the local entity" do
+      mock_fog_network = mock_fog_network_object
+      expect(mock_fog_network).to receive(:dns1).and_return('sausage')
+
+      networks = Vcloud::Walker::Resource::Networks.new([mock_fog_network])
+
+      networks.count.should == 1
+      networks.first.id.should == :network_id_1
+      networks.first.name.should == :name
+      networks.first.dns_suffix == :dns_suffix
+      networks.first.dns1 == 'sausage'
+
+    end
+
+  end
+
+  private
+  def mock_fog_network_object
+    double(:fog_network,
+           :id => :network_id_1,
+           :name => :name,
+           :description => :default,
+           :is_inherited => false,
+           :gateway => false,
+           :netmask => :default,
+           :dns_suffix => :dns_suffix,
+           :dns2 => :default,
+           :dns1 => :default,
+           :ip_ranges => :default)
+  end
+
+
+end

data/spec/walk/organization_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Vcloud::Walker::Resource::Organization do
+
+  it "should retrieve networks" do
+    fog_networks = double(:fog_networks)
+    Vcloud::Walker::FogInterface.should_receive(:get_networks).and_return(fog_networks)
+    Vcloud::Walker::Resource::Networks.should_receive(:new).with(fog_networks).and_return(double(:walker_networks, :to_summary => [:network => "Network 1"]))
+    Vcloud::Walker::Resource::Organization.networks.should == [:network => "Network 1"]
+  end
+
+  it "should retrieve catalogs" do
+    fog_catalogs = double(:fog_catalogs)
+    Vcloud::Walker::FogInterface.should_receive(:get_catalogs).and_return(fog_catalogs)
+    Vcloud::Walker::Resource::Catalogs.should_receive(:new).with(fog_catalogs).and_return(double(:walker_catalogs, :to_summary => [:catalog => "Catalog 1"]))
+    Vcloud::Walker::Resource::Organization.catalogs.should == [:catalog => "Catalog 1"]
+  end
+
+  it "should retrieve vdcs" do
+    fog_vdcs = double(:fog_vdcs)
+    Vcloud::Walker::FogInterface.should_receive(:get_vdcs).and_return(fog_vdcs)
+    Vcloud::Walker::Resource::Vdcs.should_receive(:new).with(fog_vdcs).and_return(double(:walker_vdcs, :to_summary => [:vdc => "VDC 1"]))
+    Vcloud::Walker::Resource::Organization.vdcs.should == [:vdc => "VDC 1"]
+  end
+
+  it "should retrieve edgegateways" do
+    fog_edgegateways = [{:id => 'urn:vcloud:gateway:1', :href => 'host/1', :name => 'Gateway 1',
+                         :Configuration => { :EdgeGatewayServiceConfiguration => {}}}]
+    Vcloud::Walker::FogInterface.should_receive(:get_edge_gateways).and_return(fog_edgegateways)
+
+    Vcloud::Walker::Resource::Organization.edgegateways.should == [{:id => '1',
+                                                                    name: 'Gateway 1',
+                                                                    :href => 'host/1',
+                                                                    :Configuration => {
+                                                                      :EdgeGatewayServiceConfiguration => {}}
+                                                                   }]
+  end
+
+  it "should retrive entire organization" do
+    Vcloud::Walker::Resource::Organization.should_receive(:edgegateways).and_return([:edgegateway => 'Gateway 1'])
+    Vcloud::Walker::Resource::Organization.should_receive(:vdcs).and_return([:vdc => "VDC 1"])
+    Vcloud::Walker::Resource::Organization.should_receive(:catalogs).and_return([:catalog => "Catalog 1"])
+    Vcloud::Walker::Resource::Organization.should_receive(:networks).and_return([:network => "Network 1"])
+
+    Vcloud::Walker::Resource::Organization.organization.should == {
+        :vdcs => [{ :vdc => "VDC 1" }],
+        :networks => [{ :network => "Network 1" }],
+        :catalogs => [{ :catalog => "Catalog 1" }],
+        :edgegateways => [{ :edgegateway => "Gateway 1" }]
+    }
+  end
+end
+

data/spec/walk/vapp_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Vcloud::Walker::Resource::VApp do
+
+  context 'populate summary vapp model' do
+    before(:each) do
+      fog_vapp = Fog::ServiceLayerStub.vapp_body
+      @metadata = {:name => 'web-app-1', :shutdown => true}
+      Vcloud::Core::Vapp.should_receive(:get_metadata).with("vapp-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee").and_return(@metadata)
+      Vcloud::Walker::Resource::Vms.should_receive(:new).with(fog_vapp[:Children][:Vm])
+
+      @vapp_summary = Vcloud::Walker::Resource::VApp.new(fog_vapp)
+    end
+
+    it 'should report id from the href' do
+      @vapp_summary.id.should == 'vapp-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+    end
+
+    it "should report metadata" do
+      @vapp_summary.metadata.count.should == 2
+      @vapp_summary.metadata.should == @metadata
+    end
+  end
+end

data/spec/walk/vdcs_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'fog'
+
+describe Vcloud::Walker::Resource::Vdcs do
+  let(:api_session) { double(:fog_session) }
+
+  context 'vdcs' do
+
+    it "should summarize vdcs" do
+      Fog::Compute::VcloudDirector.should_receive(:new).with(any_args()).and_return(api_session)
+      mock_fog_vdcs = StubCollectionBuilders.vdcs(StubVdc.new.vapps([mock_vapp]).build)
+      api_session.should_receive(:get_vapp).with(1).and_return(Fog::ServiceLayerStub.mock_vapp)
+      Vcloud::Core::Vm.should_receive(:get_metadata).with("vm-d19d84a5-c950-4497-a638-23eccc4226a5").and_return({})
+      Vcloud::Core::Vapp.should_receive(:get_metadata).with("vapp-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee").and_return({})
+
+      vdcs_summary = Vcloud::Walker::Resource::Vdcs.new(mock_fog_vdcs).to_summary
+
+      vdc_summary = vdcs_summary.first
+      vdc_summary[:vapps].count.should == 1
+      vdc_summary[:vapps].first[:vms].count == 1
+    end
+
+    private
+
+    def mock_vapp
+      double(:vapp, :id => 1)
+    end
+
+  end
+end

data/spec/walk/vm_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Vcloud::Walker::Resource::Vm do
+
+  context 'populate summary vm model' do
+    before(:each) do
+      fog_vm = {
+          :deployed => "true",
+          :status => "8",
+          :name => "ubuntu-testing-template",
+          :id => "urn:vcloud:vm:aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+          :href => 'https://myvdc.carrenza.net/api/vApp/vm-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
+          :"ovf:VirtualHardwareSection" =>
+              {:"ovf:Info" => "Virtual hardware requirements",
+               :"ovf:System" => {:"vssd:ElementName" => "Virtual Hardware Family", :"vssd:VirtualSystemType" => "vmx-08"},
+               :'ovf:Item' => Fog::ServiceLayerStub.hardware_resources
+              },
+          :"ovf:OperatingSystemSection" =>
+              {
+                  :vmw_osType => "ubuntu64Guest",
+                  :"ovf:Info" => "Specifies the operating system installed",
+                  :"ovf:Description" => "Ubuntu Linux (64-bit)"
+              },
+          :NetworkConnectionSection =>
+              {
+                  :type => "application/vnd.vmware.vcloud.networkConnectionSection+xml",
+                  :ovf_required => "false",
+                  :"ovf:Info" => "Specifies the available VM network connections",
+                  :PrimaryNetworkConnectionIndex => "0",
+                  :NetworkConnection =>
+                      [
+                          {
+                              :network => "Default",
+                              :needsCustomization => "true",
+                              :NetworkConnectionIndex => "0",
+                              :IpAddress => "192.168.254.100",
+                              :IsConnected => "true",
+                              :MACAddress => "00:50:56:00:00:01",
+                              :IpAddressAllocationMode => "MANUAL"
+                          },
+                      ]
+              },
+          :RuntimeInfoSection => {:VMWareTools => {:version => "2147483647"}},
+          :StorageProfile =>
+              {
+                  :type=>"application/vnd.vmware.vcloud.vdcStorageProfile+xml",
+                  :name=>"TEST-STORAGE-PROFILE",
+                  :href=>"https://api.vcd.portal.examplecloud.com/api/vdcStorageProfile/00000000-aaaa-bbbb-aaaa-000000000000"
+              }
+      }
+
+      @metadata = {:name => 'web-app-1', :shutdown => true}
+      Vcloud::Core::Vm.should_receive(:get_metadata).with("vm-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee").and_return(@metadata)
+
+      @vm_summary = Vcloud::Walker::Resource::Vm.new(fog_vm)
+    end
+
+    it 'should report id from the href' do
+      @vm_summary.id.should == 'vm-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
+    end
+
+    it "should populate vmware tool version" do
+      @vm_summary.vmware_tools.should == {:version => "2147483647"}
+    end
+
+    it "should populate virtual system type" do
+      @vm_summary.virtual_system_type.should == "vmx-08"
+    end
+
+    it "should populate operating system" do
+      @vm_summary.operating_system.should == 'Ubuntu Linux (64-bit)'
+    end
+
+    it "should populate network connection interface" do
+      @vm_summary.primary_network_connection_index.should == '0'
+      @vm_summary.network_connections.count.should == 1
+      @vm_summary.network_connections.first[:network].should == 'Default'
+    end
+
+    it "should populate storage profile" do
+      @vm_summary.storage_profile[:name].should == "TEST-STORAGE-PROFILE"
+    end
+
+    it "should populate storage profile id" do
+      @vm_summary.storage_profile[:id].should == "00000000-aaaa-bbbb-aaaa-000000000000"
+    end
+
+    context "hardware resource info" do
+
+      it "report cpu" do
+        @vm_summary.cpu.should == '2 virtual CPU(s)'
+      end
+
+      it "report memory" do
+        @vm_summary.memory.should == '4096 MB of memory'
+      end
+
+      it "report disk info" do
+        @vm_summary.disks.count.should == 2
+        @vm_summary.disks.first.should == {:name => "Hard disk 1", :size => 11265}
+        @vm_summary.disks.last.should == {:name => "Hard disk 2", :size => 307200}
+      end
+
+      it "report network card info" do
+        @vm_summary.network_cards.count.should == 1
+        @vm_summary.network_cards[0].should == {
+          :mac_address => '00:50:56:00:00:01',
+          :name => "Network adapter 0",
+          :type => "E1000"
+        }
+      end
+
+    end
+
+    it "report metadata" do
+      @vm_summary.metadata.count.should == 2
+      @vm_summary.metadata.should == @metadata
+    end
+
+  end
+end
+

data/vcloud-walker.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "vcloud/walker/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'vcloud-walker'
+  s.version     = Vcloud::Walker::VERSION
+  s.authors     = ['Government Digital Service']
+  s.homepage    = 'https://github.com/alphagov/vcloud-walker'
+  s.summary     = %q{Command line tool to describe vCloud entities}
+  s.description = %q{Vcloud-walker is a command line tool to describe different vCloud entities.
+                    This tool is a thin layer around fog api, which exposes summarized vCloud entities
+                    in the form of JSON}
+  s.license = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = s.files.grep(%r{^bin/}) {|f| File.basename(f)}
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '~> 2.14.1'
+  s.add_development_dependency 'rspec-mocks', '~> 2.14.3'
+  s.add_development_dependency 'json_spec', '~> 1.1.1'
+  s.add_runtime_dependency 'json', '~> 1.8.0'
+  s.add_runtime_dependency 'methadone'
+  s.add_runtime_dependency 'fog', '>= 1.19.0'
+  s.add_runtime_dependency 'vcloud-core', '>= 0.0.5'
+  s.add_development_dependency 'simplecov', '~> 0.8.2'
+  s.add_development_dependency 'gem_publisher', '1.2.0'
+end