TenantGate (Atlassian Confluence 7.3.5 API)

java.lang.Object
- com.atlassian.confluence.tenant.TenantGate<T>

Type Parameters:

T - The type of the bean that we are protecting.

All Implemented Interfaces:

org.springframework.beans.factory.FactoryBean<T>
```
public abstract class TenantGate<T>
extends Object
implements org.springframework.beans.factory.FactoryBean<T>
```
Prevents access to tenanted beans in case of a vacant (zero tenancy) instance.
The default behaviour is to escape with a VacantException, but the gate can also delegate to a vacant implementation which could behave somehow differently.
This class should be considered a temporary solution on the way to multi-tenancy. It's sole purpose is currently to delay the initialisation of SessionFactory beans until a system tenant arrived.
I've seen things you people wouldn't believe. Attack ships on fire off the shoulder of Orion. I watched C-beams glitter in the dark near the TenantGate. All those moments will be lost in time... like tears in rain... Time to die.

Since:

5.6

See Also:

SystemTenant

Field Summary

Fields
Modifier and Type	Field and Description
`protected Class[]`	`proxyInterfaces` Deprecated. since 7.0. Access via `getProxyInterfaces()`.
`protected TenantRegistry`	`tenantRegistry` Deprecated. Since 7.0. Access via `getTenantRegistry()`.

Constructor Summary

Constructors
Modifier Constructor and Description

protected TenantGate(TenantRegistry tenantRegistry, Class[] proxyInterfaces)

Constructors
Modifier	Constructor and Description
`protected`	`TenantGate(TenantRegistry tenantRegistry, Class[] proxyInterfaces)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> Callable<T>`	`close(Callable<T> callback)` Close all gates for the given closure on the current thread.
`protected abstract T`	`createTenantedDelegate()` Returns the delegate to be used when the tenant is present.
`protected T`	`createVacantDelegate()` Returns the delegate to be used when the tenant is vacant.
`T`	`getObject()`
`Class`	`getObjectType()`
`protected Class[]`	`getProxyInterfaces()`
`protected TenantRegistry`	`getTenantRegistry()`
`boolean`	`isPermitted()`
`boolean`	`isSingleton()`
`static <T> Callable<T>`	`open(Callable<T> callback)` Open all gates for the given closure on the current thread.
`static <T> Callable<T>`	`permit(boolean permitted, Callable<T> callback)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - tenantRegistry
```
@Deprecated
protected final TenantRegistry tenantRegistry
```
    Deprecated. Since 7.0. Access via getTenantRegistry().
  - proxyInterfaces
```
@Deprecated
protected final Class[] proxyInterfaces
```
    Deprecated. since 7.0. Access via getProxyInterfaces().
- Constructor Detail
  - TenantGate
```
protected TenantGate(TenantRegistry tenantRegistry,
                     Class[] proxyInterfaces)
```
- Method Detail
  - getTenantRegistry
```
protected TenantRegistry getTenantRegistry()
```
    Since:
    
    7.0
  - getProxyInterfaces
```
protected Class[] getProxyInterfaces()
```
    Since:
    
    7.0
  - isPermitted
```
public boolean isPermitted()
```
    Returns:
    
    checks if the current thread is allowed to pass through the gate
  - open
```
public static <T> Callable<T> open(Callable<T> callback)
```
    Open all gates for the given closure on the current thread.
    This only makes sense in a pre-tenanted state, e.g. during setup allow code to prepare the database before it's made available to a broader audience.
    
    Parameters:
    
    callback - the function allowed to pass through the gate
    
    Returns:
    
    the permitted function
  - close
```
public static <T> Callable<T> close(Callable<T> callback)
```
    Close all gates for the given closure on the current thread.
    This only makes sense in a pre-tenanted state, if you want to ensure that the given code can not access tenanted resources even though an outer closure might have granted that access, e.g. loading DefaultPluginManager.earlyStartup() plugins which should not be able to eagerly access tenanted resources.
    
    Parameters:
    
    callback - the function allowed to pass through the gate
    
    Returns:
    
    the permitted function
  - createVacantDelegate
```
protected T createVacantDelegate()
```
    Returns the delegate to be used when the tenant is vacant. May be overriden by Spring using method-injection, but can be left as the default.
  - createTenantedDelegate
```
protected abstract T createTenantedDelegate()
```
    Returns the delegate to be used when the tenant is present. Generally overriden by Spring using method-injection.
  - getObject
```
public final T getObject()
```
    Specified by:
    
    getObject in interface org.springframework.beans.factory.FactoryBean<T>
  - getObjectType
```
public final Class getObjectType()
```
    Specified by:
    
    getObjectType in interface org.springframework.beans.factory.FactoryBean<T>
  - isSingleton
```
public final boolean isSingleton()
```
    Specified by:
    
    isSingleton in interface org.springframework.beans.factory.FactoryBean<T>
  - permit
```
public static <T> Callable<T> permit(boolean permitted,
                                     Callable<T> callback)
```

Class TenantGate<T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

tenantRegistry

proxyInterfaces

Constructor Detail

TenantGate

Method Detail

getTenantRegistry

getProxyInterfaces

isPermitted

open

close

createVacantDelegate

createTenantedDelegate

getObject

getObjectType

isSingleton

permit