deltacloud-core 1.1.2 → 1.1.3

data/lib/deltacloud/drivers/fgcp/fgcp_driver_cimi_methods.rb

@@ -29,39 +29,268 @@ module Deltacloud::Drivers::Fgcp
     def systems(credentials, opts={})
       safely do
         client = new_client(credentials)
+        xml = client.list_vsys['vsyss']
+        return [] if xml.nil?
+        context = opts[:env]
 
-        if opts and opts[:id]
-          vsys_ids = [opts[:id]]
-        else
-          xml = client.list_vsys['vsyss']
-          return [] if xml.nil?
-          vsys_ids = xml[0]['vsys'].collect { |vsys| vsys['vsysId'][0] }
-        end
-
-        vsys_ids.collect do |vsys_id|
-          vsys = client.get_vsys_configuration(vsys_id)['vsys'][0]
+        systems = xml[0]['vsys'].collect do |vsys|
+          vsys_id = vsys['vsysId'][0]
           vsys_description_el = vsys['description']
           CIMI::Model::System.new(
-            :id          => vsys['vsysId'][0],
+            :id          => vsys_id,
             :name        => vsys['vsysName'][0],
-#            :machines    => "http://cimi.example.org/systems/#{vsys['vsysId'][0]}/machines?realm_id=#{vsys['vsysId'][0]}",
-#            :volumes     => "http://cimi.example.org/systems/#{vsys['vsysId'][0]}/volumes?realm_id=#{vsys['vsysId'][0]}",
-#            :networks    => "http://cimi.example.org/systems/#{vsys['vsysId'][0]}/networks?realm_id=#{vsys['vsysId'][0]}",
-#            :addresses   => "http://cimi.example.org/systems/#{vsys['vsysId'][0]}/addresses?realm_id=#{vsys['vsysId'][0]}",
-            :description => vsys_description_el ? vsys_description_el[0] : nil
+            :description => vsys_description_el ? vsys_description_el[0] : nil,
+            :machines    => { :href => context.system_machines_url(vsys_id) },
+            :volumes     => { :href => context.system_volumes_url(vsys_id) },
+            :networks    => { :href => context.system_networks_url(vsys_id) },
+            :addresses   => { :href => context.system_addresses_url(vsys_id) },
+            :operations  => []
           )
         end
