Page Comparison

Background

Update:  The API has been extended to apply to Evaluations as well as Entities.

Update:  The API has been extended to apply to Teams.  See Teams

Update:  We allow updating of Access Requirements by the ACT.  We allow Access Requirements to apply to Folders as well as Files.   Entities inherit any access restrictions applies to Folders which contain them.

Update:  We add inheritance of access requirements:  Each entity inherits the access requirements of its ancestors (e.g. the Folder(s) containing a given File).

IRB-approved versions of all of the 'data access documents' :

Summary:

- Data layer access in Synapse requires one or more approval steps.  
- In Synapse granting data access is synonymous with providing the URL to the stored data.
    (This URL may have an embedded access token.)
- Currently (i.e. as of Jan. 2012), the backend Prior to this work, the back end has a representation of EULAs and of Agreements (i.e. that a particular user agrees to a EULA)
- The work flow logic for creating the agreement is embedded in the Web client, so other clients would have to maintain duplicate logic. Specifically, the web client has the following logic:
1) When a user tries to download a layer, the Web client checks whether the parent dataset has an associate EULA;
2) If there is an EULA, the web client checks whether there is an Agreement, owned by the User and referencing the dataset and EULA;
3) If there is a EULA but no Agreement, the web client prompts the User to sign the EULA, creates the Agreement, then allows the download.

- There is no provision in our permissions scheme for an "IRB ACT role" which can grant or revoke 'download permission' to a user.

...

Tier 3:  (Tier 1) + (Tier 2) + User access must be requested/approved through an institutional review board (IRBAccess and Compliance Team (ACT).

Design

Security Model

- In the entity schema we allow a field to have a (some?) permission(s) which a user need to have before the field can be accessed.

- We add a 'Location' permission to the location field of the Layer entity.  To control download ability on a Layer, we control whether a user has the "Location' permission on the Layer.

Workflow Model

Design Assumptions

Things the client should not 'know'

- what requirements need to be met to access a Layer's location (e.g. you need to sign a EULA)

- what requirements have/have not been met by a User (e.g. whether a EULA has been signed)

Things the client SHOULD 'know'

- how to determine, from an entity's schema and from the repository authorization services, that a permission is needed to access a certain field of a certain entity.  (The alternative is to add a service to do this.)

- how to fulfill a requirement (e.g. if a EULA needs to be signed, knows how to retrieve and display the EULA, get it signed, and submit the appropriate request to the repo service)

Design Approach

The permissions-requirements service

- Add a new service 'permissionRequirements'. E.g. GET /permissionRequirements/101, where '101' is an entity ID, would return a response of the form

{

    Location:[ {type:EULA, params:{uri:/eula/987}, msg:status-msg}, {type:EULA, params:{uri:/eula/654}, msg:status-msg}, {type:ACT, params:{uri:/act/321}, msg:status-msg}]
}

The response lists the unmet requirements for each permission associated with the object, in the form <permission>:<requirement-list>.

(Optionally, just one of multiple unmet requirements could be returned, allowing the server to control the order in which requirements are considered by the client.)

There are three parts to a requirement:
type: from an ENUM, e.g. 'EULA', 'ACT'.
params: a map of parameters used by the given 'type'. The client needs to know what to do for each enum, and how to use its parameters. This will be documented in the developers' API.
msg: An optional status message, suitable for display to the user.
If a requirement has no type or params but has a message, then there is nothing for the user to do and the message helps explain why, e.g. {msg:"ACT approval pending"}

(Optionally, we could include this in the body of a 401 response.)

Permission Requirements Manager

The repository service will have a Permission Requirements Manager, which computes the response to the /permissionRequirements request from a given user for a given entity.  E.g. if a Layer required EULA 987 to be signed for a user to access it, and EULA 987 is not yet signed by the user, then the Permission Requirements Manager adds this requirement to the response to the /permissionsRequirements request.  The unmet requirements are stored *implicitly* in the state of the repository services, and the PRM determines the 'requirements gap' on the fly.

Object Model for Permission Requirements

An entity may have Requirement child entities.  These entities contain the details of what is required to obtain specific permissions on the object (e.g. <Location,EULA,/eula/987>.  The PRM refers to these objects to make its assessment.

Additional Services

- permissionRequest service:  Once the requirements are fulfilled, this allows a user to request that a permission granted for them (or should this be rolled into the permissionRequirements?)

- requirements CRUD services: allows the owner of an object to craft requirements for an object (or should this be rolled into the current permissions manager?)

Tier 1 Approval Process

Here the user signs the Tier 1 agreement upon account creation and is added to a "Tier 1 group".  The group has the Download role for all Tier 1 data layers.

"WF" refers to an envisioned workflow system which knows the approval workflows and can tell each participant what its next step is.

Below we see an alternative for synchronous user interaction.

Tier 2 Approval Process

This approval requires two hurdles, the Tier 1 agreement plus a new agreement which may be specific to the requested layer.  Upon approval Synapse adds the User to the Access Control List for the Layer.

The following variation has the properties that (1) interaction between Synapse and the User is synchronous, (2) there is no representation of the required workflow in the client, (3) there is no representation of the workflow *state* in the back end: Image Removed
This approach is based on the pattern used by "Basic Authentication", e.g. http://httpd.apache.org/docs/1.3/howto/auth.html#basicworks
in which a request can be denied, the denial containing information about what's required for the request to be approved.

Note:  the "/accessRequest" service  'knows' to check that eula 456 is signed before adding user to group 789

changed services:
    GET /layer: has to check whether there is an approval process and, if so, include the final step in the rejection
new services:
    /accessRequest: checks precondition; can (1) add user to group or (2) add Role to User
    POST /approvalProcess: creates an approvalProcess object whose parent is a Layer and
        whose content is the sequence of requests that need to be fulfilled (specific to the layer)
    POST /accessRequirements: creates an object containing the requirements for adding a User
        to the ACL for an entity (e.g. the user must have signed a certain EULA)

Design considerations:
    System does not track the 'state' of the approval process. That's left to the client.  The risk  is that the process might have to start over if it fails partway, but the benefit is in simplifying  the server.

How do you set up an approval process?
    POST /accessRequirements
    POST /approvalProcess

How do you revoke approval?
    1) remove the <User, Role> from the layer's ACL (or the <Group, Role> if all the users were added to a group)
    2) delete the approvalProcess and accessRequirements objects

