bosh-director 1.5.0.pre.1113

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

@@ -0,0 +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)
+        instance.resurrection_paused = desired_state
+        instance.save
+      end
+
+      def set_pause_for_all(desired_state)
+        Models::Instance.update(resurrection_paused: desired_state)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Bosh::Director
+  module Api
+    class SnapshotManager
+      def create_deployment_snapshot_task(user, deployment, options = {})
+        JobQueue.new.enqueue(user, Jobs::SnapshotDeployment, 'snapshot deployment', [deployment.name, options])
+      end
+
+      def create_snapshot_task(user, instance, options)
+        JobQueue.new.enqueue(user, Jobs::CreateSnapshot, 'create snapshot', [instance.id, options])
+      end
+
+      def delete_deployment_snapshots_task(user, deployment)
+        JobQueue.new.enqueue(user, Jobs::DeleteDeploymentSnapshots, 'delete deployment snapshots', [deployment.name])
+      end
+
+      def delete_snapshots_task(user, snapshot_cids)
+        JobQueue.new.enqueue(user, Jobs::DeleteSnapshots, 'delete snapshot', [snapshot_cids])
+      end
+
+      def find_by_cid(deployment, snapshot_cid)
+        snapshot = Models::Snapshot.find(snapshot_cid: snapshot_cid)
+        raise SnapshotNotFound, "snapshot #{snapshot_cid} not found" unless snapshot
+        unless deployment == snapshot.persistent_disk.instance.deployment
+          raise SnapshotNotFound, "snapshot #{snapshot_cid} not found in deployment #{deployment.name}"
+        end
+        snapshot
+      end
+
+      def snapshots(deployment, job=nil, index=nil)
+        filter = { deployment: deployment }
+        filter[:job] = job if job
+        filter[:index] = index if index
+
+        result = []
+        instances = Models::Instance.filter(filter).all
+
+        instances.each do |instance|
+          instance.persistent_disks.each do |disk|
+            disk.snapshots.each do |snapshot|
+              result << {
+                  'job' => instance.job,
+                  'index' => instance.index,
+                  'snapshot_cid' => snapshot.snapshot_cid,
+                  'created_at' => snapshot.created_at.to_s,
+                  'clean' => snapshot.clean
+              }
+            end
+          end
+        end
+
+        result
+      end
+
+      def self.delete_snapshots(snapshots)
+        snapshots.each do |snapshot|
+          Config.cloud.delete_snapshot(snapshot.snapshot_cid)
+          snapshot.delete
+        end
+      end
+
+      def self.take_snapshot(instance, options={})
+        unless Config.enable_snapshots
+          Config.logger.info('Snapshots are disabled; skipping')
+          return []
+        end
+
+        clean = options.fetch(:clean, false)
+        snapshot_cids = []
+        metadata = {
+            deployment: instance.deployment.name,
+            job: instance.job,
+            index: instance.index,
+            director_name: Config.name,
+            director_uuid: Config.uuid,
+            agent_id: instance.vm.agent_id,
+            instance_id: instance.vm_id
+        }
+
+        instance.persistent_disks.each do |disk|
+          cid = Config.cloud.snapshot_disk(disk.disk_cid, metadata)
+          snapshot = Models::Snapshot.new(persistent_disk: disk, snapshot_cid: cid, clean: clean)
+          snapshot.save
+          snapshot_cids << snapshot.snapshot_cid
+        end
+
+        snapshot_cids
+
+      rescue Bosh::Clouds::NotImplemented
+        Config.logger.info('CPI does not support disk snapshots; skipping')
+        []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+    class StemcellManager
+      include ApiHelper
+
+      def find_by_name_and_version(name, version)
+        stemcell = Models::Stemcell[:name => name, :version => version]
+        if stemcell.nil?
+          raise StemcellNotFound,
+                "Stemcell `#{name}/#{version}' doesn't exist"
+        end
+        stemcell
+      end
+
+      def stemcell_exists?(name, version)
+        find_by_name_and_version(name, version)
+        true
+      rescue StemcellNotFound
+        false
+      end
+
+      def create_stemcell(user, stemcell, options = {})
+        if options[:remote]
+          stemcell_file = stemcell
+        else
+          random_name = "stemcell-#{SecureRandom.uuid}"
+          stemcell_dir = Dir::tmpdir
+          stemcell_file = File.join(stemcell_dir, random_name)
+
+          unless check_available_disk_space(stemcell_dir, stemcell.size)
+            raise NotEnoughDiskSpace, "Uploading stemcell archive failed. " +
+              "Insufficient space on BOSH director in #{stemcell_dir}"
+          end
+          
+          write_file(stemcell_file, stemcell)
+        end
+
+        JobQueue.new.enqueue(user, Jobs::UpdateStemcell, 'create stemcell', [stemcell_file, options])
+      end
+
+      def delete_stemcell(user, stemcell, options={})
+        description = "delete stemcell: #{stemcell.name}/#{stemcell.version}"
+
+        JobQueue.new.enqueue(user, Jobs::DeleteStemcell, description, [stemcell.name, stemcell.version, options])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+    module TaskHelper
+      def create_task(user, type, description)
+        user = Models::User[:username => user]
+        task = Models::Task.create(:user => user,
+                                   :type => type,
+                                   :description => description,
+                                   :state => :queued,
+                                   :timestamp => Time.now,
+                                   :checkpoint_time => Time.now)
+        log_dir = File.join(Config.base_dir, "tasks", task.id.to_s)
+        task_status_file = File.join(log_dir, "debug")
+        FileUtils.mkdir_p(log_dir)
+        logger = Logger.new(task_status_file)
+        logger.level= Config.logger.level
+        logger.info("Director Version : #{Bosh::Director::VERSION}")
+        logger.info("Enqueuing task: #{task.id}")
+
+        # remove old tasks
+        min_task_id = task.id - Config.max_tasks
+        task_files = Dir.glob(File.join(Config.base_dir, "tasks/*"))
+        task_files.each do |file_path|
+          begin
+            task_file = File.basename(file_path)
+            task_id = Integer(task_file)
+
+            if task_id <= min_task_id && task_id >= 0
+              logger.info("Delete #{task_file}")
+              FileUtils.rm_rf file_path
+              Models::Task[task_id].destroy
+            end
+          rescue
+            # skip over invalid task files
+          end
+        end
+
+        task.output = log_dir
+        task.save
+        task
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+    class TaskManager
+      # Looks up director task in DB
+      # @param [Integer] task_id
+      # @return [Models::Task] Task
+      # @raise [TaskNotFound]
+      def find_task(task_id)
+        task = Models::Task[task_id]
+        if task.nil?
+          raise TaskNotFound, "Task #{task_id} not found"
+        end
+        task
+      end
+
+      # Returns hash representation of the task
+      # @param [Models::Task] task Director task
+      # @return [Hash] Hash task representation
+      def task_to_hash(task)
+        {
+          "id" => task.id,
+          "state" => task.state,
+          "description" => task.description,
+          "timestamp" => task.timestamp.to_i,
+          "result" => task.result,
+          "user" => task.user ? task.user.username : "admin"
+        }
+      end
+
+      def log_file(task, log_type)
+        # Backward compatibility
+        return task.output unless File.directory?(task.output)
+
+        # Backward compatbility from renaming `soap` log to `cpi` log.
+        # Old tasks might have been written to the file `soap` and we should
+        # still return them if log_type = cpi. Same goes for new task logs
+        # written to `cpi` but an old CLI has requested log_type = soap.
+        if %w(soap cpi).include?(log_type)
+          log_type = File.file?(File.join(task.output, "soap")) ? "soap" : "cpi"
+        end
+        file = File.join(task.output, log_type)
+        file_gz = [file, 'gz'].join('.')
+
+        decompress(file_gz, file)
+
+        file
+      end
+
+      def decompress(src, dst)
+        # only decompress if log_file is missing and we have a compressed file
+        return unless !File.file?(dst) && File.file?(src)
+
+        File.open(dst, 'w') do |file|
+          Zlib::GzipReader.open(src) do |gz|
+            file.write gz.read
+          end
+        end
+        FileUtils.rm(src)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+    class UserManager
+
+      # @param [String] name User name
+      # @return [Models::User] User
+      def find_by_name(name)
+        user = Models::User[:username => name]
+        if user.nil?
+          raise UserNotFound, "User `#{name}' doesn't exist"
+        end
+        user
+      end
+
+      def authenticate(username, password)
+        # This is a dev-mode shortcut
+        if Models::User.count == 0
+          return username == "admin" && password == "admin"
+        end
+
+        user = find_by_name(username)
+        BCrypt::Password.new(user.password) == password
+      rescue UserNotFound
+        false
+      end
+
+      def delete_user(username)
+        find_by_name(username).destroy
+      end
+
+      def create_user(new_user)
+        user = Models::User.new
+        user.username = new_user.username
+        if new_user.password
+          user.password = BCrypt::Password.create(new_user.password).to_s
+        end
+        save_user(user)
+        user
+      end
+
+      def update_user(updated_user)
+        user = find_by_name(updated_user.username)
+        user.password = BCrypt::Password.create(updated_user.password).to_s
+        save_user(user)
+        user
+      end
+
+      def get_user_from_request(request)
+        hash = Yajl::Parser.new.parse(request.body)
+        Models::User.new(:username => hash["username"],
+                         :password => hash["password"])
+      end
+
+      private
+
+      # Saves user in DB and handles validation errors.
+      # @param [Models::User]
+      # @return [void]
+      def save_user(user)
+        user.save
+      rescue Sequel::ValidationFailed => e
+        username_errors = e.errors.on(:username)
+        if username_errors && username_errors.include?(:unique)
+          raise UserNameTaken, "The username #{user.username} is already taken"
+        end
+        raise UserInvalid, "The user is invalid: #{e.errors.full_messages}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Api
+    class VmStateManager
+      def fetch_vm_state(user, deployment, format)
+        JobQueue.new.enqueue(user, Jobs::VmState, 'retrieve vm-stats', [deployment.id, format])
+      end
+    end
+  end
+end

