HistoryViewLinks to this page 2013 April 11 | 07:46 am


Client Requirements

Mylyn is a client based on a full offline architecture that eagerly or passively synchronizes with one or more task repositories.

  • Query tasks by attributes (retrieve either ID/URL, or attributes, or contents)
  • Query tasks by date range
  • Retrieve task contents (either via query, or by task ID/URL)
  • Retrieve repository configuration (schema of all task attributes)

Tasks are uniquely identified by:

  • A repository URL (e.g., https://bugs.eclipse.org/bugs). Can change when a repository moves servers/domains. Any valid URL, including protocol segment.
  • A per-repository task ID (e.g. 123456). Unique for the lifecycle of the task. Any String.
  • A task key (optional, e.g., JDB-123). Convenience version of the ID, can change during lifecycle of task.


  • Setup task repository [1.0] service discovery
    1. Enter repository information: url, username, password
    2. Enter network parameters: http authentication, proxy information
    3. Specify repository specific configuration parameters
  • Search for tasks in repository [requires repository schema]
    1. Repository configuration is retrieved [2.0] shapes
    2. Enter search criteria [1.0] query
      1. This can include free text, attribute selections from lists, String-formatted stack traces or frames, date ranges etc.
    3. Results are retrieve from repository [1.0] query
      1. Results may not include all details for a task (e.g. no attachment information)
      2. This should be a fast operation, balancing returned detail and overhead
  • Monitor tasks in repository (new query) [requires repository schema] [2.0] shapes
    1. Follow steps for Search for tasks in repository [1.0] query
    2. Results are refreshed periodically [1.0] query (or TRS)
      1. This is a frequent operation, the cost should be minimal
    3. Full task details are retrieved for changed tasks [1.0]
    4. Notifications are displayed for changed tasks [1.0]
    5. Continue with Results are refreshed periodically [1.0]
  • Retrieve task by id
    1. Enter task id/key [1.0]
    2. Full task details are retrieved and displayed [1.0]
  • Display task details (open task editor) [2.0]
    1. Full task details are retrieved
      1. If the task was cached only a check is needed if the cached copy is up-to-date. This should be a fast operation with minimal cost
    2. Task attributes, attachments, comments are displayed
  • Edit task (submit) [requires repository schema] [2.0] shapes
    1. Follow steps for Display task details
    2. Change task attributes (optional)
    3. Enter comment (optional)
    4. Select a work-flow operation [3.0]
    5. Submit changes to task
      1. Either submit delta of changed attributes or full details
      2. Detect concurrent modification of task in the repository
    6. Refreshed details for the task are retrieved
  • Manage the state of the Task on the TaskList
    3. Close
    4. Verifiy
    5. Reopen
    6. Duplicate [URI of resource that this is a duplicate of]

Attachment Scenarios

  • User wishes to attach documents or screenshots or some other form of supporting informatino in blob form to the ChangeRequest. The information is deemed to be in support of a particular ChangeRequest and is not expected to referended by any other ChangeRequest [3.0]
    • A specific ChangeRequest is chosen by the user
    • User selects a file for attaching to the ChangeRequest
    • File is submitted (in some cases Files are attached along with a supporting Comment)
      • Attached file may be large, the repository should support streaming of data
    • Refreshed details for the ChangeRequest are retrieved (including metadata for new attachment such as id, (url), name, size)
  • Users collaborating on a ChangeRequest with others will want to be able to retrive attachments posted by others [3.0]
    • User having viewed the presence of an attachment on a ChangeRequest, selects that the attachment be downloaded
    • The attachment is retrieved (downloaded) by the client either immediately viewed if content type support or optionally saved to disk
      • Attached file may be large, the repository should support streaming of data
  • User wishes to update an existing attachment. (Not implemented by all repositories)
    • User is able to post a new attachment, identifying the existing attachment that should be replaced.
    • Metadata about attachment (who attached, size, content type) updated based on new submit
    • Potentially a new comment also added as part of update

[1.0] - indicates the capability exists in 1.0 specification

[2.0] - indicates missing capability in 1.0 specification, added in 2.0

[3.0] - indicates missing capability in 1.0 & 2.0 specification, targeting 3.0

API Requirements


All repository that we currently support use either form/cookie or HTTP BASIC authentication mechanisms.

Data Structures

Task Schema / Repository Configuration

A task schema specifies the structure of a task or search query. Some repositories may use specific schemas on a per task basis or use a single schema (repository configuration) for all tasks. The repository configuration may depend on user permissions, e.g. a user may not have permission to see all available projects.

Task schemas contain the following data:

  • URI/Version: A task schema should have a unique location to allow caching
  • List of fields: Available fields


Fields specify information how to interpret and present a task attribute. Each field has specifies at least the following details:

  • ID: Unique identifier
  • Label: User-visible string, e.g. Project, Summary, Component
  • Visible: Set to false for internal attributes, e.g. ids
  • Type: String, Integer, Comment, Custom type etc.
  • Multi-Value: Set to true for attributes that allow selection of multiple values
  • Options: List of legal values for an attribute
    • Relational dependencies on other fields, e.g. a component may only be a valid choice if a another field has a certain value or state.

A list of common ids and types needs to be specified to support a generic implementation that is able to (partially) interpret task schemas.


An operation can be performed on a task:

  • ID: Unique identifier
  • Label: User-visible string, e.g. Reassign, Close
  • List of fields: List of fields that can be modified when this operation is performed

Search Specification

A generic language is needed for specifying search queries against a repository. Date range-based searches must be supported for incremental synchronization; alternately, a feed of changed tasks can be provided.

Search Result

A task received as result of a search. The schema should be similar to Task with less details to allow fast execution of searches.


A task. Each task has a schema that may depend on the state of the task, e.g. whether it’s a bug or feature request, the current workflow state or permissions of the authenticated user.

Accessors on ITask / ITaskMapping define the core schema for a task:

  • ID (reqd): Unique, static identifer, usually an integer. Combined with repository url to form unique handle.
    • String getTaskId()
  • Task Key: User facing identifer that can change during the lifetime of the task
    • String getTaskKey()
  • Summary (reqd): One line description of the task
    • String getSummary()
  • Description: Multiline description of the task
    • String getDescription()
  • Creation Date
    • Date getCreationDate()
  • Completion Date
    • Date getCompletionDate()
  • Task Kind: User recognized kind of task used in UI (i.e. Bug, Task, Enhancement). Often used by connectors to preform kind specific functions.
    • String getTaskKind()
  • Task Url: Url for html representation of the task
    • String getTaskUrl()
  • Owner: Person who owns / is assigned to or otherwise responsible for completion of the task (usually email address)
    • String getOwner()
  • Reporter: User who orignially submitted the task (does not chage)
    • String getReporter()
  • Cc: List of user’s Cc’d on task
    • List getCc()
  • Status: Current state of the task usually within a multstate workflow
    • String getTaskStatus()
  • Resolution: In what capacity this task was completed (fixed, duplicate, invalid etc) *
    • String getResolution()
  • Priority: Indicator of urgency. Connectors encouraged to map to Mylyn’s PriorityLevel ( P1 - P5) states
    • String getPriority()
    • PriorityLevel getPriorityLevel() - opportunity to override and perform alternate mapping
    • PriorityLevel is an enum with values P1, P2, P3, P4, P5
  • Severity: Degree of the importance of the task
    • String getSeverity()
  • Modification Date: Timestamp when task was last modified (if no explicit version attribute exists, this is used to detect a change)
    • Date getModificationDate()
  • Due Date: Date the task is expected to be completed by
    • Date getDueDate()
  • Product: Name of entity with which this task corresponds to or intended to affect
    • String getProduct()
  • Component: Sub section of Product this task is concerned with
    • String getComponent()
  • Keywords:list of strings to help identify the task, usually searchable
    • List getKeywords()
  • Attachments: Similar to list of attributes, except that the value of an attachment has to be retrieved separately
  • Operations: Legal operations that can be taken on the task in its current state
  • Attributes: This api doesn’t cover all possible ways that a task can be described. Connectors can add additional attributes that can later be displayed to the user or hidden. Each attribute corresponds to a field in the task schema and has one or multiple values. Attributes can be nested within parent attributes. Attributes can be declared to be of one of the following types:
    • Boolean
    • Date
    • Date Time
    • Integer
    • Long
    • Short Text
    • Long Rich Text
    • Long Text
    • Single Select
    • Multi Select
    • Person
    • Task Dependency
    • Url
    • Comment (See Task Comments below)
    • Attachment (See Task Attachment below)
    • Operation (used by Operations mentioned above)

Task Comments (ITaskComment) - Implemented as attributes on task data of type TaskAttribute.TYPE_COMMENT with ID = TaskAttribute.PREFIX_COMMENT + COMMENT_NUMBER. Attribute ids identified by TaskAttribute.COMMENT_XXXX

  • Author
    • IRepositoryPerson getAuthor()
  • Creation Date
    • Date getCreationDate()
  • Comment Number
    • int getNumber()
  • Comment Text
    • String getText()

Task Attachment s (ITaskAttachment) - Implemented as attributes on task data of type TaskAttribute.TYPE_ATTACHMENT with id prefix TaskAttribute.PREFIX_ATTACHMENT + ATTACHMENT_NUMBER. Child attributes below are identified by TaskAttribute.ATTACHMENT_XXXX.

  • File Name (String)
  • Author (IRepositoryPerson)
  • Description (String)
  • Comment (String)
  • Content Type (String)
  • Content Length (long)
  • Url (String)
  • isDeprecated (boolean)
  • isPatch (boolean)

Repository Person

  • Name - String
  • Person ID - String (email address / unique id)

Integration Levels

The two most significant levels of Mylyn integration are distinguished by the ability to view/edit the change reqest (task) offline and in an Eclipse native rich editor.

Integration Level 1 - Task List Support

The first level of integration with a repository give support for presenting tasks within the task list that represent the server side change request. Query support is also expected to be implemented for this level. This level does not include any rich editing. Opening of the change request itself is delegated to the repository’s web UI. For this level of integration to work, very few fields are required. Suggested minimum fields include:

  • Task Id
  • Summary
  • Modification Date
  • Completion Date (not completely necessary but desirable)

Integration Level 2 - Rich offline editing

In order to support rich offline task editing, connectors need to retrieve the change requests raw data and populate Mylyn’s TaskData structure. Additionally, a mapping is required from Mylyn attributes to the equivalent field in the retrieved TaskData. The required attributes depend on how complete support you desire for the repository in question. For example, Attachments is not required to have the rich offline editing support. This can initially be delegated to the web ui. Comments however (Task Comments above) woudl be required to make any real use of the editor.

Remote Interface

It is key that all operations that return data support checking if a repository artifact has changed before transferring large amounts of data. Polling for updates is a frequent operation of rich task repository clients and the API needs provisions to ensure scalability.

  • Authenticate

  • Retrieve Repository Configuration

  • Search for Tasks

  • Create Task

  • Retrieve Task
  • Retrieve Task Schema
  • Update Task

  • Create Attachment

  • Retrieve Attachment

Reviewer Comments

Updated with feedback from 2009-02-04 call.

– MikKersten - 18 Feb 2009

I definitely concur with what is said in the Remote Interface n support checking if a repository has changed before transferring large amounts of data.

– PeterThung - 24 Mar 2009

It would be useful that this protocol be sensitive to web based clients or the creation of web based clients for users that do not want or need a full blown Eclipse IDE to manage tasks, but would benefit from managing issues from different repositories such as Mantis, Razor etc… Also, it would be useful (at least to me), although this may be more on an aggregator client side than server side of being able to detect duplicates within a single repository and also related issues between repositories and tag them as related. In talking with MikKersten, I see the value of having fields created within each repository maybe holding the value of the unique key of the other repositories that they may be related to, but that assumes that you actually have write permissions to affect individual reports in someone elses repository and have the ability to add columns. - If possible, I think the scenario of you only have read only privileges of people’s or organizations Issue tracking repository and can only be guaranteed updates from them should be included. I’m thinking right now that the design constraint would make perhaps the one repository you do have access to the “master” repository” and have entries/copies from other peoples repositories. As they do updates to their own repositories it would update your repository. Then in your repository if you support relatinships between issues you tag issues as related locally and then your client to your own repository would have the ability to filter issues and hide related issues from table viewing purposes, but allow drill down into the relationships where they exist.

– PeterThung - 24 Mar 2009

Category:Supporting Documents