+        systems = systems.select { |s| opts[:id] == s[:id] } if opts[:id]
+
+        # now add system state and advertise operations
+        systems.each do |system|
+          vservers = client.list_vservers(system[:id])['vservers'][0]['vserver']
+          if vservers.nil?
+            system[:state] = client.get_vsys_status(system[:id])['vsysStatus'][0] == 'DEPLOYING' ? 'CREATING' : 'MIXED'
+          else
+            vservers.each do |vserver|
+              state = @@MACHINE_STATE_MAP[client.get_vserver_status(vserver['vserverId'][0])['vserverStatus'][0]]
+              system[:state] ||= state
+              system[:operations] << { :href => context.system_url("#{system[:id]}/start"), :rel => "http://schemas.dmtf.org/cimi/1/action/start" } if state == 'STOPPED'
+              system[:operations] << { :href => context.system_url("#{system[:id]}/stop"), :rel => "http://schemas.dmtf.org/cimi/1/action/stop" } if state == 'STARTED'
+              if system[:state] != state
+                system[:state] = 'MIXED'
+                # this case could have been caused by one machine in capturing state and one in e.g. creating,
+                # but just advertise both operations to cut it short
+                system[:operations] << { :href => context.system_url("#{system[:id]}/start"), :rel => "http://schemas.dmtf.org/cimi/1/action/start" }
+                system[:operations] << { :href => context.system_url("#{system[:id]}/stop"), :rel => "http://schemas.dmtf.org/cimi/1/action/stop" }
+                break
+              end
+            end
+            system[:operations].uniq!
+          end
+          # check for special case: in destroy_system the FW is stopped before the system is deleted
+          system[:state] = 'DELETING' if ((vservers.nil? and system[:state] != 'CREATING') or system[:state] == 'STOPPED') and
+                                         ['STOPPED', 'STOPPING'].include? client.get_efm_status("#{system[:id]}-S-0001")['efmStatus'][0]
+          system[:operations] << { :href => context.system_url(system[:id]), :rel => "delete" } if system[:state] == 'STOPPED'
+        end
+        systems
+      end
+    end
+
+    def create_system(credentials, opts={})
+      safely do
+        client = new_client(credentials)
+        name = opts[:name] || "system_#{Time.now.to_s}"
+        template = opts[:system_template]
+        template_id = template.id || template.href.to_s.gsub(/.*\/([^\/]+)$/, '\1')
+        vsys_id = client.create_vsys(template_id, name)['vsysId'][0]
+        opts[:id] = vsys_id
+        systems(credentials, opts).first
+      end
+    end
+
+    def destroy_system(credentials, id)
+      delete_firewall(credentials, :id => "#{id}-S-0001")
+    end
+
+    def start_system(credentials, opts={})
+      safely do
+        client = new_client(credentials)
+        context = opts[:env]
+        vsys_id = opts[:id]
+        xml = client.list_vservers(vsys_id)['vservers']
+        return unless xml and xml[0]['vserver']
+
+        # FIXME: maybe this should be done in a separate thread (in case of gigantic number of servers)
+        # FIXME: error handling (ok to exit loop? Cleanup?) - at this time the cimi spec is quiet on that
+        xml[0]['vserver'].each do |vserver|
+          begin
+            client.start_vserver(vserver['vserverId'][0])
+          rescue Exception => ex
+            raise ex if not ex.message =~ /(ALREADY_STARTED|ILLEGAL_STATE).*/
+          end
+        end
+      end
+    end
+
+    def stop_system(credentials, opts={})
+      safely do
+        client = new_client(credentials)
+        context = opts[:env]
+        vsys_id = opts[:id]
+        xml = client.list_vservers(vsys_id)['vservers']
+        return unless xml and xml[0]['vserver']
+
+        # FIXME: maybe this should be done in a separate thread (in case of gigantic number of servers)
+        # FIXME: error handling (ok to exit loop? Cleanup?) - at this time the cimi spec is quiet on that
+        xml[0]['vserver'].each do |vserver|
+          begin
+            client.stop_vserver(vserver['vserverId'][0])
+          rescue Exception => ex
+            raise ex if not ex.message =~ /(ALREADY_STOPPED|ILLEGAL_STATE).*/
+          end
+        end
+      end
+    end
+
+    def system_machines(credentials, opts={})
+      safely do
+        client = new_client(credentials)
+        #if :expand not specified, list of hrefs only, else convert from :instances?
+        context = opts[:env]
+        vsys_id = opts[:system_id]
+        xml = client.list_vservers(vsys_id)['vservers']
+        return [] unless xml and xml[0]['vserver']
+
+        machines = xml[0]['vserver'].collect do |vserver|
+          vserver_id = vserver['vserverId'][0]
+          CIMI::Model::SystemMachine.new(
+            :id      => context.system_machine_url(:id => vsys_id, :ent_id => vserver_id),
+            :name    => vserver['vserverName'][0],
+            :machine => { :href => context.machine_url(vserver_id)}
+          ) unless opts[:id] and opts[:id] != vserver_id
+        end
+        machines.compact
+      end
+    end
+
+    def system_volumes(credentials, opts={})
+      safely do
+        client = new_client(credentials)
+        context = opts[:env]
+        vsys_id = opts[:system_id]
+        #if :expand not specified, list of hrefs only, else convert from :storage_volumes?
+        xml = client.list_vdisk(vsys_id)['vdisks']
+        return [] unless xml and xml[0]['vdisk']
+
+        volumes = xml[0]['vdisk'].collect do |vdisk|
+          vdisk_id = vdisk['vdiskId'][0]
+          CIMI::Model::SystemVolume.new(
+            :id      => context.system_volume_url(:id => vsys_id, :ent_id => vdisk_id),
+            :name    => vdisk['vdiskName'][0],
+            :volume  => { :href => context.volume_url(vdisk_id)}
+          ) unless (opts[:id] and opts[:id] != vdisk_id) or determine_storage_type(vdisk_id) == 'system'
+        end
+        volumes.compact
+      end
+    end
+
+    def system_networks(credentials, opts={})
+      safely do
+        client = new_client(credentials)
+        context = opts[:env]
+        vsys_id = opts[:system_id]
+        #if :expand not specified, list of hrefs only, else ??
+        vsys = client.get_vsys_configuration(vsys_id)['vsys'][0]
+
+        # retrieve network segment (subnet) info
+        networks = vsys['vnets'][0]['vnet'].collect do |vnet|
+          network_id = vnet['networkId'][0]
+          network_id =~ /.*-(\w)$/
+          CIMI::Model::SystemNetwork.new(
+            :id      => context.system_network_url(:id => vsys_id, :ent_id => network_id),
+            :name    => "#{$1} for system #{vsys['vsysName'][0]}",
+            :network => { :href => context.network_url(network_id)}
+          ) unless opts[:id] and opts[:id] != network_id
+        end
+        networks.compact
+      end
+    end
+
+    def system_addresses(credentials, opts={})
+      safely do
+        client = new_client(credentials)
+        context = opts[:env]
+        vsys_id = opts[:system_id]
+        #if :expand not specified, list of hrefs only, else ??
+        xml = client.list_public_ips(vsys_id)['publicips']
+        return [] unless xml and xml[0]['publicip']
+
+        # retrieve network segment (subnet) info
+        addresses = xml[0]['publicip'].collect do |ip|
+          address = ip['address'][0]
+          CIMI::Model::SystemAddress.new(
+            :id      => context.system_address_url(:id => vsys_id, :ent_id => address),
+            :name    => "Public IP address allocated to system #{ip['vsysId'][0]}",
+            :address => { :href => context.address_url(address)}
+          ) unless opts[:id] and opts[:id] != address
+        end
+        addresses.compact
+      end
+    end
+
+    def system_forwarding_groups(credentials, opts={})
+      safely do
+        client = new_client(credentials)
+        context = opts[:env]
+        vsys_id = opts[:system_id]
+        #if :expand not specified, list of hrefs only, else ??
+        vsys = client.get_vsys_configuration(vsys_id)['vsys'][0]
+
+        group_id = "#{vsys_id}-INTRA"
+        groups = []
+        groups << CIMI::Model::SystemForwardingGroup.new(
+          :id               => context.system_forwarding_group_url(:id => vsys_id, :ent_id => group_id),
+          :name             => "Routing group of system #{vsys['vsysName'][0]}",
+          :forwarding_group => { :href => context.forwarding_group_url(group_id)}
+        ) unless vsys['vnets'][0]['vnet'].size <= 1 or (opts[:id] and opts[:id] != group_id)
+        groups
       end
     end
 
     def system_templates(credentials, opts={})
       safely do
         client = new_client(credentials)
