fog-vcloud-director 0.1.0

data/lib/fog/vcloud_director/models/compute/disks.rb

@@ -0,0 +1,44 @@
+require 'fog/core/collection'
+require 'fog/vcloud_director/models/compute/disk'
+
+module Fog
+  module Compute
+    class VcloudDirector
+      class Disks < Collection
+        model Fog::Compute::VcloudDirector::Disk
+
+        attribute :vm
+
+        def create(size)
+          item_list unless @disks
+          data = Fog::Generators::Compute::VcloudDirector::Disks.new(@disks)
+          data.add_hard_disk(size)
+          response = service.put_disks(vm.id, data.disks)
+          service.process_task(response.body)
+        end
+
+        def get_by_id(item_id)
+          item = item_list.find{ |i| i[:id] == item_id}
+          item.merge!(:all_disks => @disks, :vm => vm) if item
+          item
+        end
+
+        def item_list
+          @disks = service.get_vm_disks(vm.id).body
+          items = @disks[:disks]
+          items.each do |disk|
+            disk[:all_disks] = @disks
+            disk[:vm] = vm
+          end
+          items
+        end
+        
+        # Returns only disk drives (OVF resource type 17) and not controllers,
+        # etc. See <https://blogs.vmware.com/vapp/2009/11/virtual-hardware-in-ovf-part-1.html>
+        def storage_only
+          select {|d| d.resource_type == 17}
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/media.rb

@@ -0,0 +1,26 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class VcloudDirector
+      class Media < Model
+        identity  :id
+
+        attribute :href
+        attribute :type
+        attribute :name
+        attribute :status, :type => :integer
+        attribute :image_type, :aliases => :imageType
+        attribute :size, :type => :integer
+        attribute :description, :aliases => :Description
+
+        # @return [Boolean]
+        def destroy
+          requires :id
+          response = service.delete_media(id)
+          service.process_task(response.body)
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/medias.rb

@@ -0,0 +1,75 @@
+require 'fog/core/collection'
+require 'fog/vcloud_director/models/compute/media'
+
+module Fog
+  module Compute
+    class VcloudDirector
+      class Medias < Collection
+        model Fog::Compute::VcloudDirector::Media
+
+        attribute :vdc
+
+        # @param [String] name The name of the entity.
+        # @param [#read] io The input object to read from.
+        # @param [String] image_type Media image type. One of: iso, floppy.
+        # @return [Media]
+        def create(name, io, image_type='iso')
+          requires :vdc
+
+          response = service.post_upload_media(vdc.id, name, image_type, io.size)
+          service.add_id_from_href!(response.body)
+          media = new(response.body)
+
+          # Perhaps this would be better implemented as media#upload.
+
+          file = response.body[:Files][:File].first
+          file[:Link] = [file[:Link]] if file[:Link].is_a?(Hash)
+          link = file[:Link].find {|l| l[:rel] == 'upload:default'}
+
+          headers = {
+            'Content-Length' => io.size,
+            'Content-Type' => 'application/octet-stream',
+            'x-vcloud-authorization' => service.vcloud_token
+          }
+          chunker = lambda do
+            # to_s will convert the nil received after everything is read to
+            # the final empty chunk.
+            io.read(Excon.defaults[:chunk_size]).to_s
+          end
+          Excon.put(
+            link[:href],
+            :expects => 200,
+            :headers => headers,
+            :request_block => chunker)
+
+          service.process_task(response.body[:Tasks][:Task])
+
+          media.reload
+          media
+        end
+
+        private
+
+        # @param [String] item_id
+        # @return [Media]
+        def get_by_id(item_id)
+          item = service.get_media(item_id).body
+          %w(:Link).each {|key_to_delete| item.delete(key_to_delete)}
+          service.add_id_from_href!(item)
+          item
+        end
+
+        # @return [Array<Media>]
+        def item_list
+          data = service.get_vdc(vdc.id).body
+          return [] if data[:ResourceEntities].empty?
+          items = data[:ResourceEntities][:ResourceEntity].select do |resource|
+            resource[:type] == 'application/vnd.vmware.vcloud.media+xml'
+          end
+          items.each {|item| service.add_id_from_href!(item)}
+          items
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/network.rb

