bosh-director 1.3160.0 → 1.3163.0

data/lib/bosh/director/api/controllers/disks_controller.rb

@@ -0,0 +1,20 @@
+require 'bosh/director/api/controllers/base_controller'
+
+module Bosh::Director
+  module Api::Controllers
+    class DisksController < BaseController
+      get '/' do
+        content_type(:json)
+        orphan_json = @disk_manager.list_orphan_disks
+        json_encode(orphan_json)
+      end
+
+      delete '/:orphan_disk_cid' do
+        job_queue = JobQueue.new
+        task = Bosh::Director::Jobs::DeleteOrphanDisks.enqueue(current_user, [params[:orphan_disk_cid]], job_queue)
+
+        redirect "/tasks/#{task.id}"
+      end
+    end
+  end
+end

data/lib/bosh/director/api/controllers/info_controller.rb

@@ -17,8 +17,8 @@ module Bosh::Director
           'user_authentication' => @config.identity_provider.client_info,
           'features' => {
             'dns' => {
-              'status' => Config.dns_enabled?,
-              'extras' => {'domain_name' => dns_domain_name}
+              'status' => @dns_manager.dns_enabled?,
+              'extras' => {'domain_name' => @dns_manager.dns_domain_name}
             },
             'compiled_package_cache' => {
               'status' => Config.use_compiled_package_cache?,

data/lib/bosh/director/api/controllers/releases_controller.rb

@@ -25,22 +25,7 @@ module Bosh::Director
       end
 
       get '/', scope: :read do
-        releases = Models::Release.order_by(:name.asc).map do |release|
-          release_versions = release.versions_dataset.order_by(:version.asc).map do |rv|
-            {
-              'version' => rv.version.to_s,
-              'commit_hash' => rv.commit_hash,
-              'uncommitted_changes' => rv.uncommitted_changes,
-              'currently_deployed' => !rv.deployments.empty?,
-              'job_names' => rv.templates.map(&:name),
-            }
-          end
-
-          {
-            'name' => release.name,
-            'release_versions' => release_versions,
-          }
-        end
+        releases = @release_manager.get_all_releases
 
         json_encode(releases)
       end

data/lib/bosh/director/api/controllers/stemcells_controller.rb

@@ -23,15 +23,7 @@ module Bosh::Director
       end
 
       get '/', scope: :read do
-        stemcells = Models::Stemcell.order_by(:name.asc).map do |stemcell|
-          {
-            'name' => stemcell.name,
-            'operating_system' => stemcell.operating_system,
-            'version' => stemcell.version,
-            'cid' => stemcell.cid,
-            'deployments' => stemcell.deployments.map { |d| { name: d.name } }
-          }
-        end
+        stemcells = @stemcell_manager.find_all_stemcells
         json_encode(stemcells)
       end
 

data/lib/bosh/director/api/deployment_manager.rb

@@ -48,7 +48,8 @@ module Bosh::Director
             'agent_id' => vm.agent_id,
             'cid' => vm.cid,
             'job' => instance ? instance.job : nil,
-            'index' => instance ? instance.index : nil
+            'index' => instance ? instance.index : nil,
+            'id' => instance ? instance.uuid : nil
           }
         end
 

data/lib/bosh/director/api/instance_lookup.rb

@@ -31,6 +31,23 @@ module Bosh::Director
         instance
       end
 
+      def by_uuid(deployment_name, job_name, uuid)
+        deployment = DeploymentLookup.new.by_name(deployment_name)
+
+        filter = {
+            deployment_id: deployment.id,
+            job: job_name,
+            uuid: uuid
+        }
+
+        instance = Models::Instance.find(filter)
+        if instance.nil?
+          raise InstanceNotFound,
+                "`#{deployment_name}/#{job_name}/#{uuid}' doesn't exist"
+        end
+        instance
+      end
+
       def by_filter(filter)
         instances = Models::Instance.filter(filter).all
         if instances.empty?

data/lib/bosh/director/api/instance_manager.rb

@@ -6,14 +6,19 @@ module Bosh::Director
       # @raise [InstanceNotFound]
       def find_instance(instance_id)
         InstanceLookup.new.by_id(instance_id)
-      end
+        end
 
       # @param [String] deployment_name Deployment name
       # @param [String] job Job name
-      # @param [String] index Job index
+      # @param [String] index_or_id Job index or id
       # @return [Models::Instance]
-      def find_by_name(deployment_name, job, index)
-        InstanceLookup.new.by_attributes(deployment_name, job, index)
+      def find_by_name(deployment_name, job, index_or_id)
+        # This is for backwards compatibility and can be removed when we move to referencing job by instance id only.
+        if index_or_id.to_s =~ /^\d+$/
+          InstanceLookup.new.by_attributes(deployment_name, job, index_or_id)
+        else
+          InstanceLookup.new.by_uuid(deployment_name, job, index_or_id)
+        end
       end
 
       # @param [Hash] filter Sequel-style DB record filter
@@ -29,23 +34,28 @@ module Bosh::Director
         vm = instance.vm
         if vm.nil?
           raise InstanceVmMissing,
-                "`#{instance.job}/#{instance.index}' doesn't reference a VM"
+                "`#{instance.job}/#{instance.uuid} (#{instance.index})' doesn't reference a VM"
         end
 
         if vm.agent_id.nil?
           raise VmAgentIdMissing, "VM `#{vm.cid}' doesn't have an agent id"
         end
 
-        AgentClient.with_defaults(vm.agent_id)
+        AgentClient.with_vm(vm)
       end
 
-      def fetch_logs(username, deployment_name, job, index, options = {})
-        if deployment_name.nil? || job.nil? || index.nil?
+      def fetch_logs(username, deployment_name, job, index_or_id, options = {})
+        if deployment_name.nil? || job.nil? || index_or_id.nil?
           raise DirectorError,
-                'deployment, job and index parameters are required'
+                'deployment, job and index/id parameters are required'
         end
 
-        instance = find_by_name(deployment_name, job, index)
+        # This is for backwards compatibility and can be removed when we move to referencing job by instance id only.
+        if index_or_id.to_s =~ /^\d+$/
+          instance = find_by_name(deployment_name, job, index_or_id)
+        else
+          instance = filter_by(uuid: index_or_id).first
+        end
 
         JobQueue.new.enqueue(username, Jobs::FetchLogs, 'fetch logs', [instance.id, options])
       end

data/lib/bosh/director/api/release_manager.rb

@@ -3,10 +3,34 @@ module Bosh::Director
     class ReleaseManager
       include ApiHelper
 
-      # Finds release by name
-      # @param [String] name Release name
-      # @return [Models::Release]
-      # @raise [ReleaseNotFound]
+      def get_all_releases
+        releases = Models::Release.order_by(:name.asc).map do |release|
+          sorted_version_tuples = release.versions_dataset.all.map do |version|
+            {
+              provided: version,
+              parsed: Bosh::Common::Version::ReleaseVersion.parse(version.values[:version])
+            }
+          end.sort_by { |rv| rv[:parsed] }
+          release_versions = sorted_version_tuples.map do |version|
+            provided = version[:provided]
+            {
+              'version' => provided.version.to_s,
+              'commit_hash' => provided.commit_hash,
+              'uncommitted_changes' => provided.uncommitted_changes,
+              'currently_deployed' => !provided.deployments.empty?,
+              'job_names' => provided.templates.map(&:name),
+            }
+          end
+
+          {
+            'name' => release.name,
+            'release_versions' => release_versions
+          }
+        end
+
+        releases
+      end
+
       def find_by_name(name)
         release = Models::Release[:name => name]
         if release.nil?
@@ -15,10 +39,6 @@ module Bosh::Director
         release
       end
 
-      # @param [Models::Release] release Release model
-      # @param [String] version Release version
-      # @return [Models::ReleaseVersion] Release version model
-      # @raise [ReleaseVersionInvalid, ReleaseVersionNotFound]
       def find_version(release, version)
         dataset = release.versions_dataset
 

data/lib/bosh/director/api/resurrector_manager.rb

@@ -1,8 +1,15 @@
 module Bosh::Director
   module Api
     class ResurrectorManager
-      def set_pause_for_instance(deployment_name, job_name, job_index, desired_state)
-        instance = InstanceLookup.new.by_attributes(deployment_name, job_name, job_index)
+      def set_pause_for_instance(deployment_name, job_name, index_or_id, desired_state)
+
+        # This is for backwards compatibility and can be removed when we move to referencing job by instance id only.
+        if index_or_id.to_s =~ /^\d+$/
+          instance = InstanceLookup.new.by_attributes(deployment_name, job_name, index_or_id)
+        else
+          instance = InstanceLookup.new.by_uuid(deployment_name, job_name, index_or_id)
+        end
+
         instance.resurrection_paused = desired_state
         instance.save
       end

data/lib/bosh/director/api/route_configuration.rb

@@ -11,8 +11,10 @@ module Bosh
           director_app = Bosh::Director::App.new(@config)
           controllers = {}
           controllers['/backups'] = Bosh::Director::Api::Controllers::BackupsController.new(@config)
+          controllers['/cleanup'] = Bosh::Director::Api::Controllers::CleanupController.new(@config)
           controllers['/cloud_configs'] = Bosh::Director::Api::Controllers::CloudConfigsController.new(@config)
           controllers['/deployments'] = Bosh::Director::Api::Controllers::DeploymentsController.new(@config)
+          controllers['/disks'] = Bosh::Director::Api::Controllers::DisksController.new(@config)
           controllers['/info'] = Bosh::Director::Api::Controllers::InfoController.new(@config)
           controllers['/locks'] = Bosh::Director::Api::Controllers::LocksController.new(@config)
           controllers['/packages'] = Bosh::Director::Api::Controllers::PackagesController.new(@config)

data/lib/bosh/director/api/snapshot_manager.rb

@@ -26,11 +26,13 @@ module Bosh::Director
         snapshot
       end
 
-      def snapshots(deployment, job=nil, index=nil)
+      def snapshots(deployment, job=nil, index_or_id=nil)
         filter = { deployment: deployment }
         filter[:job] = job if job
-        filter[:index] = index if index
-
+        if index_or_id
+          filter_key = index_or_id.to_s =~ /^\d+$/ ? :index : :uuid
+          filter[filter_key] = index_or_id
+        end
         result = []
         instances = Models::Instance.filter(filter).all
 
@@ -40,6 +42,7 @@ module Bosh::Director
               result << {
                   'job' => instance.job,
                   'index' => instance.index,
+                  'uuid' => instance.uuid,
                   'snapshot_cid' => snapshot.snapshot_cid,
                   'created_at' => snapshot.created_at.to_s,
                   'clean' => snapshot.clean
@@ -51,9 +54,10 @@ module Bosh::Director
         result
       end
 
-      def self.delete_snapshots(snapshots)
+      def self.delete_snapshots(snapshots, options={})
+        keep_snapshots_in_the_cloud = options.fetch(:keep_snapshots_in_the_cloud, false)
         snapshots.each do |snapshot|
-          Config.cloud.delete_snapshot(snapshot.snapshot_cid)
+          Config.cloud.delete_snapshot(snapshot.snapshot_cid) unless keep_snapshots_in_the_cloud
           snapshot.delete
         end
       end

data/lib/bosh/director/api/stemcell_manager.rb

@@ -1,4 +1,5 @@
 require 'securerandom'
+require 'common/version/stemcell_version_list'
 
 module Bosh::Director
   module Api
@@ -14,6 +15,40 @@ module Bosh::Director
         stemcell
       end
 
+      def find_all_stemcells
+        Models::Stemcell.order_by(:name.asc).map do |stemcell|
+          {
+            'name' => stemcell.name,
+            'operating_system' => stemcell.operating_system,
+            'version' => stemcell.version,
+            'cid' => stemcell.cid,
+            'deployments' => stemcell.deployments.map { |d| { name: d.name } }
+          }
+        end
+      end
+
+      def latest_by_os(os)
+        stemcells = Bosh::Director::Models::Stemcell.where(:operating_system => os)
+
+        if stemcells.nil? || stemcells.empty?
+          raise StemcellNotFound,
+            "Stemcell with Operating System `#{os}' doesn't exist"
+        end
+
+        find_latest(stemcells)
+      end
+
+      def latest_by_name(name)
+        stemcells = Bosh::Director::Models::Stemcell.where(:name => name)
+
+        if stemcells.nil? || stemcells.empty?
+          raise StemcellNotFound,
+            "Stemcell `#{name}' doesn't exist"
+        end
+
+        find_latest(stemcells)
+      end
+
       def find_by_os_and_version(os, version)
         stemcell = Bosh::Director::Models::Stemcell.
             dataset.order(:name)[:operating_system => os, :version => version]
@@ -49,6 +84,21 @@ module Bosh::Director
 
         JobQueue.new.enqueue(username, Jobs::DeleteStemcell, description, [stemcell.name, stemcell.version, options])
       end
+
+      private
+
+      def find_latest(stemcells)
+        versions = stemcells.map(&:version)
+
+        latest_version = Bosh::Common::Version::StemcellVersionList.parse(versions).latest.to_s
+
+        latest_stemcell = stemcells.find do |stemcell|
+          parsed_version = Bosh::Common::Version::StemcellVersion.parse(stemcell.version).to_s
+          parsed_version == latest_version
+        end
+
+        latest_stemcell
+      end
     end
   end
 end

data/lib/bosh/director/app.rb

@@ -9,7 +9,7 @@ module Bosh::Director
   class App
 
     class << self
-      # Some places (ie, resque jobs) need to reference the authoriative app instance
+      # Some places (ie, resque jobs) need to reference the authoritative app instance
       # from class methods.
       def instance
         @@instance

data/lib/bosh/director/cloudcheck_helper.rb

@@ -13,46 +13,14 @@ module Bosh::Director
     # still be pretty generous interval for agent to respond.
     DEFAULT_AGENT_TIMEOUT = 10
 
-    def cloud
-      Bosh::Director::Config.cloud
-    end
-
-    def handler_error(message)
-      raise Bosh::Director::ProblemHandlerError, message
-    end
-
-    def instance_name(vm)
-      instance = vm.instance
-      return "Unknown VM" if instance.nil?
-
-      job = instance.job || "unknown job"
-      index = instance.index || "unknown index"
-      "#{job}/#{index}"
-    end
-
-    def agent_client(vm, timeout = DEFAULT_AGENT_TIMEOUT, retries = 0)
-      options = {
-        :timeout => timeout,
-        :retry_methods => { :get_state => retries }
-      }
-      @clients ||= {}
-      @clients[vm.agent_id] ||= AgentClient.with_defaults(vm.agent_id, options)
-    end
-
-    def agent_timeout_guard(vm, &block)
-      yield agent_client(vm)
-    rescue Bosh::Director::RpcTimeout
-      handler_error("VM `#{vm.cid}' is not responding")
-    end
-
     def reboot_vm(vm)
       cloud.reboot_vm(vm.cid)
       begin
         agent_client(vm).wait_until_ready
       rescue Bosh::Director::RpcTimeout
-        handler_error("Agent still unresponsive after reboot")
+        handler_error('Agent still unresponsive after reboot')
       rescue Bosh::Director::TaskCancelled
-        handler_error("Task was cancelled")
+        handler_error('Task was cancelled')
       end
     end
 
@@ -60,151 +28,170 @@ module Bosh::Director
       # Paranoia: don't blindly delete VMs with persistent disk
       disk_list = agent_timeout_guard(vm) { |agent| agent.list_disk }
       if disk_list.size != 0
-        handler_error("VM has persistent disk attached")
+        handler_error('VM has persistent disk attached')
       end
 
-      cloud.delete_vm(vm.cid)
-      vm.db.transaction do
-        vm.instance.update(:vm => nil) if vm.instance
-        vm.destroy
-      end
+      vm_deleter.delete_vm(vm)
     end
 
     def delete_vm_reference(vm, options={})
       if vm.cid && !options[:skip_cid_check]
-        handler_error("VM has a CID")
+        handler_error('VM has a CID')
       end
 
-      vm.db.transaction do
-        vm.instance.update(:vm => nil) if vm.instance
-        vm.destroy
-      end
+      vm.destroy
     end
 
     def recreate_vm(vm)
-      # Best we can do without any feedback from the agent
-      # is to use the spec persisted in the DB at the time
-      # of last apply call.
-      # This method is somewhat similar in its nature to what
-      # InstanceUpdater is doing in case of the stemcell update,
-      # however we don't need to handle some advanced scenarios
-      # such as disk migration.
+      @logger.debug("Recreating Vm: #{vm.inspect}")
+      unless vm.instance
+        handler_error('VM does not have an associated instance')
+      end
+      instance_model = vm.instance
+      vm_env = vm.env
 
-      spec = validate_spec(vm)
-      env = validate_env(vm)
+      handler_error("VM doesn't belong to any deployment") unless vm.deployment
+      handler_error('Failed to recreate VM without instance') unless vm.instance
 
-      resource_pool_spec = spec.fetch("resource_pool", {})
-      stemcell = find_stemcell(resource_pool_spec.fetch("stemcell", {}))
+      validate_spec(vm.instance.spec)
+      validate_env(vm.env)
 
-      deployment = vm.deployment
-      handler_error("VM doesn't belong to any deployment") unless deployment
+      instance_plan_to_delete = DeploymentPlan::InstancePlan.new(
+        existing_instance: instance_model,
+        instance: nil,
+        desired_instance: nil,
+        network_plans: []
+      )
 
-      instance = vm.instance
-      disk_cid = instance ? instance.persistent_disk_cid : nil
-
-      # One situation where this handler is actually useful is when
-      # VM has already been deleted but something failed after that
-      # and it is still referenced in DB. In that case it makes sense
-      # to ignore "VM not found" errors in `delete_vm' and let the method
-      # proceed creating a new VM. Other errors are not forgiven.
       begin
-        cloud.delete_vm(vm.cid)
-      rescue Bosh::Clouds::VMNotFound => e
-        @logger.warn("VM '#{vm.cid}' might have already been deleted from the cloud")
-      end
+        vm_deleter.delete_for_instance_plan(instance_plan_to_delete)
+      rescue Bosh::Clouds::VMNotFound
+        # One situation where this handler is actually useful is when
+        # VM has already been deleted but something failed after that
+        # and it is still referenced in DB. In that case it makes sense
+        # to ignore "VM not found" errors in `delete_vm' and let the method
+        # proceed creating a new VM. Other errors are not forgiven.
 
-      vm.db.transaction do
-        instance.update(:vm => nil) if instance
-        vm.destroy
+        @logger.warn("VM '#{vm.cid}' might have already been deleted from the cloud")
       end
 
-      cloud_properties = resource_pool_spec.fetch("cloud_properties", {})
-      networks = spec["networks"]
-      new_vm = VmCreator.create(deployment, stemcell, cloud_properties, networks, Array(disk_cid), env)
-      new_vm.apply_spec = spec
-      new_vm.save
+      instance_plan_to_create = create_instance_plan(instance_model, vm_env)
 
-      if instance
-        instance.update(:vm => new_vm)
+      vm_creator.create_for_instance_plan(
+        instance_plan_to_create,
+        Array(instance_model.persistent_disk_cid)
+      )
 
-        # refresh metadata after new instance has been set
-        VmMetadataUpdater.build.update(new_vm, {})
-      end
+      dns_manager = DnsManager.create
+      dns_names_to_ip = {}
 
-      agent_client(new_vm).wait_until_ready
-
-      agent_client(new_vm).update_settings(Bosh::Director::Config.trusted_certs)
-      new_vm.update(:trusted_certs_sha1 => Digest::SHA1.hexdigest(Bosh::Director::Config.trusted_certs))
-
-      # After this point agent is actually responding to
-      # pings, so if the rest of this handler fails
-      # bcck won't find this type of problem again
-      # but regular deployment will fail with "out-of-sync"
-      # error (as we now have an instance that points to
-      # VM that reports empty state). This problem
-      # should be handled by "out-of-sync VM" problem handler.
-
-      if disk_cid
-        # N.B. attach_disk might fail if disk image is no longer
-        # there or for some other reason. Generally it means
-        # the data has been lost (e.g. someone deleted VM from vCenter
-        # along with the disk.
-        cloud.attach_disk(new_vm.cid, disk_cid)
-        agent_client(new_vm).mount_disk(disk_cid)
+      instance_plan_to_create.existing_instance.spec['networks'].each do |network_name, network|
+        index_dns_name = dns_manager.dns_record_name(instance_model.index, instance_model.job, network_name, instance_model.deployment.name)
+        dns_names_to_ip[index_dns_name] = network['ip']
+        id_dns_name = dns_manager.dns_record_name(instance_model.uuid, instance_model.job, network_name, instance_model.deployment.name)
+        dns_names_to_ip[id_dns_name] = network['ip']
       end
 
-      agent_client(new_vm).apply(spec)
+      @logger.debug("Updating DNS record for instance: #{instance_model.inspect}; to: #{dns_names_to_ip.inspect}")
+      dns_manager.update_dns_record_for_instance(instance_model, dns_names_to_ip)
+      dns_manager.flush_dns_cache
 
-      if instance && instance.state == "started"
-        agent_client(new_vm).run_script('pre-start', {})
-        agent_client(new_vm).start
-      end
+      cleaner = RenderedJobTemplatesCleaner.new(instance_model, App.instance.blobstores.blobstore, @logger)
+      InstanceUpdater::StateApplier.new(instance_plan_to_create, agent_client(instance_model.vm), cleaner).apply
     end
 
     private
 
-    def validate_spec(vm)
-      handler_error("Unable to look up VM apply spec") unless vm.apply_spec
+    def create_instance_plan(instance_model, vm_env)
+      vm_type = DeploymentPlan::VmType.new(instance_model.spec['vm_type'])
+      env = DeploymentPlan::Env.new(vm_env)
+      stemcell = DeploymentPlan::Stemcell.new(instance_model.spec['stemcell'])
+      stemcell.add_stemcell_model
+      availability_zone = DeploymentPlan::AvailabilityZone.new(instance_model.availability_zone, instance_model.cloud_properties_hash)
+
+      instance_from_model = DeploymentPlan::Instance.new(
+        instance_model.job,
+        instance_model.index,
+        instance_model.state,
+        vm_type,
+        stemcell,
+        env,
+        false,
+        instance_model.deployment,
+        instance_model.spec,
+        availability_zone,
+        @logger
+      )
+      instance_from_model.bind_existing_instance_model(instance_model)
+
+      DeploymentPlan::ResurrectionInstancePlan.new(
+        existing_instance: instance_model,
+        instance: instance_from_model,
+        desired_instance: DeploymentPlan::DesiredInstance.new,
+        recreate_deployment: true
+      )
+    end
 
-      spec = vm.apply_spec
+    def cloud
+      Bosh::Director::Config.cloud
+    end
 
-      unless spec.kind_of?(Hash)
-        handler_error("Invalid apply spec format")
-      end
+    def handler_error(message)
+      raise Bosh::Director::ProblemHandlerError, message
+    end
+
+    def instance_name(vm)
+      instance = vm.instance
+      return "Unknown VM" if instance.nil?
 
-      spec
+      job = instance.job || "unknown job"
+      index = instance.index || "unknown index"
+      "#{job}/#{index}"
     end
 
-    def validate_env(vm)
-      handler_error("Unable to look up VM environment") unless vm.env
+    def agent_client(vm, timeout = DEFAULT_AGENT_TIMEOUT, retries = 0)
+      options = {
+        :timeout => timeout,
+        :retry_methods => { :get_state => retries }
+      }
+      @clients ||= {}
+      @clients[vm.agent_id] ||= AgentClient.with_vm(vm, options)
+    end
 
-      env = vm.env
+    def agent_timeout_guard(vm, &block)
+      yield agent_client(vm)
+    rescue Bosh::Director::RpcTimeout
+      handler_error("VM `#{vm.cid}' is not responding")
+    end
 
-      unless env.kind_of?(Hash)
-        handler_error("Invalid VM environment format")
-      end
+    def vm_deleter
+      @vm_deleter ||= VmDeleter.new(cloud, @logger)
+    end
 
-      env
+    def vm_creator
+      disk_manager = DiskManager.new(cloud, @logger)
+      job_renderer = JobRenderer.create
+      @vm_creator ||= VmCreator.new(cloud, @logger, vm_deleter, disk_manager, job_renderer)
     end
 
-    def find_stemcell(stemcell_spec)
-      stemcell_name = stemcell_spec['name']
-      stemcell_version = stemcell_spec['version']
+    def validate_spec(spec)
+      handler_error('Unable to look up VM apply spec') unless spec
 
-      unless stemcell_name && stemcell_version
-        handler_error('Unknown stemcell name and/or version')
+      unless spec.kind_of?(Hash)
+        handler_error('Invalid apply spec format')
       end
+    end
 
-      stemcell = Models::Stemcell.find(:name => stemcell_name, :version => stemcell_version)
-
-      handler_error("Unable to find stemcell '#{stemcell_name} #{stemcell_version}'") unless stemcell
+    def validate_env(env)
+      handler_error('Unable to look up VM environment') unless env
 
-      stemcell
+      unless env.kind_of?(Hash)
+        handler_error('Invalid VM environment format')
+      end
     end
 
     def generate_agent_id
       SecureRandom.uuid
     end
-
   end
 end