Difference between revisions of "SMILA/Specifications/DeltaIndexingAndConnectivtyDiscussion09"

From Eclipsepedia

Jump to: navigation, search
(Separate Interfaces for ConnectivityManager and DeltaIndexingManager: moved to own page)
(refactored this page and moved implemented changes to their own pages)
Line 1: Line 1:
== Alternative Concept ==
+
== Motivation for this page and usage ==
  
=== Motivation ===
+
the current implementation for the [[SMILA/Documentation/DeltaIndexingManager | DeltaIndexingManager]] has several problems or short comings which are listed under the section  [[#Ideas (under discussion)|Ideas (under discussion)]]. if the idea is rather large, an own page is usually better and should be created as a child to this page. it still should have an own section that at least must contain a link to the page..
  
==== Why DeltaIndexing ====
+
The initiating authors should edit only their own sections and not those of others.
DeltaIndexing is used to speed up repeated indexing of the same DataSource. DeltaIndexing reflects the state of the DataSource in the index and can so determine if a Record of a DataSource is new, has changed or was deleted. An ID and a HASH-Token (which is build over characteristic data that shows a Record has changed, e.g. last modification date) are used to compute this information. In general as a consequence, less data has to be accessed on the DataSource and only the relevant data is indexed. For each DeltaIndexing run all Records that are new, have changed or have NOT changed are marked with a visited flag. At the end of the run, if no errors have occurred, all Records that have not been visited are computed. These records are the ones that are still in the index but are not available on the DataSource anymore (they were deleted or moved). These are also deleted from the index.
+
  
 +
each subsection/page should state:
 +
* context such as: author, data, based on SVN revision
 +
*  motivation/problem
 +
* a solution proposal
  
 +
ideas that have been implemented are moved to their own page and referenced in [[#Implemented Changes|Implemented Changes]].
  
==== The Problems ====
+
== Ideas  and Problems (under discussion) ==
* One Problem at the moment is, that because SMILA's processing of incoming Records is asynchronous, DeltaIndexing does NOT really reflect the state of a Record in the index, as there is no guarantee that a Record is indexed after it was successfully added to the Queue. This could be achieved by implementing Notifications that update the DeltaIndexing state using this information. If this is done, then the computation of DeltaIndexing-Delete has to wait for all Queue entries to pass the workflow. This is a complex process which seems to be error-prone. Is it really necessary to reflect the index state or is it enough to reflect the last crawl state ?
+
* the API of the ConnectivityManager includes parts of the API of the DeltaIndexingManager, which makes it more complex than necessary. Also it implicates that the ConnectivityManager has an internal state, as DeltaIndexing for a DataSource has to be initialized and finalized. This interfaces forces it's clients to make use of DeltaIndexing and to follow a strict workflow (initialize, add records, optionally call DeltaIndex-Delete and delete the returned IDs, finish). Even if this usage was configurable, the API is - simply spoken - ugly.
+
  
 +
=== DeltaIndexing reflects crawl state rather than index state ===
  
=== New Ideas ===
+
One Problem at the moment is, that because SMILA's processing of incoming Records is asynchronous, DeltaIndexing does NOT really reflect the state of a Record in the index, as there is no guarantee that a Record is indexed after it was successfully added to the Queue. This could be achieved by implementing Notifications that update the DeltaIndexing state using this information. If this is done, then the computation of DeltaIndexing-Delete has to wait for all Queue entries to pass the workflow. This is a complex process which seems to be error-prone. Is it really necessary to reflect the index state or is it enough to reflect the last crawl state ?
  
 
+
=== Extract Session Interface from DeltaIndexingManager ===
 
+
==== Usage of DeltaIndexingManager ====
+
# used by CrawlerController: This approach would not change much of the current programming logic. Only that the CrawlerController would communicate with two references instead of one. <b>This approach was realized</b>
+
 
+
 
+
# used by Crawlers: This is a radical change as this also affects the Crawler interface. Crawlers could directly communicate with the DeltaIndexingManager and provide only those Records that pass DeltaIndexing (are new, nedd an update). CrawlerController and Crawler could implement a Consumer/Producer pattern which should improve performance. No more sending of arrays with DIInformation and thereafter retrieving the Record objects. DeltaIndexing-Delete information is computed in the Crawler and can passed to the CrawlerController as regular Records (only the ID is set) and a delete flag to notify the CrawlerController that this Record is to be deleted. This should reduce communication overhead, as the DIInformation has not to be passed between multiple components and the whole process can work multithreaded. Of course this adds a lot more logic to the Crawler and demands more knowledge from a Crawler developer. It would also mean that ID and HASH are generated in the Crawler. The downside is that each Crawler has to implement the DeltaIndexing workflow themselves. <br>We could even move all execution logic to the Crawler. CrawlerController would become obsolete. Then Crawlers would handle everything themselves - communication with DeltaIndexingManager, CoumpoundHandlers and ConnectivityManager. I think in this way the best performance can be achieved, as the setup is the very simple. No unnecessary passing of data between components. But a lot of logic has to be re-implemented in every Crawler. I wonder if there is a chance to minimize this.
+
 
+
 
+
 
+
== Implemented Changes ==
+
 
+
{{CTable}}
+
| Page || Date || Bug || Author(s)
+
|-
+
| [[SMILA/Specifications/DeltaIndexingAndConnectivtyDiscussion09/Turning_DeltaIndexing_On_or_Off |New Feature: DeltaIndexing On/Off ]] || 2009-06-10 || {{bug|279242}} || DS
+
|-
+
| [[SMILA/Specifications/DeltaIndexingAndConnectivtyDiscussion09/Separate_Interfaces_for_ConnectivityManager_and_DeltaIndexingManager| Separate Interfaces for ConnectivityManager and DeltaIndexingManager  ]] || 2008-06 ? || ? || DS?
+
|}
+
 
+
== Alternative API ==
+
 
For a better separation of tasks and an easy handling of locks on data sources during a delta indexing run, we could introduce the following interfaces. The implementations should only be proxies using the same DeltaIndexingManager service implementation, so that a DeltaIndexingSession may internally use another service if the initial one becomes unavailable.
 
For a better separation of tasks and an easy handling of locks on data sources during a delta indexing run, we could introduce the following interfaces. The implementations should only be proxies using the same DeltaIndexingManager service implementation, so that a DeltaIndexingSession may internally use another service if the initial one becomes unavailable.
  
Line 106: Line 89:
 
<b>This approach was not realized.</b>
 
<b>This approach was not realized.</b>
 
But a sessionId was introduced to distinguish between different sessions without relying on thread ids. See [https://bugs.eclipse.org/bugs/show_bug.cgi?id=279243 https://bugs.eclipse.org/bugs/show_bug.cgi?id=279243]
 
But a sessionId was introduced to distinguish between different sessions without relying on thread ids. See [https://bugs.eclipse.org/bugs/show_bug.cgi?id=279243 https://bugs.eclipse.org/bugs/show_bug.cgi?id=279243]
 +
 +
 +
== Implemented Changes ==
 +
 +
{{CTable}}
 +
| Page || Date || Bug || Author(s)
 +
|-
 +
| [[SMILA/Specifications/DeltaIndexingAndConnectivtyDiscussion09/Turning_DeltaIndexing_On_or_Off |New Feature: DeltaIndexing On/Off ]] || 2009-06-10 || {{bug|279242}} || DS
 +
|-
 +
| [[SMILA/Specifications/DeltaIndexingAndConnectivtyDiscussion09/Separate_Interfaces_for_ConnectivityManager_and_DeltaIndexingManager| Separate Interfaces for ConnectivityManager and DeltaIndexingManager  ]] || 2008-06 ? || ? || DS?
 +
|-
 +
| [[SMILA/Specifications/DeltaIndexingAndConnectivtyDiscussion09/Usage_of_DeltaIndexingManager_by_CrawlerControler_alone|Usage of DeltaIndexingManager by CrawlerControler alone]] || ? || ? || DS?
 +
|}

Revision as of 13:44, 15 October 2009

Contents

Motivation for this page and usage

the current implementation for the DeltaIndexingManager has several problems or short comings which are listed under the section Ideas (under discussion). if the idea is rather large, an own page is usually better and should be created as a child to this page. it still should have an own section that at least must contain a link to the page..

The initiating authors should edit only their own sections and not those of others.

each subsection/page should state:

  • context such as: author, data, based on SVN revision
  • motivation/problem
  • a solution proposal

ideas that have been implemented are moved to their own page and referenced in Implemented Changes.

Ideas and Problems (under discussion)

DeltaIndexing reflects crawl state rather than index state

One Problem at the moment is, that because SMILA's processing of incoming Records is asynchronous, DeltaIndexing does NOT really reflect the state of a Record in the index, as there is no guarantee that a Record is indexed after it was successfully added to the Queue. This could be achieved by implementing Notifications that update the DeltaIndexing state using this information. If this is done, then the computation of DeltaIndexing-Delete has to wait for all Queue entries to pass the workflow. This is a complex process which seems to be error-prone. Is it really necessary to reflect the index state or is it enough to reflect the last crawl state ?

Extract Session Interface from DeltaIndexingManager

For a better separation of tasks and an easy handling of locks on data sources during a delta indexing run, we could introduce the following interfaces. The implementations should only be proxies using the same DeltaIndexingManager service implementation, so that a DeltaIndexingSession may internally use another service if the initial one becomes unavailable.

interface DeltaIndexingManager
{
    /**
     * Initializes a new DeltaIndexingSession if the datasource is not locked.
     */
    DeltaIndexingSession init(String dataSourceID) throws DeltaIndexingException;
 
    /**
     * Clear all data sources that are not locked.
     */
    void clear() throws DeltaIndexingException;
 
    /**
     * Clears the data source if not locked.
     */
    void clear(String dataSourceID) throws DeltaIndexingException;
 
    /**
     * Unlocks all data sources by force.
     */
    void unlockDatasources() throws DeltaIndexingException;
 
    /**
     * Checks if a data source exists.
     */
    boolean exists(String dataSourceId);
}


interface DeltaIndexingSession
{
    /**
     * Checks if the id needs to be updated.
     */
    boolean checkForUpdate(Id id, String hash) throws DeltaIndexingException;
 
    /**
     * Maks the id as visited.
     */
    void visit(Id id, String hash) throws DeltaIndexingException;
 
    /**
     * Returns an iterator over all unvistied ids of the data source
     */
    Iterator<Id> obsoleteIdIterator(String dataSourceID) throws DeltaIndexingException;
 
    /**
     * Returns an iterator over all unvistied ids of a parent id (compound objects)
     */
    Iterator<Id> obsoleteIdIterator(Id id) throws DeltaIndexingException;
 
    /**
     * Deletes the id.
     */
    void delete(Id id) throws DeltaIndexingException;
 
    /**
    * Finishes the deltaindexing run and unlocks the data source.
    */
    void finish(String dataSourceID) throws DeltaIndexingException;
}

This approach was not realized. But a sessionId was introduced to distinguish between different sessions without relying on thread ids. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=279243


Implemented Changes

Page Date Bug Author(s)
New Feature: DeltaIndexing On/Off 2009-06-10 bug 279242 DS
Separate Interfaces for ConnectivityManager and DeltaIndexingManager 2008-06 ?  ? DS?
Usage of DeltaIndexingManager by CrawlerControler alone  ?  ? DS?