Tier 3 Approval Process

Here we have the added complexity of an external IRB.  An "IRB daemon" is added to send approval requests to the IRB and to listen for replies.  The interaction with the user is asynchronous:  While waiting for approval the user may do other things (though not access the requested layer).  Finally she receives an email saying the request was approved.

Image Removed

Some open questions:

- How does Synapse know not to wait for any more steps, once it gets the final reply from WF (the workflow is not yet done)?

- When Synapse asks "next step" can it refer to a specifc workflow instance (and avoid getting an approval step for some other user)?

New/Modified Synapse Services

Request account (initiates tier 1 workflow as a side effect)

Download access request (initiates tier 2 or tier 2 workflow as a side effect, depending on the layer)

Sign tier 1 agreement

Sign tier 2 agreement

...

Database

We have tables for Requirements and Approvals: ACCESS_REQUIREMENT contains the requirement information, while NODE_ACCESS_REQUIREMENT 'joins'  it to the JDONODE table, saying what entities are affected by the requirement.  ACCESS_APPROVAL has foreign keys to ACCESS_REQUIREMENT and principal.  The first imposes a requirement for access to the node.  The second fulfills the requirement, for a given principal. The requirement and approval tables have an "ENTITY_TYPE" field (populated from an ENUM) and a "SERIALIZED_ENTITY" field, a BLOB, allowing them to have variable content, so they can be used for Tier 2 or Tier 3 requirements.

Below we omit the primary key and foreign key constraints for simplicity.

CREATE TABLE `ACCESS_REQUIREMENT` (
  `ID` bigint(20) NOT NULL AUTO_INCREMENT,
  `ETAG` bigint(20) NOT NULL,
  `CREATED_BY` bigint(20) NOT NULL,
  `CREATED_ON` bigint(20) NOT NULL,
  `MODIFIED_BY` bigint(20) NOT NULL,
  `MODIFIED_ON` bigint(20) NOT NULL,
  `NODE_ID` bigint(20) NOT NULL,
  `ACCESS_TYPE` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `ENTITY_TYPE` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `SERIALIZED_ENTITY` mediumblob
 )

CREATE TABLE `NODE_ACCESS_REQUIREMENT` (
  `NODE_ID` bigint(20) NOT NULL,
  `REQUIREMENT_ID` bigint(20) NOT NULL,
  PRIMARY KEY (`NODE_ID`, `REQUIREMENT_ID`)
) 

CREATE TABLE `EVALAUTION_ACCESS_REQUIREMENT` (
  `EVALUATION_ID` bigint(20) NOT NULL,
  `REQUIREMENT_ID` bigint(20) NOT NULL,
  PRIMARY KEY (`NODE_ID`, `REQUIREMENT_ID`)
)

CREATE TABLE `ACCESS_APPROVAL` (
  `ID` bigint(20) NOT NULL AUTO_INCREMENT,
  `ETAG` bigint(20) NOT NULL,
  `CREATED_BY` bigint(20) NOT NULL,
  `CREATED_ON` bigint(20) NOT NULL,
  `MODIFIED_BY` bigint(20) NOT NULL,
  `MODIFIED_ON` bigint(20) NOT NULL,
  `REQUIREMENT_ID` bigint(20) NOT NULL,
  `ACCESSOR_ID`  bigint(20) NOT NULL,
  `ENTITY_TYPE` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `SERIALIZED_ENTITY` mediumblob
)

Data Access Object (DAO)

We have DAOs for AccessRequirement and AccessApproval objects.  In addition to basic CRUD operations we have:

• AccessRequirementDAO.getForNode(), which returns all the AccessRequirements associated with a Node/Entity
• AccessApprovalDAO.getForNode(), which returns all the AccessApprovals associatd with a Node/Entity.  This allows us to find all the users who have been given access to an entity via a single database query.
• AccessApprovalDAO.getForAccessRequirementsAndPrincipals() which returns the AccessApprovals for a given list of AccessRequirements and Principals.  This method allows us to look up the approval of all the access requirements for a given node (focussing on user of interest) with a single database query.

JSON Schema

We introduce JSON schemas for the generic interfaces AccessApproval and AccessRequirement, and schemas for specific types, TermsOfUseAccessRequirement, TermsOfUseAccessApproval (for tier 2 data), ACTAccessRequirement, and ACTAccessApproval (for tier 3 data).

Services

Web UI

When a user clicks Download on the page for a Data object having a Terms of Use access requirement, they are presented with a dialog showing the text from the access requirement, as shown below.  If they accept the terms, then an access approval is created and the Download link is presented.

Image Added

When a user clicks Download on the page for a Data object having an ACT access requirement, they are presented with a dialog showing the text from the access requirement, as shown below.  Once they contact the ACT team, someone from the team may create the approval object on their behalf, after which they may download the Data without encountering the dialog.

Image Added