bosh-director 1.5.0.pre.1113

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

@@ -0,0 +1,34 @@
+module Bosh::Director
+  module Api::ControllerHelpers
+    def task_timeout?(task)
+      # Some of the old task entries might not have the checkpoint_time
+      unless task.checkpoint_time
+        task.checkpoint_time = Time.now
+        task.save
+      end
+
+      # If no checkpoint update in 3 cycles --> timeout
+      (task.state == 'processing' || task.state == 'cancelling') &&
+        (Time.now - task.checkpoint_time > Config.task_checkpoint_interval * 3)
+    end
+
+    def protected!
+      unless authorized?
+        response['WWW-Authenticate'] = 'Basic realm="BOSH Director"'
+        throw(:halt, [401, "Not authorized\n"])
+      end
+    end
+
+    def authorized?
+      @auth ||=  Rack::Auth::Basic::Request.new(request.env)
+      @auth.provided? && @auth.basic? && @auth.credentials && authenticate(*@auth.credentials)
+    end
+
+    def convert_job_instance_hash(hash)
+      hash.reduce([]) do |jobs, kv|
+        job, indicies = kv
+        jobs + indicies.map { |index| [job, index] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Bosh::Director
+  module Api
+    class DeploymentLookup
+      def by_name(name)
+        deployment = Models::Deployment[name: name]
+        if deployment.nil?
+          raise DeploymentNotFound, "Deployment `#{name}' doesn't exist"
+        end
+        deployment
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+    class DeploymentManager
+      include ApiHelper
+
+      # Finds deployment by name
+      # @param [String] name
+      # @return [Models::Deployment] Deployment model
+      # @raise [DeploymentNotFound]
+      def find_by_name(name)
+        DeploymentLookup.new.by_name(name)
+      end
+
+      def create_deployment(user, deployment_manifest, options = {})
+        random_name = "deployment-#{SecureRandom.uuid}"
+        deployment_manifest_dir = Dir::tmpdir
+        deployment_manifest_file = File.join(deployment_manifest_dir, random_name)
+        unless check_available_disk_space(deployment_manifest_dir, deployment_manifest.size)
+          raise NotEnoughDiskSpace, "Uploading deployment manifest failed. " +
+            "Insufficient space on BOSH director in #{deployment_manifest_dir}"
+        end
+
+        write_file(deployment_manifest_file, deployment_manifest)
+
+        JobQueue.new.enqueue(user, Jobs::UpdateDeployment, 'create deployment', [deployment_manifest_file, options])
+      end
+
+      def delete_deployment(user, deployment, options = {})
+        JobQueue.new.enqueue(user, Jobs::DeleteDeployment, "delete deployment #{deployment.name}", [deployment.name, options])
+      end
+
+      def deployment_to_json(deployment)
+        result = {
+          "manifest" => deployment.manifest,
+        }
+
+        Yajl::Encoder.encode(result)
+      end
+
+      def deployment_vms_to_json(deployment)
+        vms = []
+        filters = {:deployment_id => deployment.id}
+        Models::Vm.eager(:instance).filter(filters).all.each do |vm|
+          instance = vm.instance
+
+          vms << {
+            "agent_id" => vm.agent_id,
+            "cid" => vm.cid,
+            "job" => instance ? instance.job : nil,
+            "index" => instance ? instance.index : nil
+          }
+        end
+
+        Yajl::Encoder.encode(vms)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director::Api
+  module Http
+    OK                    = 200
+    CREATED               = 201
+    NO_CONTENT            = 204
+
+    BAD_REQUEST           = 400
+    UNAUTHORIZED          = 401
+    FORBIDDEN             = 403
+    NOT_FOUND             = 404
+
+    INTERNAL_SERVER_ERROR = 500
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'bosh/director/api/deployment_lookup'
+
+module Bosh::Director
+  module Api
+    class InstanceLookup
+      def by_id(instance_id)
+        instance = Models::Instance[instance_id]
+        if instance.nil?
+          raise InstanceNotFound, "Instance #{instance_id} doesn't exist"
+        end
+        instance
+      end
+
+      def by_attributes(deployment_name, job_name, job_index)
+        deployment = DeploymentLookup.new.by_name(deployment_name)
+
+        filter = {
+          deployment_id: deployment.id,
+          job: job_name,
+          index: job_index
+        }
+
+        instance = Models::Instance.find(filter)
+        if instance.nil?
+          raise InstanceNotFound,
+                "`#{deployment_name}/#{job_name}/#{job_index}' doesn't exist"
+        end
+        instance
+      end
+
+      def by_filter(filter)
+        instances = Models::Instance.filter(filter).all
+        if instances.empty?
+          raise InstanceNotFound, "No instances matched #{filter.inspect}"
+        end
+        instances
+      end
+
+      def find_all
+        Models::Instance.all
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+    class InstanceManager
+      # @param [Integer] instance_id Instance id
+      # @return [Models::Instance] Instance
+      # @raise [InstanceNotFound]
+      def find_instance(instance_id)
+        InstanceLookup.new.by_id(instance_id)
+      end
+
+      # @param [String] deployment_name Deployment name
+      # @param [String] job Job name
+      # @param [String] index Job index
+      # @return [Models::Instance]
+      def find_by_name(deployment_name, job, index)
+        InstanceLookup.new.by_attributes(deployment_name, job, index)
+      end
+
+      # @param [Hash] filter Sequel-style DB record filter
+      # @return [Array] List of instances that matched the filter
+      # @raise [InstanceNotFound]
+      def filter_by(filter)
+        InstanceLookup.new.by_filter(filter)
+      end
+
+      # @param [Models::Instance] instance Instance
+      # @return [AgentClient] Agent client to talk to instance
+      def agent_client_for(instance)
+        vm = instance.vm
+        if vm.nil?
+          raise InstanceVmMissing,
+                "`#{instance.job}/#{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.new(vm.agent_id)
+      end
+
+      def fetch_logs(user, deployment_name, job, index, options = {})
+        if deployment_name.nil? || job.nil? || index.nil?
+          raise DirectorError,
+                "deployment, job and index parameters are required"
+        end
+
+        instance = find_by_name(deployment_name, job, index)
+
+        JobQueue.new.enqueue(user, Jobs::FetchLogs, 'fetch logs', [instance.id, options])
+      end
+
+      def ssh(user, options)
+        description = "ssh: #{options['command']}:#{options['target']}"
+        deployment = DeploymentLookup.new.by_name(options['deployment_name'])
+
+        JobQueue.new.enqueue(user, Jobs::Ssh, description, [deployment.id, options])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+    class ProblemManager
+
+      def initialize(deployment_manager = DeploymentManager.new)
+        @deployment_manager = deployment_manager
+      end
+
+      def perform_scan(user, deployment_name)
+        deployment = @deployment_manager.find_by_name(deployment_name)
+
+        JobQueue.new.enqueue(user, Jobs::CloudCheck::Scan, 'scan cloud', [deployment.name])
+      end
+
+      def get_problems(deployment_name)
+        deployment = @deployment_manager.find_by_name(deployment_name)
+
+        filters = {
+          :deployment_id => deployment.id,
+          :state => 'open'
+        }
+
+        Models::DeploymentProblem.filter(filters).order(:created_at).all
+      end
+
+      def apply_resolutions(user, deployment_name, resolutions)
+        deployment = @deployment_manager.find_by_name(deployment_name)
+        JobQueue.new.enqueue(user, Jobs::CloudCheck::ApplyResolutions, 'apply resolutions', [deployment.name, resolutions])
+      end
+
+      def scan_and_fix(user, deployment_name, jobs)
+        deployment = @deployment_manager.find_by_name(deployment_name)
+
+        JobQueue.new.enqueue(user, Jobs::CloudCheck::ScanAndFix, 'scan and fix', [deployment.name, jobs, Bosh::Director::Config.fix_stateful_nodes])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+    class PropertyManager
+
+      def initialize
+        @deployment_manager = DeploymentManager.new
+      end
+
+      def create_property(deployment_name, property_name, value)
+        property = Models::DeploymentProperty.new
+        property.deployment = find_deployment(deployment_name)
+        property.name = property_name
+        property.value = value
+        property.save
+
+      rescue Sequel::ValidationFailed => e
+        if e.errors[[:name, :deployment_id]].include?(:unique)
+          raise PropertyAlreadyExists,
+                "Property `#{property_name}' already exists " +
+                "for deployment `#{deployment_name}'"
+        end
+        invalid_property(e.errors)
+      end
+
+      def update_property(deployment_name, property_name, value)
+        property = get_property(deployment_name, property_name)
+        property.value = value
+        property.save
+
+      rescue Sequel::ValidationFailed => e
+        invalid_property(e.errors)
+      end
+
+      def delete_property(deployment_name, property_name)
+        get_property(deployment_name, property_name).destroy
+      end
+
+      def get_property(deployment_name, property_name)
+        deployment = find_deployment(deployment_name)
+        filters = {:deployment_id => deployment.id, :name => property_name}
+        property = Models::DeploymentProperty.find(filters)
+        if property.nil?
+          raise PropertyNotFound,
+                "Property `#{property_name}' not found " +
+                "for deployment `#{deployment_name}'"
+        end
+        property
+      end
+
+      def get_properties(deployment_name)
+        filters = {:deployment_id => find_deployment(deployment_name).id}
+        Models::DeploymentProperty.filter(filters).all
+      end
+
+      private
+
+      def invalid_property(errors)
+        raise PropertyInvalid,
+              "Property is invalid: #{errors.full_messages.sort.join(", ")}"
+      end
+
+      def find_deployment(name)
+        @deployment_manager.find_by_name(name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+    class ReleaseManager
+      include ApiHelper
+
+      RELEASE_TGZ = "release.tgz"
+
+      # Finds release by name
+      # @param [String] name Release name
+      # @return [Models::Release]
+      # @raise [ReleaseNotFound]
+      def find_by_name(name)
+        release = Models::Release[:name => name]
+        if release.nil?
+          raise ReleaseNotFound, "Release `#{name}' doesn't exist"
+        end
+        release
+      end
+
+      # @param [Models::Release] release Release model
+      # @param [String] version Release version
+      # @return [Models::ReleaseVersion] Release version model
+      # @raise [ReleaseVersionNotFound]
+      def find_version(release, version)
+        dataset = release.versions_dataset
+        release_version = dataset.filter(:version => version).first
+        if release_version.nil?
+          raise ReleaseVersionNotFound,
+                "Release version `#{release.name}/#{version}' doesn't exist"
+        end
+
+        release_version
+      end
+
+      def create_release(user, release_bundle, options = {})
+        release_dir = Dir.mktmpdir("release")
+
+        if options['remote']
+          options['location'] = release_bundle
+        else
+          unless check_available_disk_space(release_dir, release_bundle.size)
+            raise NotEnoughDiskSpace, "Uploading release archive failed. " +
+              "Insufficient space on BOSH director in #{release_dir}"
+          end
+  
+          write_file(File.join(release_dir, RELEASE_TGZ), release_bundle)
+        end
+
+        JobQueue.new.enqueue(user, Jobs::UpdateRelease, 'create release', [release_dir, options])
+      end
+
+      def delete_release(user, release, options = {})
+        JobQueue.new.enqueue(user, Jobs::DeleteRelease, "delete release: #{release.name}", [release.name, options])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+    class ResourceManager
+
+      def initialize(blobstore_client=App.instance.blobstores.blobstore)
+        @logger = Config.logger
+        @blobstore_client = blobstore_client
+      end
+
+      # Retrieves the resource `id` from the blobstore and stores it
+      # locally, and returns the path to the file
+      #
+      # @param [String] id
+      # @return [String] path to the contents of the blobstore id
+      def get_resource_path(id)
+        blobstore_resource(id) do |blobstore|
+          random_name = "resource-#{SecureRandom.uuid}"
+          path = File.join(Dir.tmpdir, random_name)
+
+          File.open(path, "w") do |f|
+            blobstore.get(id, f)
+          end
+
+          path
+        end
+      end
+
+      # Retrieves the resource `id` from the blobstore and returns the
+      # contents of it.
+      # @param [String] id
+      # @return [String] contents of the blobstore id
+      def get_resource(id)
+        @logger.debug("Downloading #{id} from blobstore...")
+
+        blob = nil
+        blobstore_resource(id) do |blobstore|
+          blob = blobstore.get(id)
+        end
+
+        @logger.debug("Downloaded #{id} from blobstore")
+        blob
+      end
+
+      # Deletes the resource `id` from the blobstore
+      # @param [String] id
+      def delete_resource(id)
+        @logger.debug("Deleting #{id} from blobstore...")
+
+        blobstore_resource(id) do |blobstore|
+          blobstore.delete(id)
+        end
+
+        @logger.debug("Deleted #{id} from blobstore")
+      end
+
+      private
+
+      def blobstore_resource(id)
+        yield @blobstore_client
+      rescue Bosh::Blobstore::NotFound
+        raise ResourceNotFound, "Resource `#{id}' not found in the blobstore"
+      rescue Bosh::Blobstore::BlobstoreError => e
+        raise ResourceError, "Blobstore error accessing resource `#{id}': #{e}"
+      end
+    end
+  end
+end