@@ -0,0 +1,25 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class VcloudDirector
+      class Network < Model
+        identity  :id
+
+        attribute :name
+        attribute :type
+        attribute :href
+        attribute :description
+        attribute :is_inherited
+        attribute :is_shared
+        attribute :fence_mode
+        attribute :gateway
+        attribute :netmask
+        attribute :dns1
+        attribute :dns2
+        attribute :dns_suffix
+        attribute :ip_ranges, :type => :array
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/networks.rb

@@ -0,0 +1,62 @@
+require 'fog/core/collection'
+require 'fog/vcloud_director/models/compute/network'
+
+module Fog
+  module Compute
+    class VcloudDirector
+      class Networks < Collection
+
+        include Fog::VcloudDirector::Query
+
+        model Fog::Compute::VcloudDirector::Network
+
+        attribute :organization
+        attribute :vdc
+
+        def query_type
+          "orgVdcNetwork"
+        end
+
+        private
+
+        def get_by_id(item_id)
+          raw_network = service.get_network_complete(item_id).body
+          data = {}
+          data[:type] = raw_network[:type]
+          data[:href] = raw_network[:href]
+          service.add_id_from_href!(data)
+          data[:name] = raw_network[:name]
+          data[:description] = raw_network[:Description]
+          data[:is_shared] = raw_network[:IsShared]
+          net_config = raw_network[:Configuration]
+          data[:fence_mode] = net_config[:FenceMode]
+          ip_scope = net_config[:IpScopes][:IpScope]
+          data[:is_inherited] = ip_scope[:IsInherited]
+          data[:gateway] = ip_scope[:Gateway]
+          data[:netmask] = ip_scope[:Netmask]
+          data[:dns1] = ip_scope[:Dns1]
+          data[:dns2] = ip_scope[:Dns2]
+          data[:dns_suffix] = ip_scope[:DnsSuffix]
+          data[:ip_ranges] = []
+          raw_ip_ranges = ip_scope[:IpRanges][:IpRange]
+          data[:ip_ranges] = raw_ip_ranges.map do |ip_range|
+            { :start_address => ip_range[:StartAddress],
+              :end_address   => ip_range[:EndAddress] }
+          end
+          data
+        end
+
+        def item_list
+          items = if vdc
+            vdc.available_networks.select {|link| link[:type] == "application/vnd.vmware.vcloud.network+xml"}
+          else
+            data = service.get_organization(organization.id).body
+            data[:Link].select { |link| link[:type] == "application/vnd.vmware.vcloud.orgNetwork+xml" }
+          end
+          items.each{|item| service.add_id_from_href!(item) }
+          items
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/organization.rb

@@ -0,0 +1,37 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class VcloudDirector
+      class Organization < Model
+        identity  :id
+
+        attribute :name
+        attribute :type
+        attribute :href
+        attribute :description, :aliases => :Description
+        attribute :full_name, :aliases => :FullName
+
+        def vdcs
+          requires :id
+          service.vdcs(:organization => self)
+        end
+
+        def catalogs
+          requires :id
+          service.catalogs(:organization => self)
+        end
+
+        def networks
+          requires :id
+          service.networks(:organization => self)
+        end
+
+        def tasks
+          requires :id
+          service.tasks(:organization => self)
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/organizations.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/vcloud_director/models/compute/organization'
+
+module Fog
+  module Compute
+    class VcloudDirector
+      class Organizations < Collection
+        model Fog::Compute::VcloudDirector::Organization
+
+        private
+
+        def get_by_id(org_id)
+          org = service.get_organization(org_id).body
+          org.delete(:Link)
+          service.add_id_from_href!(org)
+          org
+        end
+
+        def item_list
+          data = service.get_organizations.body
+          orgs = data[:Org]
+          orgs.each {|org| service.add_id_from_href!(org)}
+          orgs
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/tag.rb