data/lib/bosh/director/app.rb

@@ -0,0 +1,35 @@
+module Bosh::Director
+
+  # This is a work in progress.
+  #
+  # The App is the "top of the world"; it holds all the stateful components in the
+  # system. There should be only one instance, available as a class instance to the
+  # (hopefully few) components that require it.
+
+  class App
+
+    class << self
+      # Some places (ie, resque jobs) need to reference the authoriative app instance
+      # from class methods.
+      def instance
+        @@instance
+      end
+    end
+
+    attr_reader :blobstores
+
+    def initialize(config)
+      # You should only create one of these at a time, but when you create one
+      # it becomes the authoritative official version across the whole app.
+      @@instance = self
+
+      # This is the legacy config system that we are trying to get rid of by
+      # decomposing and moving all the dependent components into this App
+      Bosh::Director::Config.configure(config.hash)
+
+      @blobstores = Blobstores.new(config)
+    end
+
+
+  end
+end

data/lib/bosh/director/blob_util.rb

@@ -0,0 +1,87 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  class BlobUtil
+    # @param [String] path Path to a file to be uploaded
+    # @return [String] Created blob id
+    def self.create_blob(path)
+      File.open(path) { |f| blobstore.create(f) }
+    end
+
+    def self.copy_blob(blobstore_id)
+      # Create a copy of the given blob
+      Dir.mktmpdir do |path|
+        temp_path = File.join(path, "blob")
+        File.open(temp_path, 'w') do |file|
+          blobstore.get(blobstore_id, file)
+        end
+        File.open(temp_path, 'r') do |file|
+          blobstore_id = blobstore.create(file)
+        end
+      end
+      blobstore_id
+    end
+
+    def self.save_to_global_cache(compiled_package, cache_key)
+      global_cache_filename = [compiled_package.package.name, cache_key].join('-')
+      Dir.mktmpdir do |path|
+        temp_path = File.join(path, 'blob')
+        File.open(temp_path, 'wb') do |file|
+          blobstore.get(compiled_package.blobstore_id, file)
+        end
+
+        File.open(temp_path) do |file|
+          compiled_package_cache_blobstore.create(file, global_cache_filename)
+        end
+      end
+    end
+
+    def self.exists_in_global_cache?(package, cache_key)
+      global_cache_filename = [package.name, cache_key].join('-')
+      compiled_package_cache_blobstore.exists?(global_cache_filename)
+    end
+
+    def self.fetch_from_global_cache(package, stemcell, cache_key, dependency_key)
+      global_cache_filename = [package.name, cache_key].join('-')
+
+      blobstore_id = nil
+      compiled_package_sha1 = nil
+
+      Dir.mktmpdir do |path|
+        blob_path = File.join(path, 'blob')
+        begin
+          File.open(blob_path, 'wb') do |file|
+            compiled_package_cache_blobstore.get(global_cache_filename, file)
+          end
+        rescue Bosh::Blobstore::NotFound => e
+          # if the object is not found in the cache, we ignore it and return nil
+          return nil
+        end
+
+        File.open(blob_path) do |file|
+          blobstore_id = blobstore.create(file)
+          compiled_package_sha1 = Digest::SHA1.file(blob_path).hexdigest
+        end
+      end
+
+      Models::CompiledPackage.create do |p|
+        p.package = package
+        p.stemcell = stemcell
+        p.sha1 = compiled_package_sha1
+        p.build = Models::CompiledPackage.generate_build_number(package, stemcell)
+        p.blobstore_id = blobstore_id
+        p.dependency_key = dependency_key
+      end
+    end
+
+    private
+
+    def self.blobstore
+      App.instance.blobstores.blobstore
+    end
+
+    def self.compiled_package_cache_blobstore
+      Config.compiled_package_cache_blobstore
+    end
+  end
+end