brightbox-cli 0.18.1 → 1.0.0.rc1

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/models/compute/server.rb

@@ -1,107 +0,0 @@
-require 'fog/compute/models/server'
-
-module Fog
-  module Compute
-    class Vsphere
-
-      class Server < Fog::Compute::Server
-
-        # This will be the instance uuid which is globally unique across
-        # a vSphere deployment.
-        identity  :id
-
-        # JJM REVISIT (Extend the model of a vmware server)
-        # SEE: http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.VirtualMachine.html
-        # (Take note of the See also section.)
-        # In particular:
-        #   GuestInfo: information about the guest operating system
-        #   VirtualMachineConfigInfo: Access to the VMX file and configuration
-
-        attribute :name
-        # UUID may be the same from VM to VM if the user does not select (I copied it)
-        attribute :uuid
-        # Instance UUID should be unique across a vCenter deployment.
-        attribute :instance_uuid
-        attribute :hostname
-        attribute :operatingsystem
-        attribute :ipaddress
-        attribute :power_state,   :aliases => 'power'
-        attribute :tools_state,   :aliases => 'tools'
-        attribute :tools_version
-        attribute :mac_addresses, :aliases => 'macs'
-        attribute :hypervisor,    :aliases => 'host'
-        attribute :is_a_template
-        attribute :connection_state
-        attribute :mo_ref
-        attribute :path
-
-        def vm_reconfig_memory(options = {})
-          requires :instance_uuid, :memory
-          connection.vm_reconfig_memory('instance_uuid' => instance_uuid, 'memory' => memory)
-        end
-        def vm_reconfig_cpus(options = {})
-          requires :instance_uuid, :cpus
-          connection.vm_reconfig_cpus('instance_uuid' => instance_uuid, 'cpus' => cpus)
-        end
-        def vm_reconfig_hardware(options = {})
-          requires :instance_uuid, :hardware_spec
-          connection.vm_reconfig_hardware('instance_uuid' => instance_uuid, 'hardware_spec' => hardware_spec)
-        end
-        def start(options = {})
-          requires :instance_uuid
-          connection.vm_power_on('instance_uuid' => instance_uuid)
-        end
-
-        def stop(options = {})
-          options = { :force => false }.merge(options)
-          requires :instance_uuid
-          connection.vm_power_off('instance_uuid' => instance_uuid, 'force' => options[:force])
-        end
-
-        def reboot(options = {})
-          options = { :force => false }.merge(options)
-          requires :instance_uuid
-          connection.vm_reboot('instance_uuid' => instance_uuid, 'force' => options[:force])
-        end
-
-        def destroy(options = {})
-          requires :instance_uuid
-          connection.vm_destroy('instance_uuid' => instance_uuid)
-        end
-
-        def migrate(options = {})
-          options = { :priority => 'defaultPriority' }.merge(options)
-          requires :instance_uuid
-          connection.vm_migrate('instance_uuid' => instance_uuid, 'priority' => options[:priority])
-        end
-
-        def create(options ={})
-          requires :name, :path
-          new_vm = self.class.new(create_results['vm_attributes'])
-          new_vm.collection = self.collection
-          new_vm.connection = self.connection
-          new_vm
-        end
-        def clone(options = {})
-          requires :name, :path
-          # Convert symbols to strings
-          req_options = options.inject({}) { |hsh, (k,v)| hsh[k.to_s] = v; hsh }
-          # Give our path to the request
-          req_options['path'] ="#{path}/#{name}"
-          # Perform the actual clone
-          clone_results = connection.vm_clone(req_options)
-          # Create the new VM model.
-          new_vm = self.class.new(clone_results['vm_attributes'])
-          # We need to assign the collection and the connection otherwise we
-          # cannot reload the model.
-          new_vm.collection = self.collection
-          new_vm.connection = self.connection
-          # Return the new VM model.
-          new_vm
-        end
-
-      end
-
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/models/compute/servers.rb