+        context = opts[:env]
         templates = client.list_vsys_descriptor['vsysdescriptors'][0]['vsysdescriptor'].collect do |desc|
+          conf = client.get_vsys_descriptor_configuration(desc['vsysdescriptorId'][0])['vsysdescriptor'][0]
+          components = conf['vservers'][0]['vserver'].collect do |vserver|
+            next if vserver['vserverType'][0] == 'firewall'
+            volume_templates = vserver['vdisks'][0]['vdisk'].collect do |vdisk|
+              CIMI::Model::VolumeTemplateWithLocation.new(
+                :volume_config => CIMI::Model::VolumeConfiguration.new(:capacity => vdisk['size'][0].to_i * 1024 * 1024)
+              )
+            end if vserver['vdisks']
+            {
+              :name             => desc['vsysdescriptorName'][0],
+              :description      => '',
+              :type             => "http://schemas.dmtf.org/cimi/1/Machine",
+              :machine_template => CIMI::Model::MachineTemplate.new(
+                :name             => vserver['vserverName'][0],
+                :description      => '',
+                :machine_config   => CIMI::Service::MachineConfiguration.find(vserver['vserverType'][0], context),
+                :machine_image    => { :href => context.machine_image_url(vserver['diskimageId'][0]) },
+                :volume_templates => volume_templates
+              )
+            }
+          end
+          # add network templates
+          if conf['vsysdescriptorId'][0] =~ /(1|2|3)-tier Skeleton/
+            tiers = ['DMZ', 'Secure1', 'Secure2']
+            components += 1.upto($1.to_i).collect do |n|
+              {
+                :name             => tiers[n],
+                :description      => "Network tier #{n}",
+                :type             => "http://schemas.dmtf.org/cimi/1/Network",
+                :network_template => CIMI::Model::NetworkTemplate.new(
+                  :name             => 'Private network',
+                  :description      => '',
+                  :network_config   => CIMI::Model::NetworkConfiguration.new(
+                    :network_type     => 'PRIVATE',
+                    :class_of_service => 'BRONZE'
+                  )
+                )
+              }
+            end
+          end
           CIMI::Model::SystemTemplate.new(
-            :id           => desc['vsysdescriptorId'][0],
-            :name         => desc['vsysdescriptorName'][0],
-            :description  => desc['description'][0]
+            :id                    => desc['vsysdescriptorId'][0],
+            :name                  => desc['vsysdescriptorName'][0],
+            :description           => desc['description'][0],
+            :component_descriptors => components.compact
           )
         end
         templates = templates.select { |t| opts[:id] == t[:id] } if opts[:id]
