Page tree
Skip to end of metadata
Go to start of metadata

EXPERIMENTAL

This feature is experimental. It means that it is not intended for production use. The feature is not finished. It is not stable. The implementation may contain bugs, the configuration may change at any moment without any warning and it may not work at all. Use at your own risk. This feature is not covered by midPoint support. In case that you are interested in supporting development of this feature, please consider purchasing midPoint Platform subscription.

MidPoint 4.3 and later

Until now, the live synchronization task supported only two ways of handling an error:

  1. stop processing, until the error is not fixed;
  2. ignore the error and continue processing.

The former option is safe but can result in unnecessary delays in processing, mainly if errors occurs relatively often. The latter eliminates delays, but results in missing updates and therefore resource ↔ midPoint state inconsistency.

In 4.3 we experimentally implemented a third option: delayed processing of erroneous objects.

It works like this:

  1. An error is encountered during live sync task.
  2. If appropriate configuration is set, the task does not stop processing nor ignores the error. Instead, a trigger is created on the respective resource object shadow, reminding midPoint that the shadow should be re-processed. The time interval for the trigger is configurable and can be e.g. a few hours.
  3. After specified time arrives, the shadow is re-processed.
  4. If the repeated processing is successful, the process ends here. If not, another trigger (with an interval that may be the same or different) is set up, and the process repeats.
  5. If the process is not successful even after specified number of repetitions, the process ends.

An example of configuration:

<task oid="0bdfdb9c-ccae-4202-a060-f9aab35bd211"
    xmlns="http://midpoint.evolveum.com/xml/ns/public/common/common-3"
    xmlns:ext="http://midpoint.evolveum.com/xml/ns/public/model/extension-3"
    xmlns:ri="http://midpoint.evolveum.com/xml/ns/public/resource/instance-3">

    <name>Live Sync</name>

    <extension>
        <ext:objectclass>ri:AccountObjectClass</ext:objectclass>
        <ext:liveSyncErrorHandlingStrategy>
            <entry>
                <reaction>
                    <retryLater>
                        <initialInterval>PT30M</initialInterval>
                        <nextInterval>PT1H</nextInterval>
                    </retryLater>
                    <stopAfter>4</stopAfter>
                </reaction>
            </entry>
        </ext:liveSyncErrorHandlingStrategy>
    </extension>
    ...
</task>

After an error is encountered, the retry is attempted after 30 minutes. The next retries are done after 1 hour. The process stops after 4 attempts.

The configuration is driven by LiveSyncErrorHandlingStrategyType, that consists of one or more entries (LiveSyncErrorHandlingStrategyEntryType). Each entry contains:

  • a situation describing when the entry applies,
  • a reaction that should be applied.

The situation is currently described simply by set of operation statuses: PARTIAL_ERROR, FATAL_ERROR, or both (this is the default).

The reaction is either:

ReactionMeaningActionNote
ignoreError is ignored.The synchronization token is advanced to the next change, effectively ignoring the failed record.
stopThe processing is stopped.The synchronization token is unchanged, or set to the current record. (Depending on resource setup.)This is the default strategy.
retryLaterThe processing is retried later.A trigger is created, as described above.

Besides these options, you can specify also stopAfter property (applicable to ignore and retryLater reactions) that cause the task to be stopped after seeing specified number of error situations. (This option is even more fragile than the other ones. It will be most probably replaced by the thresholds mechanism.)

The retryLater reaction has the following properties:

PropertyMeaningThe default
initialIntervalInitial retry interval.30 minutes
nextInterval"Next" retry interval, after initial attempt.6 hours
retryLimit Maximal number of retries to attempt.unlimited

To conclude, this mechanism is experimental. Most probably it will be replaced by something more general, applicable e.g. to other kinds of synchronization tasks, like import or reconciliation.

  • No labels