@@ -1,43 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/server'
-
-module Fog
-  module Compute
-    class Vsphere
-
-      class Servers < Fog::Collection
-
-        model Fog::Compute::Vsphere::Server
-
-        # 'path' => '/Datacenters/vm/Jeff/Templates' will be MUCH faster.
-        # than simply listing everything.
-        def all(filters = {})
-          # REVISIT: I'm not sure if this is the best way to implement search
-          # filters on a collection but it does work.  I need to study the AWS
-          # code more to make sure this matches up.
-          filters['folder'] ||= attributes['folder']
-          response = connection.list_virtual_machines(filters)
-          load(response['virtual_machines'])
-        end
-
-        def get(id)
-          # Is the id a managed_object_reference?  This may be the case if we're reloading
-          # a model of a VM in the process of being cloned, since it
-          # will not have a instance_uuid yet.
-          if id =~ /^vm-/
-            response = connection.find_vm_by_ref('vm_ref' => id)
-            server_attributes = response['virtual_machine']
-          else
-            response = connection.list_virtual_machines('instance_uuid' => id)
-            server_attributes = response['virtual_machines'].first
-          end
-          new(server_attributes)
-        rescue Fog::Compute::Vsphere::NotFound
-          nil
-        end
-
-      end
-
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/requests/compute/current_time.rb

@@ -1,22 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Real
-
-        def current_time
-          current_time = @connection.serviceInstance.CurrentTime
-          { 'current_time' => current_time }
-        end
-
-      end
-
-      class Mock
-
-        def current_time
-          { 'current_time' => Time.now.utc }
-        end
-
-      end
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/requests/compute/datacenters.rb

@@ -1,34 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Real
-        def datacenters
-          @datacenters ||= datacenters_reload
-          # Hide the values which are the RbVmomi instances
-          @datacenters.keys
-        end
-
-        private
-
-        def datacenters_reload
-          @rootfolder  ||= @connection.rootFolder
-          inventory = @rootfolder.inventory(:Datacenter => [ 'name' ])[@rootfolder]
-          # Convert the inventory into a Hash of the form: We remove the
-          # property selectors.  { "<dc_name>" => #<RbVmomi::VIM::Datacenter> }
-          # The Datacenter instance itself is at index 0 and the properties we
-          # collected are at index 1.
-          inventory.inject({}) do |memo, (name,dc_ary)|
-            memo[name] = dc_ary[0]
-            memo
-          end
-        end
-      end
-
-      class Mock
-        def datacenters
-          [ "Solutions", "Solutions2", "Solutions3" ]
-        end
-      end
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/requests/compute/find_vm_by_ref.rb

@@ -1,41 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-
-      module Shared
-
-        # REVISIT:  This is a naive implementation and not very efficient since
-        # we find ALL VM's and then iterate over them looking for the managed object
-        # reference id...  There should be an easier way to obtain a reference to a
-        # VM using only the name or the _ref.  This request is primarily intended to
-        # reload the attributes of a cloning VM which does not yet have an instance_uuid
-        def find_vm_by_ref(options = {})
-          raise ArgumentError, "Must pass a vm_ref option" unless options['vm_ref']
-
-          # This is the inefficient call
-          all_vm_attributes = list_virtual_machines['virtual_machines']
-          # Find the VM attributes of the reference
-          if vm_attributes = all_vm_attributes.find { |vm| vm['mo_ref'] == options['vm_ref'] }
-            response = { 'virtual_machine' => vm_attributes }
-          else
-            raise Fog::Compute::Vsphere::NotFound, "VirtualMachine with Managed Object Reference #{options['vm_ref']} could not be found."
-          end
-          response
-        end
-
-      end
-
-      # The Real and Mock classes share the same method
-      # because list_virtual_machines will be properly mocked for us
-
-      class Real
-        include Shared
-      end
-
-      class Mock
-        include Shared
-      end
-
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/requests/compute/list_virtual_machines.rb

