bosh-director 1.5.0.pre.1113

data/db/migrations/director/20130530164918_add_paused_flag_to_instance.rb

@@ -0,0 +1,14 @@
+Sequel.migration do
+  up do
+    alter_table :instances do
+      add_column :resurrection_paused, TrueClass
+      set_column_default :resurrection_paused, false
+    end
+  end
+
+  down do
+    alter_table :instances do
+      drop_column :resurrection_paused
+    end
+  end
+end

data/db/migrations/director/20130531172604_add_director_attributes.rb

@@ -0,0 +1,13 @@
+Sequel.migration do
+  up do
+    create_table(:director_attributes) do
+      primary_key :uuid
+      String :uuid, unique: true, null: false
+    end
+  end
+
+  down do
+    drop_table(:director_attributes)
+  end
+
+end

data/db/migrations/dns/20120123234908_initial.rb

@@ -0,0 +1,27 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+Sequel.migration do
+  change do
+    create_table :domains do
+      primary_key :id
+      String :name, :size => 255, :null => false, :unique => true
+      String :master, :size => 128, :null => true, :default => nil
+      Integer :last_check, :null => true, :default => nil
+      String :type, :size => 6, :null => false
+      Integer :notified_serial, :null => true, :default => nil
+      String :account, :size=> 40, :null => true, :default => nil
+    end
+
+    create_table :records do
+      primary_key :id
+      String :name, :size => 255, :null => true, :default => nil, :index => true
+      String :type, :size => 10, :null => true, :default => nil
+      String :content, :size => 4098, :null => true, :default => nil
+      Integer :ttl, :null => true, :default => nil
+      Integer :prio, :null => true, :default => nil
+      Integer :change_date, :null => true, :default => nil
+      foreign_key :domain_id, :domains, :on_delete => :cascade, :null => true, :default => nil, :index => true
+      index [:name, :type]
+    end
+  end
+end

data/lib/bosh/director.rb