@@ -69,6 +298,24 @@ module Deltacloud::Drivers::Fgcp
       end
     end
 
+    # FGCP instance states mapped to CIMI machine states
+    @@MACHINE_STATE_MAP = {
+      'DEPLOYING'       =>  'CREATING',
+      'RUNNING'         =>  'STARTED',
+      'STOPPING'        =>  'STOPPING',
+      'STOPPED'         =>  'STOPPED',
+      'STARTING'        =>  'STARTING', # not sure about this one
+      'FAILOVER'        =>  'STARTED',
+      'UNEXPECTED_STOP' =>  'STOPPED',
+      'RESTORING'       =>  'RESTORING',
+      'BACKUP_ING'      =>  'CAPTURING',
+      'ERROR'           =>  'ERROR',   # allowed actions limited
+      'START_ERROR'     =>  'STOPPED', # allowed actions are same as for STOPPED
+      'STOP_ERROR'      =>  'STARTED', # allowed actions are same as for RUNNING
+      'REGISTERING'     =>  'PENDING',
+      'CHANGE_TYPE'     =>  'PENDING'
+    }
+
   end
 
 end

data/lib/deltacloud/drivers/google/google_driver.rb

@@ -16,6 +16,12 @@
 require 'fog'
 require_relative '../../helpers/blob_stream_helper.rb'
 
+module Excon
+  class Connection
+    def connection;@data;end
+  end
+end
+
 module Deltacloud
   module Drivers
     module Google

data/lib/deltacloud/drivers/mock/mock_driver.rb

@@ -114,7 +114,7 @@ module Deltacloud::Drivers::Mock
       results
     end
 
-    def filter_by_owner(images, owner_id)
+    def filter_by_owner(credentials, images, owner_id)
       return images unless owner_id
       if owner_id == 'self'
         images.select { |e| e.owner_id == credentials.user }
@@ -131,7 +131,7 @@ module Deltacloud::Drivers::Mock
       images = @client.build_all(Image)
 
       images = filter_on(images, opts, :id, :architecture)