@@ -1,236 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Real
-        def list_virtual_machines(options = {})
-          # Listing all VM's can be quite slow and expensive.  Try and optimize
-          # based on the available options we have.  These conditions are in
-          # ascending order of  time to complete for large deployments.
-          if options['instance_uuid'] then
-            list_all_virtual_machines_by_instance_uuid(options)
-          elsif options['folder'] then
-            list_all_virtual_machines_in_folder(options)
-          else
-            list_all_virtual_machines
-          end
-        end
-
-        private
-
-        def list_all_virtual_machines_in_folder(options = {})
-          # Tap gets rid of the leading empty string and "Datacenters" element
-          # and returns the array.
-          path_elements = options['folder'].split('/').tap { |ary| ary.shift 2 }
-          # The DC name itself.
-          dc_name = path_elements.shift
-          # If the first path element contains "vm" this denotes the vmFolder
-          # and needs to be shifted out since each DC contains only one
-          # vmFolder
-          path_elements.shift if path_elements[0] == 'vm'
-          # Make sure @datacenters is populated (the keys are DataCenter instances)
-          self.datacenters.include? dc_name or raise ArgumentError, "Could not find a Datacenter named #{dc_name}"
-          # Get the datacenter managed object
-          dc = @datacenters[dc_name]
-
-          # Get the VM Folder (Group) efficiently
-          vm_folder = dc.vmFolder
-
-          # Walk the tree resetting the folder pointer as we go
-          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
-            # JJM VIM::Folder#find appears to be quite efficient as it uses the
-            # searchIndex It certainly appears to be faster than
-            # VIM::Folder#inventory since that returns _all_ managed objects of
-            # a certain type _and_ their properties.
-            sub_folder = current_folder.find(sub_folder_name, RbVmomi::VIM::Folder)
-            raise ArgumentError, "Could not descend into #{sub_folder_name}.  Please check your path." unless sub_folder
-            sub_folder
-          end
-
-          # This should be efficient since we're not obtaining properties
-          virtual_machines = folder.children.inject([]) do |ary, child|
-            if child.is_a? RbVmomi::VIM::VirtualMachine then
-              ary << convert_vm_mob_ref_to_attr_hash(child)
-            end
-            ary
-          end
-
-          # Return the managed objects themselves as an array.  These may be converted
-          # to an attribute has using convert_vm_mob_ref_to_attr_hash
-          { 'virtual_machines' => virtual_machines }
-        end
-
-        def list_all_virtual_machines_by_instance_uuid(options = {})
-          uuid = options['instance_uuid']
-          search_filter = { :uuid => uuid, 'vmSearch' => true, 'instanceUuid' => true }
-          vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first
-          if vm_attribute_hash = convert_vm_mob_ref_to_attr_hash(vm_mob_ref) then
-            virtual_machines = [ vm_attribute_hash ]
-          else
-            virtual_machines = [ ]
-          end
-          { 'virtual_machines' => virtual_machines }
-        end
-
-        def list_all_virtual_machines
-          virtual_machines = list_all_virtual_machine_mobs.collect do |vm_mob|
-            convert_vm_mob_ref_to_attr_hash(vm_mob)
-          end
-          { 'virtual_machines' => virtual_machines }
-        end
-
-
-        # NOTE: This is a private instance method required by the vm_clone
-        # request.  It's very hard to get the Managed Object Reference
-        # of a Template because we can't search for it by instance_uuid
-        # As a result, we need a list of all virtual machines, and we
-        # need them in "native" format, not filter attribute format.
-        def list_all_virtual_machine_mobs
-          virtual_machines = Array.new
-          # Find each datacenter
-          datacenters = @connection.rootFolder.children.find_all do |child|
-            child.kind_of? RbVmomi::VIM::Datacenter
-          end
-          # Next, search the "vmFolder" inventory of each data center:
-          datacenters.each do |dc|
-            inventory = dc.vmFolder.inventory( 'VirtualMachine' => :all )
-            virtual_machines << find_all_in_inventory(inventory, :type => RbVmomi::VIM::VirtualMachine, :property => 'name' )
-          end
-
-          virtual_machines.flatten
-        end
-
-        def find_all_in_inventory(inventory, properties = { :type => RbVmomi::VIM::VirtualMachine, :property => nil } )
-          results = Array.new
-
-          inventory.each do |k,v|
-
-            # If we have a VMware folder we need to traverse the directory
-            # to ensure we pick VMs inside folders. So we do a bit of recursion
-            # here.
-            results << find_all_in_inventory(v) if k.is_a? RbVmomi::VIM::Folder
-
-            if v[0].is_a? properties[:type]
-              if properties[:property].nil?
-                results << v[0]
-              else
-                results << v[1][properties[:property]]
-              end
-            end
-          end
-          results.flatten
-        end
-
-        def get_folder_path(folder, root = nil)
-          if ( not folder.methods.include?('parent') ) or ( folder == root )
-            return
-          end
-          "#{get_folder_path(folder.parent)}/#{folder.name}"
-        end
-      end
-
-      class Mock
-
-        def get_folder_path(folder, root = nil)
-          nil
-        end
-
-        def list_virtual_machines(options = {})
-          case options['instance_uuid']
-          when nil
-            rval = YAML.load <<-'ENDvmLISTING'
----
-virtual_machines:
-- name: centos56gm
-  hypervisor: gunab.puppetlabs.lan
-  tools_version: guestToolsCurrent
-  ipaddress:
-  mo_ref: vm-698
-  power_state: poweredOff
-  uuid: 42322347-d791-cd34-80b9-e25fe28ad37c
-  is_a_template: true
-  id: 50323f93-6835-1178-8b8f-9e2109890e1a
-  tools_state: toolsNotRunning
-  connection_state: connected
-  instance_uuid: 50323f93-6835-1178-8b8f-9e2109890e1a
-  hostname:
-  mac_addresses:
-    Network adapter 1: 00:50:56:b2:00:a1
-  operatingsystem:
-- name: centos56gm2
-  hypervisor: gunab.puppetlabs.lan
-  tools_version: guestToolsCurrent
-  ipaddress:
-  mo_ref: vm-640
-  power_state: poweredOff
-  uuid: 564ddcbe-853a-d29a-b329-a0a3693a004d
-  is_a_template: true
-  id: 5257dee8-050c-cbcd-ae25-db0e582ab530
-  tools_state: toolsNotRunning
-  connection_state: connected
-  instance_uuid: 5257dee8-050c-cbcd-ae25-db0e582ab530
-  hostname:
-  mac_addresses:
-    Network adapter 1: 00:0c:29:3a:00:4d
-  operatingsystem:
-- name: dashboard_gm
-  hypervisor: gunab.puppetlabs.lan
-  tools_version: guestToolsCurrent
-  ipaddress: 192.168.100.184
-  mo_ref: vm-669
-  power_state: poweredOn
-  uuid: 564d3f91-3452-a509-a678-1246f7897979
-  is_a_template: false
-  id: 5032739c-c871-c0d2-034f-9700a0b5383e
-  tools_state: toolsOk
-  connection_state: connected
-  instance_uuid: 5032739c-c871-c0d2-034f-9700a0b5383e
-  hostname: compliance.puppetlabs.vm
-  mac_addresses:
-    Network adapter 1: 00:50:56:b2:00:96
-  operatingsystem: Red Hat Enterprise Linux 6 (64-bit)
-- name: jefftest
-  hypervisor: gunab.puppetlabs.lan
-  tools_version: guestToolsCurrent
-  ipaddress: 192.168.100.187
-  mo_ref: vm-715
-  power_state: poweredOn
-  uuid: 42329da7-e8ab-29ec-1892-d6a4a964912a
-  is_a_template: false
-  id: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-  tools_state: toolsOk
-  connection_state: connected
-  instance_uuid: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-  hostname: centos56gm.localdomain
-  mac_addresses:
-    Network adapter 1: 00:50:56:b2:00:af
-  operatingsystem: CentOS 4/5 (32-bit)
-ENDvmLISTING
-          when '5032c8a5-9c5e-ba7a-3804-832a03e16381'
-            YAML.load <<-'5032c8a5-9c5e-ba7a-3804-832a03e16381'
----
-virtual_machines:
-- name: jefftest
-  hypervisor: gunab.puppetlabs.lan
-  tools_version: guestToolsCurrent
-  ipaddress: 192.168.100.187
-  mo_ref: vm-715
-  power_state: poweredOn
-  uuid: 42329da7-e8ab-29ec-1892-d6a4a964912a
-  is_a_template: false
-  id: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-  tools_state: toolsOk
-  connection_state: connected
-  instance_uuid: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-  hostname: centos56gm.localdomain
-  mac_addresses:
-    Network adapter 1: 00:50:56:b2:00:af
-  operatingsystem: CentOS 4/5 (32-bit)
-            5032c8a5-9c5e-ba7a-3804-832a03e16381
-          when 'does-not-exist-and-is-not-a-uuid', '50323f93-6835-1178-8b8f-9e2109890e1a'
-            { 'virtual_machines' => [] }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/requests/compute/vm_clone.rb