@@ -0,0 +1,133 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh
+  module Director
+  end
+end
+
+require 'digest/sha1'
+require 'erb'
+require 'fileutils'
+require 'forwardable'
+require 'logger'
+require 'monitor'
+require 'optparse'
+require 'ostruct'
+require 'pathname'
+require 'pp'
+require 'thread'
+require 'tmpdir'
+require 'yaml'
+require 'time'
+require 'zlib'
+
+require 'common/runs_commands'
+require 'common/exec'
+require 'common/properties'
+
+require 'bcrypt'
+require 'blobstore_client'
+require 'eventmachine'
+require 'netaddr'
+require 'resque'
+require 'sequel'
+require 'sinatra/base'
+require 'securerandom'
+require 'yajl'
+require 'nats/client'
+require 'securerandom'
+
+require 'common/thread_formatter'
+require 'bosh/core/encryption_handler'
+require 'bosh/director/api'
+require 'bosh/director/dns_helper'
+require 'bosh/director/errors'
+require 'bosh/director/ext'
+require 'bosh/director/ip_util'
+require 'bosh/director/lock_helper'
+require 'bosh/director/validation_helper'
+require 'bosh/director/download_helper'
+
+require 'bosh/director/version'
+require 'bosh/director/next_rebase_version'
+require 'bosh/director/config'
+require 'bosh/director/event_log'
+require 'bosh/director/task_result_file'
+require 'bosh/director/blob_util'
+
+require 'bosh/director/client'
+require 'bosh/director/agent_client'
+require 'cloud'
+require 'bosh/director/compile_task'
+require 'bosh/director/configuration_hasher'
+require 'bosh/director/cycle_helper'
+require 'bosh/director/encryption_helper'
+require 'bosh/director/vm_creator'
+require 'bosh/director/vm_metadata_updater'
+require 'bosh/director/vm_data'
+require 'bosh/director/vm_reuser'
+require 'bosh/director/deployment_plan'
+require 'bosh/director/deployment_plan/assembler'
+require 'bosh/director/duration'
+require 'bosh/director/hash_string_vals'
+require 'bosh/director/instance_deleter'
+require 'bosh/director/instance_updater'
+require 'bosh/director/job_runner'
+require 'bosh/director/job_updater'
+require 'bosh/director/job_queue'
+require 'bosh/director/tar_gzipper'
+require 'bosh/director/lock'
+require 'bosh/director/nats_rpc'
+require 'bosh/director/network_reservation'
+require 'bosh/director/package_compiler'
+require 'bosh/director/problem_scanner'
+require 'bosh/director/problem_resolver'
+require 'bosh/director/resource_pool_updater'
+require 'bosh/director/sequel'
+require 'common/thread_pool'
+
+require 'bosh/director/cloudcheck_helper'
+require 'bosh/director/problem_handlers/base'
+require 'bosh/director/problem_handlers/invalid_problem'
+require 'bosh/director/problem_handlers/inactive_disk'
+require 'bosh/director/problem_handlers/out_of_sync_vm'
+require 'bosh/director/problem_handlers/unresponsive_agent'
+require 'bosh/director/problem_handlers/unbound_instance_vm'
+require 'bosh/director/problem_handlers/mount_info_mismatch'
+require 'bosh/director/problem_handlers/missing_vm'
+
+require 'bosh/director/jobs/base_job'
+require 'bosh/director/jobs/backup'
+require 'bosh/director/jobs/scheduled_backup'
+require 'bosh/director/jobs/create_snapshot'
+require 'bosh/director/jobs/snapshot_deployment'
+require 'bosh/director/jobs/snapshot_deployments'
+require 'bosh/director/jobs/snapshot_self'
+require 'bosh/director/jobs/delete_deployment'
+require 'bosh/director/jobs/delete_deployment_snapshots'
+require 'bosh/director/jobs/delete_release'
+require 'bosh/director/jobs/delete_snapshots'
+require 'bosh/director/jobs/delete_stemcell'
+require 'bosh/director/jobs/update_deployment'
+require 'bosh/director/jobs/update_release'
+require 'bosh/director/jobs/update_stemcell'
+require 'bosh/director/jobs/fetch_logs'
+require 'bosh/director/jobs/vm_state'
+require 'bosh/director/jobs/cloud_check/scan'
+require 'bosh/director/jobs/cloud_check/scan_and_fix'
+require 'bosh/director/jobs/cloud_check/apply_resolutions'
+require 'bosh/director/jobs/ssh'
+
+require 'bosh/director/models/helpers/model_helper'
+
+require 'bosh/director/db_backup'
+require 'bosh/director/blobstores'
+require 'bosh/director/app'
+
+module Bosh::Director
+  autoload :Models, 'bosh/director/models' # Defining model classes relies on a database connection
+end
+
+require 'bosh/director/thread_pool'
+require 'bosh/director/api/controller_helpers'
+require 'bosh/director/api/controller'

data/lib/bosh/director/agent_client.rb

@@ -0,0 +1,78 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  class AgentClient < Client
+
+    DEFAULT_POLL_INTERVAL = 1.0
+
+    def initialize(id, options = {})
+      # Retry 'get_state' and 'get_task' in case of timeout errors
+      defaults = {
+        :retry_methods => { :get_state => 2, :get_task => 2}
+      }
+
+      credentials = Bosh::Director::Models::Vm.find(:agent_id => id).credentials
+      if credentials
+        defaults.merge!({
+          :credentials => credentials
+        })
+      end
+
+      super("agent", id, defaults.merge(options))
+    end
+
+    # This converts the old agent response format to the new.  This can be taken
+    # out once the agents never reply with the old message format.
+    # The old message format is just to pass the return object as JSON. That
+    # means it could be any type -- array, hash, string, int, etc.
+    # The new format is:
+    # {"state"=>"task_state", "value"=><task_return_object>,
+    #  "agent_task_id"=>123}
+    # This is a class method to make testing easier.
+    # @param [Object] msg The agent message to convert to the new format.
+    # @return [Hash] The message in the new message format.
+    def self.convert_old_message_to_new(msg)
+      if msg && msg.is_a?(Hash)
+        if !msg.has_key?("value")
+          # There's no value but there is state and agent_task_id.
+          # Just leave it.
+          if msg.has_key?("state") && msg.has_key?("agent_task_id")
+            return msg
+          end
+          # There's no value and either one or both of state/agent_task_id don't
+          # exist.  Assume that the whole message response was meant to be the
+          # value.
+          return {"value" => msg,
+                  "state" => msg["state"] || "done",
+                  "agent_task_id" => msg["agent_task_id"] || nil}
+        elsif !msg.has_key?("state")
+          # The message has a value section but no "state".  Mark state as
+          # done.
+          return {"value" => msg["value"],
+                  "state" => "done",
+                  "agent_task_id" => msg["agent_task_id"] || nil}
+        else
+          # The message was good from the start!
+          return msg
+        end
+      end
+      # If the message was anything other than a hash (float, int, string,
+      # array, etc.) then we want to just make that be the "value".
+      {"state" => "done", "value" => msg, "agent_task_id" => nil}
+    end
+
+    [:apply, :compile_package, :drain, :fetch_logs, :migrate_disk, :mount_disk,
+     :stop, :unmount_disk].each do |method|
+      define_method (method) do |*args|
+        task = AgentClient.convert_old_message_to_new(super(*args))
+        while task["state"] == "running"
+          sleep(DEFAULT_POLL_INTERVAL)
+          task = AgentClient.convert_old_message_to_new(
+              get_task(task["agent_task_id"]))
+        end
+        task["value"]
+      end
+    end
+
+  end
+end

