Page Comparison

public interface Authorizer extends{
AuthEnforcer { 	/**
   * Initialize *the Grants a principal authorization to perform a set of actions on an entity.
     *
     * @param entity the entity on which an action is being performed
     * @param principal the Principal that performs the actions. This could be a user, group or a role
     * @param actions the set of actions to grant
     */
    void grant(EntityId entity, Principal principal, Set<Action> actions);

	/**
     * Grants a Principal authorization to perform all actions on an entity.
     *
     * @param entity the entity on which an action is being performed
     {@link Authorizer}. Authorization extensions can use this method to access an
   * {@link AuthorizationContext} that allows them to interact with CDAP for operations such as creating and accessing
   * datasets, executing dataset operations in transactions, etc.
   *
   * @param context the {@link AuthorizationContext} that can be used to interact with CDAP
   */
  void initialize(AuthorizationContext context) throws Exception;

  /**
   * Enforces authorization for the specified {@link Principal} for the specified {@link Action} on the specified
   * {@link EntityId}.
   *
   * @param entity the {@link EntityId} on which authorization is to be enforced
   * @param principal the {@link Principal} that performs the actions.
This could be a* user,@param groupaction orthe a{@link roleAction} being performed
   */ @throws UnauthorizedException if the voidprincipal grant(EntityId entity, Principal principal, Set<Action> actions);
	/**
 is not authorized to perform action on the entity
   * Revokes@throws aException principal'sif authorizationany toother performerrors aoccurred setwhile ofperforming actionsthe onauthorization an entity.
 enforcement check
   */
  void   * @param entity the entity on which an action is being performed
enforce(EntityId entity, Principal principal, Action action) throws Exception;

  /**
   * * @param principal the principal that performs the actions. This could be a user, group or a role
 Grants a {@link Principal} authorization to perform a set of {@link Action actions} on an {@link EntityId}.
   *
   * @param actionsentity the set of actions{@link EntityId} to revokewhom permissions{@link onAction actions} are to be granted
*/   * @param voidprincipal revoke(EntityId entity,the {@link Principal} that principal,performs Set<Action>the actions);. This 	/**could be a user, or role
* Revokes a principal's* authorization@param toactions performthe anyset actionof on{@link anAction entity.actions} to grant.
   */
  void grant(EntityId entity, *Principal @paramprincipal, entitySet<Action> theactions) entitythrows onException;
which
an action is/**
being performed  * Revokes a {@link *Principal @param principal's} theauthorization principalto thatperform performsa theset actions.of This{@link couldAction beactions} aon
user, group or a* rolean {@link EntityId}.
   */
   * void@param revoke(EntityId entity, Principal Principal);

    /**
 the {@link EntityId} whose {@link Action actions} are to be revoked
   * Revokes@param allprincipal principals'the authorization{@link toPrincipal} performthat anyperforms action on an entitythe actions. This could be a user, *group or role
   * @param entityactions the entityset onof which{@link anAction actionactions} isto beingrevoke
performed      */
    void revoke(EntityId entity);, }

Principal

 principal, Set<Action> actions) throws Exception;

  /**
   * Revokes all {@link Principal principals'} authorization to perform any {@link Action} on the given
   * {@link EntityId}.
   *
   * @param entity the {@link EntityId} on which all {@link Action actions} are to be revoked
   */
  void revoke(EntityId entity) throws Exception;

  /**
   * Returns all the {@link Privilege} for the specified {@link Principal}.
   *
   * @param principal the {@link Principal} for which to return privileges
   * @return a {@link Set} of {@link Privilege} for the specified principal
   */
  Set<Privilege> listPrivileges(Principal principal) throws Exception;

  /********************************* Role Management: APIs for Role Based Access Control ******************************/
  /**
   * Create a role.
   *
   * @param role the {@link Role} to create
   * @throws RoleAlreadyExistsException if the the role to be created already exists
   */
  void createRole(Role role) throws Exception;

  /**
   * Drop a role.
   *
   * @param role the {@link Role} to drop
   * @throws RoleNotFoundException if the role to be dropped is not found
   */
  void dropRole(Role role) throws Exception;

  /**
   * Add a role to the specified {@link Principal}.
   *
   * @param role the {@link Role} to add to the specified group
   * @param principal the {@link Principal} to add the role to
   * @throws RoleNotFoundException if the role to be added to the principals is not found
   */
  void addRoleToPrincipal(Role role, Principal principal) throws Exception;

  /**
   * Delete a role from the specified {@link Principal}.
   *
   * @param role the {@link Role} to remove from the specified group
   * @param principal the {@link Principal} to remove the role from
   * @throws RoleNotFoundException if the role to be removed to the principals is not found
   */
  void removeRoleFromPrincipal(Role role, Principal principal) throws Exception;

  /**
   * Returns a set of all {@link Role roles} for the specified {@link Principal}.
   *
   * @param principal the {@link Principal} to look up roles for
   * @return Set of {@link Role} for the specified {@link Principal}
   */
  Set<Role> listRoles(Principal principal) throws Exception;

  /**
   * Returns all available {@link Role}. Only a super user can perform this operation.
   *
   * @return a set of all available {@link Role} in the system.
   */
  Set<Role> listAllRoles() throws Exception;

  /**
   * Destroys an {@link Authorizer}. Authorization extensions can use this method to write any cleanup code.
   */
  void destroy() throws Exception;
}