Enforce basic checks on lease/resource compatibility. Allows resources to reject leases if they are incompatible, even if the resource types match.

For example, if a resource represents a 32-bit host, this method might reject leases that need a 64-bit host. The blueprint might also reject a resource if the lease needs 8GB of RAM and the resource only has 6GB free.

This method should not acquire locks or expect anything to be locked. This is a coarse compatibility check between a lease and a resource.

Acquire a lease. Allows resources to perform setup as leases are brought online.

If acquisition fails, throw an exception.

React to a lease being released.

This callback is primarily useful for automatically releasing resources once all leases are released.

Destroy any temporary data associated with a lease.

If a lease creates temporary state while held, destroy it here.

Return true to try to allocate a new resource and expand the resource pool instead of permitting an otherwise valid acquisition on an existing resource.

This allows the blueprint to provide a soft hint about when the resource pool should grow.

Returning "true" in all cases generally makes sense when a blueprint controls a fixed pool of resources, like a particular number of physical hosts: you want to put all the hosts in service, so whenever it is possible to allocate a new host you want to do this.

Returning "false" in all cases generally make sense when a blueprint has a flexible pool of expensive resources and you want to pack leases onto them as tightly as possible.

Enforce fundamental implementation/lease checks. Allows implementations to reject a lease which no concrete blueprint can ever satisfy.

For example, if a lease only builds ARM hosts and the lease needs a PowerPC host, it may be rejected here.

This is the earliest rejection phase, and followed by canEverAllocateResourceForLease().

This method should not actually check if a resource can be allocated right now, or even if a blueprint which can allocate a suitable resource really exists, only if some blueprint may conceivably exist which could plausibly be able to build a suitable resource.

Enforce basic blueprint/lease checks. Allows blueprints to reject a lease which they can not build a resource for.

This is the second rejection phase. It follows canAnyBlueprintEverAllocateResourceForLease() and is followed by canAllocateResourceForLease().

This method should not check if a resource can be built right now, only if the blueprint as configured may, at some time, be able to build a suitable resource.

Enforce basic availability limits. Allows blueprints to reject resource allocation if they are currently overallocated.

This method should perform basic capacity/limit checks. For example, if it has a limit of 6 resources and currently has 6 resources allocated, it might reject new leases.

This method should not acquire locks or expect locks to be acquired. This is a coarse check to determine if the operation is likely to succeed right now without needing to acquire locks.

It is expected that this method will sometimes return true (indicating that a resource can be allocated) but find that another allocator has eaten up free capacity by the time it actually tries to build a resource. This is normal and the allocator will recover from it.

Allocate a suitable resource for a lease.

This method MUST acquire, hold, and manage locks to prevent multiple allocations from racing. World state is not locked before this method is called. Blueprints are entirely responsible for any lock handling they need to perform.

Destroy any temporary data associated with a resource.

If a resource creates temporary state when allocated, destroy that state here. For example, you might shut down a virtual host or destroy a working copy on disk.

Get a human readable name for a resource.

Get all the DrydockBlueprintImplementations which can possibly build a resource to satisfy a lease.

This method returns blueprints which might, at some time, be able to build a resource which can satisfy the lease. They may not be able to build that resource right now.

Does this implementation use concurrent resource limits?

Implementations can override this method to opt into standard limit behavior, which provides a simple concurrent resource limit.

Get the effective concurrent resource limit for this blueprint.

Apply standard limits on resource allocation rate.