data/lib/bosh/director/api.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+  end
+end
+
+require 'bosh/director/api/http_constants'
+
+require 'bosh/director/api/api_helper'
+require 'bosh/director/api/task_helper'
+
+require 'bosh/director/api/backup_manager'
+require 'bosh/director/api/deployment_manager'
+require 'bosh/director/api/instance_manager'
+require 'bosh/director/api/problem_manager'
+require 'bosh/director/api/property_manager'
+require 'bosh/director/api/release_manager'
+require 'bosh/director/api/resource_manager'
+require 'bosh/director/api/snapshot_manager'
+require 'bosh/director/api/stemcell_manager'
+require 'bosh/director/api/task_manager'
+require 'bosh/director/api/user_manager'
+require 'bosh/director/api/vm_state_manager'
+require 'bosh/director/api/backup_manager'
+require 'bosh/director/api/resurrector_manager'
+
+require 'bosh/director/api/instance_lookup'
+require 'bosh/director/api/deployment_lookup'

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

@@ -0,0 +1,81 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+require 'sys/filesystem'
+include Sys
+
+module Bosh::Director
+  module Api
+    module ApiHelper
+      READ_CHUNK_SIZE = 16384
+
+      class DisposableFile < ::Rack::File
+        def close
+          FileUtils.rm_rf(self.path) if File.exists?(self.path)
+        end
+      end
+
+      # Adapted from Sinatra::Base#send_file. There is one difference:
+      # it uses DisposableFile instead of Rack::File.
+      # DisposableFile gets removed on "close" call. This is primarily
+      # meant to serve temporary files fetched from the blobstore.
+      # We CANNOT use a Sinatra after filter, as the filter is called before
+      # the contents of the file is sent to the client.
+      def send_disposable_file(path, opts = {})
+        if opts[:type] || !response['Content-Type']
+          content_type opts[:type] || File.extname(path), :default => 'application/octet-stream'
+        end
+
+        disposition = opts[:disposition]
+        filename    = opts[:filename]
+        disposition = 'attachment' if disposition.nil? && filename
+        filename    = path         if filename.nil?
+        attachment(filename, disposition) if disposition
+
+        last_modified opts[:last_modified] if opts[:last_modified]
+
+        file      = DisposableFile.new nil
+        file.path = path
+        result    = file.serving env
+        result[1].each { |k,v| headers[k] ||= v }
+        headers['Content-Length'] = result[1]['Content-Length']
+        halt opts[:status] || result[0], result[2]
+      rescue Errno::ENOENT
+        not_found
+      end
+
+      def json_encode(payload)
+        Yajl::Encoder.encode(payload)
+      end
+
+      def json_decode(payload)
+        Yajl::Parser.parse(payload)
+      end
+
+      def start_task
+        task = yield
+        unless task.kind_of?(Models::Task)
+          raise "Block didn't return Task object"
+        end
+        redirect "/tasks/#{task.id}"
+      end
+
+      def check_available_disk_space(dir, size)
+        begin
+          stat = Sys::Filesystem.stat(dir)
+          available_space = stat.block_size * stat.blocks_available
+          available_space > size ? true : false
+        rescue
+          false
+        end
+      end
+
+      def write_file(path, stream, chunk_size = READ_CHUNK_SIZE)
+        buffer = ""
+        File.open(path, "w") do |file|
+          file.write(buffer) until stream.read(chunk_size, buffer).nil?
+        end
+      rescue SystemCallError => e
+        raise SystemError, e.message
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Bosh::Director
+  module Api
+    class BackupManager
+      attr_accessor :destination_path
+
+      def initialize
+        @destination_path = '/var/vcap/store/director/backup.tgz'
+      end
+
+      def create_backup(user)
+        JobQueue.new.enqueue(user, Jobs::Backup, 'bosh backup', [destination_path])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,639 @@
+module Bosh::Director
+  module Api
+    class Controller < Sinatra::Base
+      PUBLIC_URLS = %w(/info)
+
+      include ApiHelper
+      include Http
+      include DnsHelper
+
+      def initialize
+        super
+        @deployment_manager = DeploymentManager.new
+        @backup_manager = BackupManager.new
+        @instance_manager = InstanceManager.new
+        @resurrector_manager = ResurrectorManager.new
+        @problem_manager = ProblemManager.new
+        @property_manager = PropertyManager.new
+        @resource_manager = ResourceManager.new
+        @release_manager = ReleaseManager.new
+        @snapshot_manager = SnapshotManager.new
+        @stemcell_manager = StemcellManager.new
+        @task_manager = TaskManager.new
+        @user_manager = UserManager.new
+        @vm_state_manager = VmStateManager.new
+        @logger = Config.logger
+      end
+
+      mime_type :tgz, 'application/x-compressed'
+
+      def self.consumes(*types)
+        types = Set.new(types)
+        types.map! { |t| mime_type(t) }
+
+        condition do
+          types.include?(request.content_type)
+        end
+      end
+
+      def authenticate(user, password)
+        if @user_manager.authenticate(user, password)
+          @user = user
+          true
+        else
+          false
+        end
+      end
+
+      helpers ControllerHelpers
+
+      before do
+        auth_provided = %w(HTTP_AUTHORIZATION X-HTTP_AUTHORIZATION X_HTTP_AUTHORIZATION).detect do |key|
+          request.env.has_key?(key)
+        end
+
+        protected! if auth_provided || !PUBLIC_URLS.include?(request.path_info)
+      end
+
+      after { headers('Date' => Time.now.rfc822) } # As thin doesn't inject date
+
+      configure do
+        set(:show_exceptions, false)
+        set(:raise_errors, false)
+        set(:dump_errors, false)
+      end
+
+      error do
+        exception = request.env['sinatra.error']
+        if exception.kind_of?(DirectorError)
+          @logger.debug('Request failed, ' +
+                          "response code: #{exception.response_code}, " +
+                          "error code: #{exception.error_code}, " +
+                          "error message: #{exception.message}")
+          status(exception.response_code)
+          error_payload = {
+            'code' => exception.error_code,
+            'description' => exception.message
+          }
+          json_encode(error_payload)
+        else
+          msg = ["#{exception.class} - #{exception.message}:"]
+          msg.concat(exception.backtrace)
+          @logger.error(msg.join("\n"))
+          status(500)
+        end
+      end
+
+      post '/users', :consumes => [:json] do
+        user = @user_manager.get_user_from_request(request)
+        @user_manager.create_user(user)
+        status(204)
+        nil
+      end
+
+      put '/users/:username', :consumes => [:json] do
+        user = @user_manager.get_user_from_request(request)
+        if user.username != params[:username]
+          raise UserImmutableUsername, 'The username is immutable'
+        end
+        @user_manager.update_user(user)
+        status(204)
+        nil
+      end
+
+      delete '/users/:username' do
+        @user_manager.delete_user(params[:username])
+        status(204)
+        nil
+      end
+
+      post '/packages/matches', :consumes => :yaml do
+        manifest = Psych.load(request.body)
+        unless manifest.is_a?(Hash) && manifest['packages'].is_a?(Array)
+          raise BadManifest, "Manifest doesn't have a usable packages section"
+        end
+
+        fp_list = []
+        sha1_list = []
+
+        manifest['packages'].each do |package|
+          fp_list << package['fingerprint'] if package['fingerprint']
+          sha1_list << package['sha1'] if package['sha1']
+        end
+
+        filter = {:fingerprint => fp_list, :sha1 => sha1_list}.sql_or
+
+        result = Models::Package.where(filter).all.map { |package|
+          [package.sha1, package.fingerprint]
+        }.flatten.compact.uniq
+
+        json_encode(result)
+      end
+
+      post '/releases', :consumes => :tgz do
+        options = {}
+        options['remote'] = false
+        options['rebase'] = true if params['rebase'] == 'true'
+
+        task = @release_manager.create_release(@user, request.body, options)
+        redirect "/tasks/#{task.id}"
+      end
+
+      post '/releases', :consumes => :json do
+        options = {}
+        options['remote'] = true
+        options['rebase'] = true if params['rebase'] == 'true'
+        payload = json_decode(request.body)
+
+        task = @release_manager.create_release(@user, payload['location'], options)
+        redirect "/tasks/#{task.id}"
+      end
+
+      get '/releases' do
+        releases = Models::Release.order_by(:name.asc).map do |release|
+          release_versions = release.versions_dataset.order_by(:version.asc).map do |rv|
+            Hash['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
+
+          Hash['name', release.name,
+               'release_versions', release_versions]
+        end
+
+        json_encode(releases)
+      end
+
+      get '/releases/:name' do
+        name = params[:name].to_s.strip
+        release = @release_manager.find_by_name(name)
+
+        result = { }
+
+        result['packages'] = release.packages.map do |package|
+          {
+            'name' => package.name,
+            'sha1' => package.sha1,
+            'version' => package.version.to_s,
+            'dependencies' => package.dependency_set.to_a
+          }
+        end
+
+        result['jobs'] = release.templates.map do |template|
+          {
+            'name' => template.name,
+            'sha1' => template.sha1,
+            'version' => template.version.to_s,
+            'packages' => template.package_names
+          }
+        end
+
+        result['versions'] = release.versions.map do |rv|
+          rv.version.to_s
+        end
+
+        content_type(:json)
+        json_encode(result)
+      end
+
+      delete '/releases/:name' do
+        release = @release_manager.find_by_name(params[:name])
+
+        options = {}
+        options['force'] = true if params['force'] == 'true'
+        options['version'] = params['version']
+
+        task = @release_manager.delete_release(@user, release, options)
+        redirect "/tasks/#{task.id}"
+      end
+
+      post '/stemcells', :consumes => :tgz do
+        task = @stemcell_manager.create_stemcell(@user, request.body, :remote => false)
+        redirect "/tasks/#{task.id}"
+      end
+
+      post '/stemcells', :consumes => :json do
+        payload = json_decode(request.body)
+        task = @stemcell_manager.create_stemcell(@user, payload['location'], :remote => true)
+        redirect "/tasks/#{task.id}"
+      end
+
+      get '/stemcells' do
+        stemcells = Models::Stemcell.order_by(:name.asc).map do |stemcell|
+          {
+            'name' => stemcell.name,
+            'version' => stemcell.version,
+            'cid' => stemcell.cid
+          }
+        end
+        json_encode(stemcells)
+      end
+
+      delete '/stemcells/:name/:version' do
+        name, version = params[:name], params[:version]
+        options = {}
+        options['force'] = true if params['force'] == 'true'
+        stemcell = @stemcell_manager.find_by_name_and_version(name, version)
+        task = @stemcell_manager.delete_stemcell(@user, stemcell, options)
+        redirect "/tasks/#{task.id}"
+      end
+
+      post '/deployments', :consumes => :yaml do
+        options = {}
+        options['recreate'] = true if params['recreate'] == 'true'
+
+        task = @deployment_manager.create_deployment(@user, request.body, options)
+        redirect "/tasks/#{task.id}"
+      end
+
+      get '/deployments/:deployment/jobs/:job/:index' do
+        instance = @instance_manager.find_by_name(params[:deployment], params[:job], params[:index])
+
+        response = {
+          deployment: params[:deployment],
+          job: instance.job,
+          index: instance.index,
+          state: instance.state,
+          disks: instance.persistent_disks.map {|d| d.disk_cid}
+        }
+
+        json_encode(response)
+      end
+
+      # PUT /deployments/foo/jobs/dea?new_name=dea_new
+      put '/deployments/:deployment/jobs/:job', :consumes => :yaml do
+        if params['state']
+          options = {
+            'job_states' => {
+              params[:job] => {
+                'state' => params['state']
+              }
+            }
+          }
+        else
+          unless params['new_name']
+            raise DirectorError, "Missing operation on job `#{params[:job]}'"
+          end
+          options = {
+            'job_rename' => {
+              'old_name' => params[:job],
+              'new_name' => params['new_name']
+            }
+          }
+          options['job_rename']['force'] = true if params['force'] == 'true'
+        end
+
+        # we get the deployment here even though it isn't used here, to make sure
+        # the call returns a 404 if the deployment doesn't exist
+        @deployment_manager.find_by_name(params[:deployment])
+        task = @deployment_manager.create_deployment(@user, request.body, options)
+        redirect "/tasks/#{task.id}"
+      end
+
+      # PUT /deployments/foo/jobs/dea/2?state={started,stopped,detached,restart,recreate}
+      put '/deployments/:deployment/jobs/:job/:index', :consumes => :yaml do
+        begin
+          index = Integer(params[:index])
+        rescue ArgumentError
+          raise InstanceInvalidIndex, "Invalid instance index `#{params[:index]}'"
+        end
+
+        options = {
+          'job_states' => {
+            params[:job] => {
+              'instance_states' => {
+                index => params['state']
+              }
+            }
+          }
+        }
+
+        deployment = @deployment_manager.find_by_name(params[:deployment])
+        manifest = request.content_length.nil? ? StringIO.new(deployment.manifest) : request.body
+        task = @deployment_manager.create_deployment(@user, manifest, options)
+        redirect "/tasks/#{task.id}"
+      end
+
+      # GET /deployments/foo/jobs/dea/2/logs
+      get '/deployments/:deployment/jobs/:job/:index/logs' do
+        deployment = params[:deployment]
+        job = params[:job]
+        index = params[:index]
+
+        options = {
+          'type' => params[:type].to_s.strip,
+          'filters' => params[:filters].to_s.strip.split(/[\s\,]+/)
+        }
+
+        task = @instance_manager.fetch_logs(@user, deployment, job, index, options)
+        redirect "/tasks/#{task.id}"
+      end
+
+      get '/deployments/:deployment/snapshots' do
+        deployment = @deployment_manager.find_by_name(params[:deployment])
+        json_encode(@snapshot_manager.snapshots(deployment))
+      end
+
+      get '/deployments/:deployment/jobs/:job/:index/snapshots' do
+        deployment = @deployment_manager.find_by_name(params[:deployment])
+        json_encode(@snapshot_manager.snapshots(deployment, params[:job], params[:index]))
+      end
+
+      post '/deployments/:deployment/snapshots' do
+        deployment = @deployment_manager.find_by_name(params[:deployment])
+        # until we can tell the agent to flush and wait, all snapshots are considered dirty
+        options = {clean: false}
+
+        task = @snapshot_manager.create_deployment_snapshot_task(@user, deployment, options)
+        redirect "/tasks/#{task.id}"
+      end
+
+      put '/deployments/:deployment/jobs/:job/:index/resurrection', consumes: :json do
+        payload = json_decode(request.body)
+
+        @resurrector_manager.set_pause_for_instance(params[:deployment], params[:job], params[:index], payload['resurrection_paused'])
+      end
+
+      post '/deployments/:deployment/jobs/:job/:index/snapshots' do
+        instance = @instance_manager.find_by_name(params[:deployment], params[:job], params[:index])
+        # until we can tell the agent to flush and wait, all snapshots are considered dirty
+        options = {clean: false}
+
+        task = @snapshot_manager.create_snapshot_task(@user, instance, options)
+        redirect "/tasks/#{task.id}"
+      end
+
+      delete '/deployments/:deployment/snapshots' do
+        deployment = @deployment_manager.find_by_name(params[:deployment])
+
+        task = @snapshot_manager.delete_deployment_snapshots_task(@user, deployment)
+        redirect "/tasks/#{task.id}"
+      end
+
+      delete '/deployments/:deployment/snapshots/:cid' do
+        deployment = @deployment_manager.find_by_name(params[:deployment])
+        snapshot = @snapshot_manager.find_by_cid(deployment, params[:cid])
+
+        task = @snapshot_manager.delete_snapshots_task(@user, [params[:cid]])
+        redirect "/tasks/#{task.id}"
+      end
+
+      get '/deployments' do
+        deployments = Models::Deployment.order_by(:name.asc).map { |deployment|
+          name = deployment.name
+
+          releases = deployment.release_versions.map { |rv|
+            Hash['name', rv.release.name, 'version', rv.version.to_s]
+          }
+
+          stemcells = deployment.stemcells.map { |sc|
+            Hash['name', sc.name, 'version', sc.version]
+          }
+
+          Hash['name', name, 'releases', releases, 'stemcells', stemcells]
+        }
+
+        json_encode(deployments)
+      end
+
+      get '/deployments/:name' do
+        deployment = @deployment_manager.find_by_name(params[:name])
+        @deployment_manager.deployment_to_json(deployment)
+      end
+
+      get '/deployments/:name/vms' do
+        deployment = @deployment_manager.find_by_name(params[:name])
+
+        format = params[:format]
+        if format == 'full'
+          task = @vm_state_manager.fetch_vm_state(@user, deployment, format)
+          redirect "/tasks/#{task.id}"
+        else
+          @deployment_manager.deployment_vms_to_json(deployment)
+        end
+      end
+
+      delete '/deployments/:name' do
+        deployment = @deployment_manager.find_by_name(params[:name])
+
+        options = {}
+        options['force'] = true if params['force'] == 'true'
+        options['keep_snapshots'] = true if params['keep_snapshots'] == 'true'
+        task = @deployment_manager.delete_deployment(@user, deployment, options)
+        redirect "/tasks/#{task.id}"
+      end
+
+      # Property management
+      get '/deployments/:deployment/properties' do
+        properties = @property_manager.get_properties(params[:deployment]).map do |property|
+          { 'name' => property.name, 'value' => property.value }
+        end
+        json_encode(properties)
+      end
+
+      get '/deployments/:deployment/properties/:property' do
+        property = @property_manager.get_property(params[:deployment], params[:property])
+        json_encode('value' => property.value)
+      end
+
+      post '/deployments/:deployment/properties', :consumes => [:json] do
+        payload = json_decode(request.body)
+        @property_manager.create_property(params[:deployment], payload['name'], payload['value'])
+        status(204)
+      end
+
+      post '/deployments/:deployment/ssh', :consumes => [:json] do
+        payload = json_decode(request.body)
+        task = @instance_manager.ssh(@user, payload)
+        redirect "/tasks/#{task.id}"
+      end
+
+      put '/deployments/:deployment/properties/:property', :consumes => [:json] do
+        payload = json_decode(request.body)
+        @property_manager.update_property(params[:deployment], params[:property], payload['value'])
+        status(204)
+      end
+
+      delete '/deployments/:deployment/properties/:property' do
+        @property_manager.delete_property(params[:deployment], params[:property])
+        status(204)
+      end
+
+      # Cloud check
+
+      # Initiate deployment scan
+      post '/deployments/:deployment/scans' do
+        start_task { @problem_manager.perform_scan(@user, params[:deployment]) }
+      end
+
+      # Get the list of problems for a particular deployment
+      get '/deployments/:deployment/problems' do
+        problems = @problem_manager.get_problems(params[:deployment]).map do |problem|
+          {
+            'id' => problem.id,
+            'type' => problem.type,
+            'data' => problem.data,
+            'description' => problem.description,
+            'resolutions' => problem.resolutions
+          }
+        end
+
+        json_encode(problems)
+      end
+
+      # Try to resolve a set of problems
+      put '/deployments/:deployment/problems', :consumes => [:json] do
+        payload = json_decode(request.body)
+        start_task { @problem_manager.apply_resolutions(@user, params[:deployment], payload['resolutions']) }
+      end
+
+      put '/deployments/:deployment/scan_and_fix', :consumes => :json do
+        jobs_json = json_decode(request.body)['jobs']
+        # payload: [['j1', 'i1'], ['j1', 'i2'], ['j2', 'i1'], ...]
+        payload = convert_job_instance_hash(jobs_json)
+
+        start_task { @problem_manager.scan_and_fix(@user, params[:deployment], payload) }
+      end
+
+      get '/tasks' do
+        dataset = Models::Task.dataset
+        limit = params['limit']
+        if limit
+          limit = limit.to_i
+          limit = 1 if limit < 1
+          dataset = dataset.limit(limit)
+        end
+
+        states = params['state'].to_s.split(',')
+
+        if states.size > 0
+          dataset = dataset.filter(:state => states)
+        end
+
+        verbose = params['verbose'] || '1'
+        if verbose == '1'
+          dataset = dataset.filter(type: %w[
+          update_deployment
+          delete_deployment
+          update_release
+          delete_release
+          update_stemcell
+          delete_stemcell
+          create_snapshot
+          delete_snapshot
+          snapshot_deployment
+        ])
+        end
+
+        tasks = dataset.order_by(:timestamp.desc).map do |task|
+          if task_timeout?(task)
+            task.state = :timeout
+            task.save
+          end
+          @task_manager.task_to_hash(task)
+        end
+
+        content_type(:json)
+        json_encode(tasks)
+      end
+
+      get '/tasks/:id' do
+        task = @task_manager.find_task(params[:id])
+        if task_timeout?(task)
+          task.state = :timeout
+          task.save
+        end
+
+        content_type(:json)
+        json_encode(@task_manager.task_to_hash(task))
+      end
+
+      # Sends back output of given task id and params[:type]
+      # Example: `get /tasks/5/output?type=event` will send back the file
+      # at /var/vcap/store/director/tasks/5/event
+      get '/tasks/:id/output' do
+        log_type = params[:type] || 'debug'
+        task = @task_manager.find_task(params[:id])
+
+        if task.output.nil?
+          halt(204)
+        end
+
+        log_file = @task_manager.log_file(task, log_type)
+
+        if File.file?(log_file)
+          send_file(log_file, :type => 'text/plain')
+        else
+          status(204)
+        end
+      end
+
+      delete '/task/:id' do
+        task_id = params[:id]
+        task = @task_manager.find_task(task_id)
+
+        if task.state != 'processing' && task.state != 'queued'
+          status(400)
+          body("Cannot cancel task #{task_id}: invalid state (#{task.state})")
+        else
+          task.state = :cancelling
+          task.save
+          status(204)
+          body("Cancelling task #{task_id}")
+        end
+      end
+
+      # JMS and MB: We don't know why this code exists. According to JP it shouldn't. We want to remove it.
+      # To get comforable with that idea, we log something we can look for in production.
+      #
+      # GET /resources/deadbeef
+      get '/resources/:id' do
+        @logger.warn('Something is proxying a blob through the director. Find out why before we remove this method. ZAUGYZ')
+        tmp_file = @resource_manager.get_resource_path(params[:id])
+        send_disposable_file(tmp_file, :type => 'application/x-gzip')
+      end
+
+      post '/backups' do
+        start_task { @backup_manager.create_backup(@user) }
+      end
+
+      get '/backups' do
+        send_file @backup_manager.destination_path
+      end
+
+      get '/info' do
+        status = {
+          'name' => Config.name,
+          'uuid' => Config.uuid,
+          'version' => "#{VERSION} (#{Config.revision})",
+          'user' => @user,
+          'cpi' => Config.cloud_type,
+          'features' => {
+            'dns' => {
+              'status' => Config.dns_enabled?,
+              'extras' => { 'domain_name' => dns_domain_name }
+            },
+            'compiled_package_cache' => {
+              'status' => Config.use_compiled_package_cache?,
+              'extras' => { 'provider' => Config.compiled_package_cache_provider }
+            },
+            'snapshots' => {
+              'status' => Config.enable_snapshots
+            }
+          }
+        }
+        content_type(:json)
+        json_encode(status)
+      end
+
+      put '/resurrection', consumes: :json do
+        payload = json_decode(request.body)
+
+        @resurrector_manager.set_pause_for_all(payload['resurrection_paused'])
+        status(200)
+      end
+    end
+  end
+end