-      images = filter_by_owner(images, opts[:owner_id])
+      images = filter_by_owner(credentials, images, opts[:owner_id])
 
       # Add hardware profiles to each image
       images = images.map { |i| (i.hardware_profiles = hardware_profiles(nil)) && i }

data/lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb

@@ -32,7 +32,110 @@ module Deltacloud::Drivers::Mock
           return []
         end
       end
-      systems.map{|sys|convert_cimi_mock_urls(:system, sys ,opts[:env])}.flatten
+      systems.map{|sys| convert_urls(sys, opts[:env])}.flatten
+    end
+
+    def create_system(credentials, opts={})
+      check_credentials(credentials)
+      id = "#{opts[:env].send("systems_url")}/#{opts[:name]}"
+      sys_hsh = { "id"=> id,
+                  "name" => opts[:name],
+                  "description" => opts[:description],
+                  "created" => Time.now,
+                  "state" => "STOPPED",
+                  "systemTemplate"=> { "href" => opts[:system_template].id },
+                  "operations" => [{"rel"=>"http://schemas.dmtf.org/cimi/1/action/start", "href"=> "#{id}/start"},
+                                   {"rel"=>"edit", "href"=> id},
+                                   {"rel"=>"delete", "href"=> id}]    }
+      system = CIMI::Model::System.from_json(JSON.generate(sys_hsh))
+
+      @client.store_cimi(:system, system)
+      system
+    end
+
+    def destroy_system(credentials, id)
+      check_credentials(credentials)
+      @client.destroy_cimi(:system, id)
+    end
+
+    def start_system(credentials, id)
+      check_credentials(credentials)
+      update_object_state(id, "System", "STARTED")
+    end
+
+    def stop_system(credentials, id)
+      check_credentials(credentials)
+      update_object_state(id, "System", "STOPPED")
+    end
+
+    def system_machines(credentials, opts={})
+      check_credentials(credentials)
+      if opts[:id].nil?
+        machines = @client.load_all_cimi(:system_machine).map{|mach| CIMI::Model::SystemMachine.from_json(mach)}
+      else
+        begin
+          machines = [CIMI::Model::SystemMachine.from_json(@client.load_cimi(:system_machine, opts[:id]))]
+        rescue Errno::ENOENT
+          return []
+        end
+      end
+      machines.map{|m|convert_urls(m, opts[:env])}.flatten
+    end
+
+    def system_volumes(credentials, opts={})
+      check_credentials(credentials)
+      if opts[:id].nil?
+        volumes = @client.load_all_cimi(:system_volume).map{|vol| CIMI::Model::SystemVolume.from_json(vol)}
+      else
+        begin
+          volumes = [CIMI::Model::SystemVolume.from_json(@client.load_cimi(:system_volume, opts[:id]))]
+        rescue Errno::ENOENT
+          return []
+        end
+      end
+      volumes.map{|vol|convert_urls(vol, opts[:env])}.flatten
+    end
+
+    def system_networks(credentials, opts={})
+      check_credentials(credentials)
+      if opts[:id].nil?
+        networks = @client.load_all_cimi(:system_network).map{|net| CIMI::Model::SystemNetwork.from_json(net)}
+      else
+        begin
+          networks = [CIMI::Model::SystemNetwork.from_json(@client.load_cimi(:system_network, opts[:id]))]
+        rescue Errno::ENOENT
+          return []
+        end
+      end
+      networks.map{|n|convert_urls(n, opts[:env])}.flatten
+    end
+
+    def system_addresses(credentials, opts={})
+      check_credentials(credentials)
+      if opts[:id].nil?
+        addresses = @client.load_all_cimi(:system_address).map{|a| CIMI::Model::SystemAddress.from_json(a)}
+      else
+        begin
+          addresses = [CIMI::Model::SystemVolume.from_json(@client.load_cimi(:system_address, opts[:id]))]
+        rescue Errno::ENOENT
+          return []
+        end
+      end
+      addresses.map{|a|convert_urls(a, opts[:env])}.flatten
+    end
+
+    def system_forwarding_groups(credentials, opts={})
+      check_credentials(credentials)
+      if opts[:id].nil?
+        groups = @client.load_all_cimi(:system_forwarding_group).map{|group| CIMI::Model::SystemForwardingGroup.from_json(group)}
+      else
+        begin
+          groups = [CIMI::Model::SystemForwardingGroup.from_json(@client.load_cimi(:system_forwarding_group, opts[:id]))]
+        rescue Errno::ENOENT
+          return []
+        end
+      end
+      groups.map{|g|convert_urls(g, opts[:env])}.flatten
     end
 
     def system_templates(credentials, opts={})