@@ -0,0 +1,31 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class VcloudDirector
+      class Tag < Model
+        identity  :id
+        attribute :value
+
+        def value=(new_value)
+          has_changed = ( value != new_value )
+          not_first_set = !value.nil?
+          attributes[:value] = new_value
+          if not_first_set && has_changed
+            response = service.put_vapp_metadata_item_metadata(vm.id, id, value)
+            service.process_task(response.body)
+          end
+        end
+
+        def destroy
+          response = service.delete_vapp_metadata_item_metadata(vm.id, id)
+          service.process_task(response.body)
+        end
+
+        def vm
+          attributes[:vm]
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/tags.rb

@@ -0,0 +1,41 @@
+require 'fog/core/collection'
+require 'fog/vcloud_director/models/compute/tag'
+
+module Fog
+  module Compute
+    class VcloudDirector
+      class Tags < Collection
+        model Fog::Compute::VcloudDirector::Tag
+
+        attribute :vm
+
+        def get_by_name(tag_name)
+          get(tag_name)
+        end
+
+        def get_by_id(item_id)
+          item_list unless @items
+          @items.find{ |i| i[:id] == item_id}
+        end
+
+        def create(key,value)
+          response = service.post_update_vapp_metadata(vm.id, { key => value} )
+          service.process_task(response.body)
+        end
+
+        def hash_items
+          @tags = service.get_metadata(vm.id).body
+          @tags[:metadata]
+        end
+
+        private
+
+        def item_list
+          @items =[]
+          hash_items.each_pair{ |k,v| @items << {:id => k, :value => v }.merge(:vm => vm) }
+          @items
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/task.rb

@@ -0,0 +1,55 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class VcloudDirector
+      class Task < Fog::Model
+        identity  :id
+
+        attribute :href
+        attribute :type
+        attribute :name
+        attribute :end_time, :aliases => :endTime, :type => :time
+        attribute :expiry_time, :aliases => :expiryTime, :type => :time
+        attribute :operation
+        attribute :operation_name, :aliases => :operationName
+        attribute :start_time, :aliases => :startTime, :type => :time
+        attribute :status
+        attribute :description, :aliases => :Description
+        attribute :error, :aliases => :Error
+        attribute :progress, :aliases => :Progress, :type => :integer
+
+        # Since 5.1
+        attribute :operation_key, :aliases => :operationKey
+        attribute :cancel_requested, :aliases => :cancelRequested, :type => :boolean
+        attribute :service_namespace, :aliases => :serviceNamespace
+        attribute :details, :aliases => :Details
+
+        def ready?
+          status == 'success'
+        end
+
+        def success?
+          status == 'success'
+        end
+
+        def non_running?
+          if @service.show_progress? && (@last_progress ||= 0) < 100
+            if status == 'running' || status == 'queued'
+              Fog::Formatador.redisplay_progressbar(progress, 100, :label => operation_name, :started_at => start_time)
+              @last_progress = progress
+            elsif status == 'success'
+              Fog::Formatador.redisplay_progressbar(100, 100, :label => operation_name, :started_at => start_time)
+              @last_progress = 100
+            end
+          end
+          ! %w(running queued).include?(status)
+        end
+
+        def cancel
+          service.post_cancel_task(id)
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/tasks.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/vcloud_director/models/compute/task'
+
+module Fog
+  module Compute
+    class VcloudDirector
+      class Tasks < Collection
+
+        include Fog::VcloudDirector::Query
+
+        model Fog::Compute::VcloudDirector::Task
+
+        attribute :organization
+
+        def query_type
+          "task"
+        end
+
+        def get(id)
+          data = service.get_task(id).body
+          return nil unless data
+          data[:id] = data[:href].split('/').last
+          data[:progress] ||= 0
+          new(data)
+        end
+
+        private
+
+        def item_list
+          data = service.get_task_list(organization.id).body
+          data[:Task].each {|task| service.add_id_from_href!(task)}
+        end
+      end
+    end
+  end
+end