@@ -1,171 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-
-      module Shared
-        private
-        def vm_clone_check_options(options)
-          default_options = {
-            'force'        => false,
-            'linked_clone' => false,
-          }
-          options = default_options.merge(options)
-          required_options = %w{ path name }
-          required_options.each do |param|
-            raise ArgumentError, "#{required_options.join(', ')} are required" unless options.has_key? param
-          end
-          # The tap removes the leading empty string
-          path_elements = options['path'].split('/').tap { |o| o.shift }
-          first_folder = path_elements.shift
-          if first_folder != 'Datacenters' then
-            raise ArgumentError, "vm_clone path option must start with /Datacenters.  Got: #{options['path']}"
-          end
-          dc_name = path_elements.shift
-          if not self.datacenters.include? dc_name then
-            raise ArgumentError, "Datacenter #{dc_name} does not exist, only datacenters #{self.dacenters.join(",")} are accessible."
-          end
-          options
-        end
-      end
-
-      class Real
-        include Shared
-        def vm_clone(options = {})
-          # Option handling
-          options = vm_clone_check_options(options)
-
-          notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Could not find VM template" }
-
-          # Find the template in the folder.  This is more efficient than
-          # searching ALL VM's looking for the template.
-          # Tap gets rid of the leading empty string and "Datacenters" element
-          # and returns the array.
-          path_elements = options['path'].split('/').tap { |ary| ary.shift 2 }
-          # The DC name itself.
-          template_dc = path_elements.shift
-          # If the first path element contains "vm" this denotes the vmFolder
-          # and needs to be shifted out
-          path_elements.shift if path_elements[0] == 'vm'
-          # The template name.  The remaining elements are the folders in the
-          # datacenter.
-          template_name = path_elements.pop
-          # Make sure @datacenters is populated.  We need the instances from the Hash keys.
-          self.datacenters
-          # Get the datacenter managed object from the hash
-          dc = @datacenters[template_dc]
-          # Get the VM Folder (Group) efficiently
-          vm_folder = dc.vmFolder
-          # Walk the tree resetting the folder pointer as we go
-          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
-            # JJM VIM::Folder#find appears to be quite efficient as it uses the
-            # searchIndex It certainly appears to be faster than
-            # VIM::Folder#inventory since that returns _all_ managed objects of
-            # a certain type _and_ their properties.
-            sub_folder = current_folder.find(sub_folder_name, RbVmomi::VIM::Folder)
-            raise ArgumentError, "Could not descend into #{sub_folder_name}.  Please check your path." unless sub_folder
-            sub_folder
-          end
-
-          # Now find the template itself using the efficient find method
-          vm_mob_ref = folder.find(template_name, RbVmomi::VIM::VirtualMachine)
-
-          # Now find _a_ resource pool of the template's host (REVISIT: We need
-          # to support cloning into a specific RP)
-          esx_host = vm_mob_ref.collect!('runtime.host')['runtime.host']
-          # The parent of the ESX host itself is a ComputeResource which has a resourcePool
-          resource_pool = esx_host.parent.resourcePool
-          relocation_spec=nil
-          if ( options['linked_clone'] )
-            # cribbed heavily from the rbvmomi clone_vm.rb
-            # this chunk of code reconfigures the disk of the clone source to be read only,
-            # and then creates a delta disk on top of that, this is required by the API in order to create
-            # linked clondes
-            disks = vm_mob_ref.config.hardware.device.select do |vm_device|
-              vm_device.class == RbVmomi::VIM::VirtualDisk
-            end
-            disks.select{|vm_device| vm_device.backing.parent == nil}.each do |disk|
-              disk_spec = {
-                :deviceChange => [
-                  {
-                    :operation => :remove,
-                    :device => disk
-                  },
-                  {
-                    :operation => :add,
-                    :fileOperation => :create,
-                    :device => disk.dup.tap{|disk_backing|
-                      disk_backing.backing = disk_backing.backing.dup;
-                      disk_backing.backing.fileName = "[#{disk.backing.datastore.name}]";
-                      disk_backing.backing.parent = disk.backing
-                    }
-                  },
-                ]
-              }
-              vm_mob_ref.ReconfigVM_Task(:spec => disk_spec).wait_for_completion
-            end
-            # Next, create a Relocation Spec instance
-            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
-                                                                      :diskMoveType => :moveChildMostDiskBacking)
-          else
-            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
-                                                                      :transform => options['transform'] || 'sparse')
-          end
-          # And the clone specification
-          clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(:location => relocation_spec,
-                                                            :powerOn  => options['power_on'] || true,
-                                                            :template => false)
-          task = vm_mob_ref.CloneVM_Task(:folder => vm_mob_ref.parent, :name => options['name'], :spec => clone_spec)
-          # Waiting for the VM to complete allows us to get the VirtulMachine
-          # object of the new machine when it's done.  It is HIGHLY recommended
-          # to set 'wait' => true if your app wants to wait.  Otherwise, you're
-          # going to have to reload the server model over and over which
-          # generates a lot of time consuming API calls to vmware.
-          if options['wait'] then
-            # REVISIT: It would be awesome to call a block passed to this
-            # request to notify the application how far along in the process we
-            # are.  I'm thinking of updating a progress bar, etc...
-            new_vm = task.wait_for_completion
-          else
-            tries = 0
-            new_vm = begin
-              # Try and find the new VM (folder.find is quite efficient)
-              folder.find(options['name'], RbVmomi::VIM::VirtualMachine) or raise Fog::Vsphere::Errors::NotFound
-            rescue Fog::Vsphere::Errors::NotFound
-              tries += 1
-              if tries <= 10 then
-                sleep 15
-                retry
-              end
-              nil
-            end
-          end
-
-          # Return hash
-          {
-            'vm_ref'        => new_vm ? new_vm._ref : nil,
-            'vm_attributes' => new_vm ? convert_vm_mob_ref_to_attr_hash(new_vm) : {},
-            'task_ref'      => task._ref
-          }
-        end
-
-      end
-
-      class Mock
-        include Shared
-        def vm_clone(options = {})
-          # Option handling
-          options = vm_clone_check_options(options)
-          notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Cloud not find VM template" }
-          vm_mob_ref = list_virtual_machines['virtual_machines'].find(notfound) do |vm|
-            vm['name'] == options['path'].split("/")[-1]
-          end
-          {
-            'vm_ref'   => 'vm-123',
-            'task_ref' => 'task-1234',
-          }
-        end
-
-      end
-    end
-  end
-end