@@ -46,17 +149,17 @@ module Deltacloud::Drivers::Mock
           return []
         end
       end
-      system_templates.map{|sys_templ|convert_cimi_mock_urls(:system_template, sys_templ, opts[:env])}.flatten
+      system_templates.map{|sys_templ| convert_urls(sys_templ, opts[:env])}.flatten
     end
 
     def networks(credentials, opts={})
       check_credentials(credentials)
       if opts[:id].nil?
         networks = @client.load_all_cimi(:network).map{|net| CIMI::Model::Network.from_json(net)}
-        networks.map{|net|convert_cimi_mock_urls(:network, net ,opts[:env])}.flatten
+        networks.map{|net| convert_urls(net, opts[:env])}.flatten
       else
         network = CIMI::Model::Network.from_json(@client.load_cimi(:network, opts[:id]))
-        convert_cimi_mock_urls(:network, network, opts[:env])
+        convert_urls(network, opts[:env])
       end
     end
 
@@ -106,10 +209,10 @@ module Deltacloud::Drivers::Mock
       check_credentials(credentials)
       if opts[:id].nil?
         network_configs = @client.load_all_cimi(:network_configuration).map{|net_config| CIMI::Model::NetworkConfiguration.from_json(net_config)}
-        network_configs.map{|net_config|convert_cimi_mock_urls(:network_configuration, net_config, opts[:env])}.flatten
+        network_configs.map{|net_config| convert_urls(net_config, opts[:env])}.flatten
       else
         network_config = CIMI::Model::NetworkConfiguration.from_json(@client.load_cimi(:network_configuration, opts[:id]))
-        convert_cimi_mock_urls(:network_configuration, network_config, opts[:env])
+        convert_urls(network_config, opts[:env])
       end
     end
 
@@ -117,10 +220,10 @@ module Deltacloud::Drivers::Mock
       check_credentials(credentials)
       if opts[:id].nil?
         network_templates = @client.load_all_cimi(:network_template).map{|net_templ| CIMI::Model::NetworkTemplate.from_json(net_templ)}
-        network_templates.map{|net_templ|convert_cimi_mock_urls(:network_template, net_templ, opts[:env])}.flatten
+        network_templates.map{|net_templ| convert_urls(net_templ, opts[:env])}.flatten
       else
         network_template = CIMI::Model::NetworkTemplate.from_json(@client.load_cimi(:network_template, opts[:id]))
-        convert_cimi_mock_urls(:network_template, network_template, opts[:env])
+        convert_urls(network_template, opts[:env])
       end
     end
 
@@ -128,10 +231,10 @@ module Deltacloud::Drivers::Mock
       check_credentials(credentials)
       if opts[:id].nil?
         forwarding_groups = @client.load_all_cimi(:forwarding_group).map{|fg| CIMI::Model::ForwardingGroup.from_json(fg)}
-        forwarding_groups.map{|fg|convert_cimi_mock_urls(:forwarding_group, fg, opts[:env])}.flatten
+        forwarding_groups.map{|fg| convert_urls(fg, opts[:env])}.flatten
       else
         forwarding_group = CIMI::Model::ForwardingGroup.from_json(@client.load_cimi(:forwarding_group, opts[:id]))
-        convert_cimi_mock_urls(:forwarding_group, forwarding_group, opts[:env])
+        convert_urls(forwarding_group, opts[:env])
       end
     end
 
@@ -139,10 +242,10 @@ module Deltacloud::Drivers::Mock
       check_credentials(credentials)
       if opts[:id].nil?
         forwarding_group_templates = @client.load_all_cimi(:forwarding_group_template).map{|fg_templ| CIMI::Model::ForwardingGroupTemplate.from_json(fg_templ)}
-        forwarding_group_templates.map{|fg_templ|convert_cimi_mock_urls(:forwarding_group_template, fg_templ, opts[:env])}.flatten
+        forwarding_group_templates.map{|fg_templ| convert_urls(fg_templ, opts[:env])}.flatten
       else
         forwarding_group_template = CIMI::Model::ForwardingGroupTemplate.from_json(@client.load_cimi(:forwarding_group_template, opts[:id]))
-        convert_cimi_mock_urls(:forwarding_group_template, forwarding_group_template, opts[:env])
+        convert_urls(forwarding_group_template, opts[:env])
       end
     end
 
@@ -150,10 +253,10 @@ module Deltacloud::Drivers::Mock
       check_credentials(credentials)
       if opts[:id].nil?
         ports = @client.load_all_cimi(:network_port).map{|net_port| CIMI::Model::NetworkPort.from_json(net_port)}
-        ports.map{|net_port|convert_cimi_mock_urls(:network_port, net_port, opts[:env])}.flatten
+        ports.map{|net_port| convert_urls(net_port, opts[:env])}.flatten
       else
         port = CIMI::Model::NetworkPort.from_json(@client.load_cimi(:network_port, opts[:id]))
-        convert_cimi_mock_urls(:network_port, port, opts[:env])
+        convert_urls(port, opts[:env])
       end
     end
 
@@ -161,10 +264,10 @@ module Deltacloud::Drivers::Mock
       check_credentials(credentials)
       if opts[:id].nil?
         network_port_configurations = @client.load_all_cimi(:network_port_configuration).map{|network_port_config| CIMI::Model::NetworkPortConfiguration.from_json(network_port_config)}
-        network_port_configurations.map{|network_port_config|convert_cimi_mock_urls(:network_port_configuration, network_port_config, opts[:env])}.flatten
+        network_port_configurations.map{|network_port_config| convert_urls(network_port_config, opts[:env])}.flatten
       else
         network_port_configuration = CIMI::Model::NetworkPortConfiguration.from_json(@client.load_cimi(:network_port_configuration, opts[:id]))
-        convert_cimi_mock_urls(:network_port_configuration, network_port_configuration, opts[:env])
+        convert_urls(network_port_configuration, opts[:env])
       end
     end
 
@@ -172,10 +275,10 @@ module Deltacloud::Drivers::Mock
       check_credentials(credentials)
       if opts[:id].nil?
         network_port_templates = @client.load_all_cimi(:network_port_template).map{|net_port_templ| CIMI::Model::NetworkPortTemplate.from_json(net_port_templ)}
-        network_port_templates.map{|net_port_templ|convert_cimi_mock_urls(:network_port_template, net_port_templ, opts[:env])}.flatten
+        network_port_templates.map{|net_port_templ| convert_urls(net_port_templ, opts[:env])}.flatten
       else
         network_port_template = CIMI::Model::NetworkPortTemplate.from_json(@client.load_cimi(:network_port_template, opts[:id]))
-        convert_cimi_mock_urls(:network_port_template, network_port_template, opts[:env])
+        convert_urls(network_port_template, opts[:env])
       end
     end
 
@@ -183,54 +286,63 @@ module Deltacloud::Drivers::Mock
       check_credentials(credentials)
       if opts[:id].nil?
         address_templates = @client.load_all_cimi(:address_template).map{|addr_templ| CIMI::Model::AddressTemplate.from_json(addr_templ)}
-        address_templates.map{|addr_templ|convert_cimi_mock_urls(:address_template, addr_templ, opts[:env])}.flatten
+        address_templates.map{|addr_templ| convert_urls(addr_templ, opts[:env])}.flatten
       else
         address_template = CIMI::Model::AddressTemplate.from_json(@client.load_cimi(:address_template, opts[:id]))
-        convert_cimi_mock_urls(:address_template, address_template, opts[:env])
+        convert_urls(address_template, opts[:env])
       end
     end
 
     private
 
-    def convert_cimi_mock_urls(model_name, cimi_object, context)
-      cimi_object.attribute_values.each do |k,v|
-        if ( v.is_a?(Struct) || ( v.is_a?(Array) && v.first.is_a?(Struct)))
-          case v
-            when Array
-              v.each do |item|
-                convert_struct_urls(item, k.to_s.singularize.to_sym, context)
-              end
-            else
-              opts = nil
-              if is_subcollection?(v, cimi_object.id)
-                opts = {:parent_model_name => model_name, :parent_item_name => cimi_object.name}
-              end
-              convert_struct_urls(v, k, context, opts)
-            end
+    # Convert all attributes that have values of the form
+    #   http://cimi.example.org/COLL/ID
+    #   or
+    #   http://cimi.example.org/COLL/ID/SUBCOLL/ENT_ID
+    def convert_urls(val, context)
+      if val.nil? || val.is_a?(Fixnum)
+        # Nothing to do
+      elsif val.is_a?(Struct)
+        val.members.each { |m| val[m] = convert_urls(val[m], context) }
+      elsif val.is_a?(Hash)
+        val.keys.each { |m| val[m] = convert_urls(val[m], context) }
+      elsif val.is_a?(Array)
+        val.each_index { |i| val[i] = convert_urls(val[i], context) }
+      elsif val.is_a?(String)
+        val = rewrite_url(val, context)
+      elsif val.is_a?(CIMI::Model::Resource)
+        val.attribute_values.each do |k, v|
+          val[k] = convert_urls(val[k], context)
         end
+      else
+        # Need to add a branch for val.class
+        raise "Whoa ! #{val.inspect}"
       end
-      object_url = context.send(:"#{model_name}_url", cimi_object.name)
-      cimi_object.id=object_url
-      cimi_object.operations.each{|op| op.href=object_url  }
-      cimi_object
+      val
     end
 
-    def is_subcollection?(struct, cimi_object_id)
-      return false if struct.href.nil?
-      struct.href.include?(cimi_object_id)
-    end
-
-    def convert_struct_urls(struct, cimi_name, context, opts = nil)
-      return unless (struct.respond_to?(:href) && (not struct.href.nil?) && (not cimi_name == :operation ))
-      if opts
-        struct.href = context.send(:"#{opts[:parent_model_name]}_url", opts[:parent_item_name]) + "/#{cimi_name}"
+    # Rewrite URL assuming it points at a valid resource; if that's not
+    # possible, return +s+
+    #
+    # URLs that should be rewritten need to be in the form
+    #   http://cimi.example.org/COLLECTION/ID
+    #   or
+    #   http://cimi.example.org/COLLECTION/SYSTEM_ID/SUBCOLLECTION/ENT_ID
+    def rewrite_url(s, context)
+      begin
+        u = URI.parse(s)
+      rescue URI::InvalidURIError
+        return s
+      end
+      return s unless u.scheme == 'http' && u.host == 'cimi.example.org'
+      _, coll, id, sub_coll, sub_id = u.path.split("/")
+      method = sub_coll ? "#{coll.singularize}_#{sub_coll.singularize}_url"
+                        : "#{coll.singularize}_url"
+      if context.respond_to?(method)
+        sub_coll ? context.send(method, :id => id, :ent_id => sub_id)
+                 : context.send(method, id)
       else
-        obj_name = struct.href.split("/").last
-        if cimi_name.to_s.end_with?("config")
-          struct.href = context.send(:"#{cimi_name}uration_url", obj_name)
-        else
-          struct.href = context.send(:"#{cimi_name}_url", obj_name)
-        end
+        s
       end
     end