Sync4jStrategy


1   /**
2    * Copyright (C) 2003-2005 Funambol
3    *
4    * This program is free software; you can redistribute it and/or modify
5    * it under the terms of the GNU General Public License as published by
6    * the Free Software Foundation; either version 2 of the License, or
7    * (at your option) any later version.
8    *
9    * This program is distributed in the hope that it will be useful,
10   * but WITHOUT ANY WARRANTY; without even the implied warranty of
11   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12   * GNU General Public License for more details.
13   *
14   * You should have received a copy of the GNU General Public License
15   * along with this program; if not, write to the Free Software
16   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17   */
18  package sync4j.server.engine;
19  
20  import java.security.Principal  ;
21  import java.sql.Timestamp  ;
22  import java.util.*;
23  import java.util.logging.Level  ;
24  import java.util.logging.Logger  ;
25  
26  import org.apache.commons.collections.ListUtils;
27  
28  import sync4j.framework.core.Add;
29  import sync4j.framework.core.ModificationCommand;
30  import sync4j.framework.core.StatusCode;
31  import sync4j.framework.engine.*;
32  import sync4j.framework.engine.Util;
33  import sync4j.framework.engine.source.MemorySyncSource;
34  import sync4j.framework.engine.source.ObjectSizeMismatchException;
35  import sync4j.framework.engine.source.SyncSource;
36  import sync4j.framework.engine.source.SyncSourceException;
37  
38  /**
39   * This class represents a synchronization process.
40   *
41   * The base concrete implementation of a synchronization strategy. It implements
42   * the <i>ConcreteStrategy</i> partecipant of the Strategy Pattern.
43   * <p>
44   * The synchronization process is implemented in this class as follows:
45   * <p>
46   * Given a set of sources A, B, C, D, etc, the synchronization process takes place
47   * between two sources at a time: A is first synchronzed with B, then AB with
48   * C, then ABC with D and so on. <br>
49   * The synchronization process is divided in three phases: preparation, synchronization,
50   * finalization. These phases correspond to the methdos prepareSync, sync and
51   * endSync; they are call-back methods called sequentially by a driver object,
52   * usually a SyncMethod object. In this way the SyncMethod object has a chance
53   * to communicate with the external world before carry on the process.
54   * For example a SyncMethod object can show to the user the items that are going
55   * to be synchronized, so that the user can let the process carry on or stop it. <br>
56   * prepareSync returns an array of SyncOperation, in which each element represents
57   * a particular synchronization action, ie. create an item in the source A,
58   * delete the item X from the source B, etc. Sometime it is not possible decide
59   * what to do, thus a SyncConflict operation is used. A conflict must be solved
60   * by something external the synchronization process, for instance by a user
61   * action. Below is a table of all possible situations.
62   * <pre>
63   *
64   * | -------- | --- | --- | --- | --- | --- |
65   * | Source A |     |     |     |     |     |
66   * |    /     |  N  |  D  |  U  |  S  |  X  |     N : item new
67   * | Source B |     |     |     |     |     |     D : item deleted
68   * | -------- | --- | --- | --- | --- | --- |     U : item updated
69   * |       N  |  O  |  O  |  O  |  O  |  B  |     S : item synchronized/unchanged
70   * | -------- | --- | --- | --- | --- | --- |     X : item not existing
71   * |       D  |  O  |  X  |  O  |  X  |  X  |     O : conflict
72   * | -------- | --- | --- | --- | --- | --- |     A : item A replaces item B
73   * |       U  |  O  |  O  |  O  |  B  |  B  |     B : item B replaces item A
74   * | -------- | --- | --- | --- | --- | --- |
75   * |       S  |  O  |  X  |  A  |  =  |  B  |
76   * | -------- | --- | --- | --- | --- | --- |
77   * |       X  |  A  |  X  |  A  |  A  |  X  |
78   * | -------- | --- | --- | --- | --- | --- |
79   *
80   * </pre>
81   *
82   * @author Stefano Fornari @ Funambol
83   *
84   * @version  $Id: Sync4jStrategy.java,v 1.43 2005/07/13 19:26:51 luigiafassina Exp $
85   */
86  public class Sync4jStrategy implements SyncStrategy, java.io.Serializable   {
87  
88      // --------------------------------------------------------------- Constants
89  
90      public static String   LOG_NAME = "sync4j.framework.engine";
91  
92      private transient static Logger   log = Logger.getLogger(LOG_NAME);
93  
94      // -------------------------------------------------------------- Properties
95  
96      /**
97       * The synchronization source
98       */
99      private transient SyncSource[] sources = null;
100     public SyncSource[] getSources(){ return sources; }
101 
102     public void setSources(SyncSource[] sources){ this.sources = sources; }
103 
104     /**
105      * The process' name
106      */
107     public String   getName(){ return name; }
108 
109     private String   name;
110     public void setName(String   name){ this.name = name; }
111 
112     // ------------------------------------------------------------ Private data
113     
114     //
115     // NOTE: server modification MUST be detected and stored at the beginning of
116     // the sync process (i.e. in the first modification message), otherwise in
117     // the case of multi message, likely the server will detect items modified
118     // by the current sync as server modifications.
119     // Reading server modifications at the synchronization start does not
120     // loose items since. Let's suppose we have the following events axis:
121     //
122     //  s1            e1    s2              e2             s3          e3
123     //  |-------------|....|---------------|...............|-----------|
124     //
125     // where s<x> is the beginning of a sync and e<x> represents its end.
126     // In s2 we collect all modified items since s1; if any other process 
127     // modifies an item after s2, it won't be detected during the second 
128     // synchronization. However, it will be detected at s3, where we collect all
129     // modified items since s2.
130     //
131     private HashMap newBAll;
132     private HashMap updatedBAll;
133     private HashMap deletedBAll;
134 
135     // ------------------------------------------------------------ Constructors
136 
137     public Sync4jStrategy() {
138         newBAll     = new HashMap();
139         updatedBAll = new HashMap();
140         deletedBAll = new HashMap();
141     }
142 
143     public Sync4jStrategy(SyncSource[] syncSources) {
144         this();
145         sources = syncSources;
146     }
147 
148     // ---------------------------------------------------------- Public methods
149 
150     /**
151      * Preparation for the synchronization. If <i>sources</i> is not null,
152      * the preparation works on the given sources. Otherwise it works on the
153      * sources as they were set in the constructor.
154      * Note that in the case of slow sync, the sync analysis to determine the
155      * new items on the server that must be returned to the client, we need to
156      * wait for the last call to this method. This is used for protocols that
157      * supports a multi message session. At the contrary, client side
158      * modifications can be processed immediately.
159      *
160      *
161      * @param sources the sources to be synchronized
162      * @param nextSync the timestamp of the beginning of this synchronization
163      * @param principal the entity for which the synchronization is required
164      * @param last is this the last call to prepareSlowSync ?
165      *
166      * @return an array of SyncOperation, one for each SyncItem that must be
167      *         created/updated/deleted or in conflict.
168      *
169      * @see sync4j.framework.engine.SyncStrategy
170      */
171     public SyncOperation[] prepareSlowSync(SyncSource[] sources  ,
172                                            Principal      principal,
173                                            Timestamp      nextSync ,
174                                            boolean      last     )
175     throws SyncException {
176 
177         if (sources != null) {
178             this.sources = sources;
179         }
180 
181         SyncItem[] Am, Bm;
182         List syncOperations = new ArrayList();
183 
184         Logger   log = Logger.getLogger(LOG_NAME);
185 
186         if (log.isLoggable(Level.INFO)) {
187             log.info( "Preparing slow synchronization of source '"
188                     + sources[1].getSourceURI()
189                     + "' for "
190                     + principal
191                     + " ..."
192                     );
193             if (last) {
194                 log.info("Last call");
195             } else {
196                 log.info("Not the last call");
197             }
198         }
199 
200         //
201         // First process the items provided by the client
202         //
203         Am = sources[1].getUpdatedSyncItems(principal, null);
204         Bm = sources[0].getAllSyncItems(principal);
205 
206         //
207         // Just in case...
208         //
209         if (Am == null) {
210             Am = new SyncItem[0];
211         }
212 
213         if (Bm == null) {
214             Bm = new SyncItem[0];
215         }
216 
217         //
218         // If any item from the client has not a corresponding mapping, the
219         // server source must be queried for the item, since the client item
220         // could be the same of an existing server item. In this case, the old
221         // unmapped item is replaced in Map by the newly mapped item.
222         //
223         ArrayList newlyMappedItems = new ArrayList();
224         fixMappedItems(newlyMappedItems, Am, sources[0], principal);
225 
226         //
227         // Because it is a slow sync, items state must be reset to S
228         //
229         EngineHelper.resetState(Am);
230         EngineHelper.resetState(Bm);
231 
232         for (int i=0; i<Am.length; ++i) {
233             if (!Am[i].isMapped()) {
234                 syncOperations.add(checkSyncOperation(principal, nextSync, Am[i], null));
235             }
236         }
237 
238         Iterator j = newlyMappedItems.iterator();
239         while (j.hasNext()) {
240             SyncItemMapping m = (SyncItemMapping)j.next();
241             m.getSyncItemA().setState(SyncItemState.SYNCHRONIZED);
242             m.getSyncItemB().setState(SyncItemState.SYNCHRONIZED);
243             syncOperations.add(checkSyncOperation(principal, nextSync, m.getSyncItemA(), m.getSyncItemB()));
244         }
245 
246         //
247         // If it is the last call, we have also to consider what is in source
248         // B but not in A
249         //
250         if (last) {
251             //
252             // In this case getAllSyncItems() returns the items in the datastore
253             // reconstructed from the GUID-LUID mapping. In addition to these
254             // items we have the ones sent in the last message (retrieved
255             // calling getUpdatedSyncItems().
256             //
257             EngineHelper.resetState(Am);
258 
259             List all = new ArrayList(Arrays.asList(sources[1].getAllSyncItems(principal)));
260             all.addAll(Arrays.asList(Am));
261 
262             for (int i=0; i<Bm.length; ++i) {
263                 if (!(all.contains(Bm[i]))) {
264                     syncOperations.add(checkSyncOperation(principal, nextSync, null, Bm[i]));
265                 }
266             }
267         }
268 
269         if (log.isLoggable(Level.FINEST)) {
270             log.finest("operations: " + syncOperations);
271         }
272 
273         if (log.isLoggable(Level.INFO)) {
274             log.info("Preparation completed.");
275         }
276 
277         return (SyncOperation[])syncOperations.toArray(new SyncOperationImpl[] {});
278     }
279 
280     /**
281      * Preparation for faset synchronization. If <i>sources</i> is not null,
282      * the preparation operates on the given sources. Otherwise it works on the
283      * sources as they were set in the constructor.
284      * <p>
285      * Refer to the <a HREF="http://sync4j.sourceforge.net/web/project/architecture/sync4j-architecture.html">
286      * architecture document</a> for details about the algoritm applied.
287      *
288      * @param sources the sources to be synchronized
289      * @param principal the entity for which the synchronization is required
290      * @param lastSync timestamp of the last synchronization
291      * @param nextSync timestamp of the current synchronization
292      * @param last is this the last call to prepareFastSync ?
293      *
294      * @return an array of SyncOperation, one for each SyncItem that must be
295      *         created/updated/deleted or in conflict.
296      *
297      * @see sync4j.framework.engine.SyncStrategy
298      */
299     public SyncOperation[] prepareFastSync(SyncSource[] sources  ,
300                                            Principal      principal,
301                                            Timestamp      lastSync ,
302                                            Timestamp      nextSync ,
303                                            boolean      last     )
304     throws SyncException {
305         if (sources != null) {
306             this.sources = sources;
307         }
308 
309         // ---------------------------------------------------------------------
310 
311         List Am    ,  // items modified in A
312              Bm    ,  // items modified in B
313              AmBm  ,  // Am intersect Bm
314              AAmBm ,  // items unmodified in A, but modified in B
315              AmBBm ;  // items unmodified in B, but modified in A
316 
317         ArrayList syncOperations = null;
318 
319         SyncItem[] newA     = null, newB     = null,
320                    updatedA = null, updatedB = null,
321                    deletedA = null, deletedB = null;
322 
323         if (log.isLoggable(Level.INFO)) {
324             log.info( "Preparing fast synchronization of source '"
325                     + sources[1].getSourceURI()
326                     + "' for "
327                     + principal
328                     + " since "
329                     + lastSync
330                     + "..."
331                     );
332 
333             if (last) {
334                 log.info("Last call");
335             } else {
336                 log.info("Not the last call");
337             }
338         }
339 
340         // ---------------------------------------------------------------------
341 
342         //
343         // NOTE: simplified version - only two sources, the first one of which
344         // is the client
345         //
346         newA       = sources[1].getNewSyncItems      (principal, lastSync);
347         updatedA   = sources[1].getUpdatedSyncItems  (principal, lastSync);
348         deletedA   = sources[1].getDeletedSyncItems  (principal, lastSync);
349 
350         if (log.isLoggable(Level.FINEST)) {
351             log.finest("newA: " + Util.arrayToString(newA));
352             log.finest("updatedA: " + Util.arrayToString(updatedA));
353             log.finest("deletedA: " + Util.arrayToString(deletedA));
354         }
355 
356         String   uri = sources[0].getSourceURI();
357         if (newBAll.get(uri) == null) {
358             if (log.isLoggable(Level.FINEST)) {
359                 log.finest("Detecting server changes...");
360             }
361             newB       = sources[0].getNewSyncItems      (principal, lastSync);
362             updatedB   = sources[0].getUpdatedSyncItems  (principal, lastSync);
363             deletedB   = sources[0].getDeletedSyncItems  (principal, lastSync);
364 
365             //
366             // The SyncSource should return empty arrays... but just in case...
367             //
368             if (newB == null) {
369                 newB = new SyncItemImpl[0];
370             }
371             if (updatedB == null) {
372                 updatedB = new SyncItemImpl[0];
373             }
374             if (deletedB == null) {
375                 deletedB = new SyncItemImpl[0];
376             }
377 
378             if (log.isLoggable(Level.FINEST)) {
379                 log.finest("newB: " + Util.arrayToString(newB));
380                 log.finest("updatedB: " + Util.arrayToString(updatedB));
381                 log.finest("deletedB: " + Util.arrayToString(deletedB));
382             }
383             
384             newBAll    .put(uri, newB);
385             updatedBAll.put(uri, updatedB);
386             deletedBAll.put(uri, deletedB);
387         } else {
388             newB     = (SyncItem[])newBAll    .get(uri);
389             updatedB = (SyncItem[])updatedBAll.get(uri);
390             deletedB = (SyncItem[])deletedBAll.get(uri);
391         }
392 
393         //
394         // If any item from the client has not a corresponding mapping, the
395         // server source must be queried for the item, since the client item
396         // could be the same of an existing server item. In this case,  the old
397         // unmapped item is replaced by the newly mapped item.
398         //
399         ArrayList newlyMappedItems = new ArrayList();
400 
401         fixMappedItems(newlyMappedItems, newA,     sources[0], principal);
402         fixMappedItems(newlyMappedItems, updatedA, sources[0], principal);
403         fixMappedItems(newlyMappedItems, deletedA, sources[0], principal);
404 
405         if (log.isLoggable(Level.FINEST)) {
406             log.finest("Newly mapped items: " + newlyMappedItems);
407         }
408 
409         Am = new ArrayList(); Bm = new ArrayList();
410         Am.addAll(Arrays.asList(newA      ));
411         Am.addAll(Arrays.asList(updatedA  ));
412         Am.addAll(Arrays.asList(deletedA  ));
413         Bm.addAll(Arrays.asList(newB      ));
414         Bm.addAll(Arrays.asList(updatedB  ));
415         Bm.addAll(Arrays.asList(deletedB  ));
416 
417         if (log.isLoggable(Level.FINEST)) {
418             log.finest("Am: " + Am);
419             log.finest("Bm: " + Bm);
420             log.finest("Am-Bm: " + ListUtils.subtract(Am, Bm));
421             log.finest("Bm-Am: " + ListUtils.subtract(Bm, Am));
422         }
423 
424         //
425         // Now calculate subsets: AmBm, AmBBm, AAmBm.
426         // Note that Bm and AAmBm must be calculated only when we got the
427         // last message. For the others, it must be empty. At the contrary,
428         //
429         AmBm  = EngineHelper.intersect(Am, Bm);
430         AmBBm = EngineHelper.buildAmBBm(ListUtils.subtract(Am, Bm), sources[0], principal);
431 
432         AAmBm = new ArrayList();
433         if (last) {
434             //
435             // NOte: being this class a concrete SyncStrategy implementation for
436             // Sync4j we know already that sources[1] is a MemorySyncSource.
437             //
438             newA       = ((MemorySyncSource)sources[1]).getAllNewSyncItems      (principal, lastSync);
439             updatedA   = ((MemorySyncSource)sources[1]).getAllUpdatedSyncItems  (principal, lastSync);
440             deletedA   = ((MemorySyncSource)sources[1]).getAllDeletedSyncItems  (principal, lastSync);
441 
442             AAmBm = EngineHelper.buildAAmBm(ListUtils.subtract(Bm, Am), sources[1], principal);
443         } else {
444             Bm.clear();
445         }
446 
447         if (log.isLoggable(Level.FINEST)) {
448             log.finest("AmBm:  " + AmBm );
449             log.finest("AmBBm: " + AmBBm);
450             log.finest("AAmBm: " + AAmBm);
451         }
452 
453         //
454         // Ready for conflict detection!
455         //
456         syncOperations =
457             checkSyncOperations(principal, nextSync, Am, Bm, AmBm, AmBBm, AAmBm);
458 
459         if (log.isLoggable(Level.FINEST)) {
460             log.finest("operations: " + syncOperations);
461         }
462 
463         if (log.isLoggable(Level.INFO)) {
464             log.info("Preparation completed.");
465         }
466 
467         return (SyncOperation[])syncOperations.toArray(new SyncOperationImpl[] {});
468     }
469 
470     /**
471      * Implements Synchronizable.sync
472      *
473      *
474      */
475     public SyncOperationStatus[] sync(SyncOperation[] syncOperations) {
476         Logger   log = Logger.getLogger(LOG_NAME);
477 
478         if (log.isLoggable(Level.INFO)) {
479             log.info("Synchronizing...");
480         }
481 
482         if ((syncOperations == null) || (syncOperations.length == 0)) {
483             return new SyncOperationStatus[0];
484         }
485 
486         ArrayList status = new ArrayList();
487 
488         SyncOperationStatus[] operationStatus = null;
489         for(int i=0; i<syncOperations.length; ++i) {
490             if (log.isLoggable(Level.FINEST)) {
491                 log.finest("Executing " + syncOperations[i]);
492             }
493 
494             //
495             // execSyncOperation can return more than one status for one
496             // operation when more than one source are involved
497             //
498             operationStatus = execSyncOperation((SyncOperationImpl)syncOperations[i]);
499 
500             for (int j=0; j<operationStatus.length; ++j) {
501                 status.add(operationStatus[j]);
502             }  // next j
503         } // next i
504 
505         if (log.isLoggable(Level.FINEST)) {
506             log.finest("status: " + status);
507         }
508 
509         return (SyncOperationStatus[])status.toArray(new SyncOperationStatus[0]);
510     }
511 
512     /**
513      * Implements Synchronizable.endSync
514      *
515      * @see beanblue.sync.event.Synchronizable
516      */
517     public void endSync() throws SyncException {
518         Logger   log = Logger.getLogger(LOG_NAME);
519 
520         if (log.isLoggable(Level.INFO)) {
521             log.info("Synchronization completed.");
522         }
523     }
524 
525     // -------------------------------------------------------- Protected methds
526 
527     /**
528      * Checks the given SyncItem lists and creates the needed SyncOperations
529      * following the rules described in the class description and in the
530      * architecture document.
531      *
532      * @param principal who has requested the synchronization
533      * @param nextSync timestamp of the current synchronization
534      * @param Am the Am set
535      * @param Bm the Bm set
536      * @param AmBm the AmBm
537      * @param AmBBm the AmBBm
538      * @param AAmBm the AAmBm
539      *
540      * @return an ArrayList containing all the collected sync operations
541      */
542     protected ArrayList checkSyncOperations(Principal   principal,
543                                             Timestamp   nextSync ,
544                                             List      Am       ,
545                                             List      Bm       ,
546                                             List      AmBm     ,
547                                             List      AmBBm    ,
548                                             List      AAmBm    ) {
549         SyncItemMapping mapping = null;
550         SyncItem syncItemA = null, syncItemB = null;
551 
552         ArrayList all        = new ArrayList();
553         ArrayList operations = new ArrayList();
554 
555         // ---------------------------------------------------------------------
556 
557         all.addAll(AmBm );
558         all.addAll(AmBBm);
559         all.addAll(AAmBm);
560 
561         //
562         // 1st check: items in both sources
563         //
564         Iterator i = all.iterator();
565         while (i.hasNext()) {
566             mapping = (SyncItemMapping)i.next();
567 
568             syncItemA = mapping.getSyncItemA();
569             syncItemB = mapping.getSyncItemB();
570 
571             operations.add(
572                 checkSyncOperation(
573                     principal,
574                     nextSync ,
575                     syncItemA,
576                     syncItemB
577                 )
578             );
579             Am.remove(syncItemA);
580             Bm.remove(syncItemB);
581         }
582 
583         //
584         // 2nd check: items in source A and not in source B
585         //
586         i = Am.iterator();
587         while (i.hasNext()) {
588            syncItemA = (SyncItem)i.next();
589 
590            operations.add(checkSyncOperation(principal, nextSync, syncItemA, null));
591         }  // next i
592 
593         //
594         // 3rd check: items in source B and not in source A
595         //
596         i = Bm.iterator();
597         while (i.hasNext()) {
598            syncItemB = (SyncItem)i.next();
599 
600            operations.add(checkSyncOperation(principal, nextSync, null, syncItemB));
601         }  // next i
602 
603         return operations;
604     }
605 
606     /**
607      * Create a SyncOperation based on the state of the given SyncItem couple.
608      *
609      * @param principal     the entity that wnats to do the operation
610      * @param nextSync      timestamp of the current synchronization (used for "B" operation)
611      * @param syncItemA     the SyncItem of the source A - NULL means <i>not existing</i/
612      * @param syncItemB     the SyncItem of the source B - NULL means <i>not existing</i/
613      *
614      * @return the SyncOperation object
615      */
616     protected SyncOperation checkSyncOperation(Principal   principal,
617                                                Timestamp   nextSync    ,
618                                                SyncItem  syncItemA,
619                                                SyncItem  syncItemB) {
620         if (log.isLoggable(Level.FINEST)) {
621             log.finest( "check: syncItemA: "
622                     + syncItemA
623                     + " syncItemB: "
624                     + syncItemB
625                     );
626         }
627 
628         if (syncItemA == null) {
629             syncItemA = SyncItemImpl.getNotExistingSyncItem(null);
630         }
631         if (syncItemB == null) {
632             syncItemB = SyncItemImpl.getNotExistingSyncItem(null);
633         }
634 
635         switch (syncItemA.getState()) {
636             //
637             // NEW
638             //
639             case SyncItemState.NEW:
640                 switch (syncItemB.getState()) {
641                     case SyncItemState.NEW:
642                         return new SyncConflict(syncItemA, syncItemB,
643                                                 String.valueOf(SyncItemState.NEW) +
644                                                 String.valueOf(SyncItemState.NEW) );
645                     case SyncItemState.UPDATED:
646                         return new SyncConflict(syncItemA, syncItemB,
647                                                 String.valueOf(SyncItemState.NEW)     +
648                                                 String.valueOf(SyncItemState.UPDATED) );
649                    case SyncItemState.DELETED:
650                        return new SyncConflict(syncItemA, syncItemB,
651                                                 String.valueOf(SyncItemState.NEW)     +
652                                                 String.valueOf(SyncItemState.DELETED) );
653                    case SyncItemState.SYNCHRONIZED:
654                        return new SyncConflict(syncItemA, syncItemB,
655                                                 String.valueOf(SyncItemState.NEW)       +
656                                                 String.valueOf(SyncItemState.SYNCHRONIZED) );
657                    case SyncItemState.NOT_EXISTING:
658                        syncItemA.setPropertyValue(syncItemB.PROPERTY_TIMESTAMP, nextSync);
659                        return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.NEW, false, true);
660                 }  // end inner switch
661 
662             //
663             // DELETED
664             //
665             case SyncItemState.DELETED:
666                 switch (syncItemB.getState()) {
667                     case SyncItemState.NEW:
668                         return new SyncConflict(syncItemA, syncItemB,
669                                                 String.valueOf(SyncItemState.DELETED) +
670                                                 String.valueOf(SyncItemState.NEW)     );
671                     case SyncItemState.UPDATED:
672                         syncItemB.setState(SyncItemState.NEW);
673                         return new SyncConflict(syncItemA, syncItemB,
674                                                 String.valueOf(SyncItemState.DELETED) +
675                                                 String.valueOf(SyncItemState.NEW)     );
676                    case SyncItemState.SYNCHRONIZED:
677                         return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.DELETE, false, true);
678 
679                    case SyncItemState.DELETED:
680                    case SyncItemState.NOT_EXISTING:
681                         return new SyncOperationImpl(principal, syncItemB, syncItemA, SyncOperation.NOP, false, false);
682                 }  // end inner switch
683 
684             //
685             // UPDATED
686             //
687             case SyncItemState.UPDATED:
688                 switch (syncItemB.getState()) {
689                     case SyncItemState.NEW:
690                         return new SyncConflict(syncItemA, syncItemB,
691                                                 String.valueOf(SyncItemState.UPDATED) +
692                                                 String.valueOf(SyncItemState.NEW)     );
693                     case SyncItemState.UPDATED:
694                         return new SyncConflict(syncItemA, syncItemB,
695                                                 String.valueOf(SyncItemState.UPDATED) +
696                                                 String.valueOf(SyncItemState.UPDATED) );
697                     case SyncItemState.DELETED:
698                         return new SyncConflict(syncItemA, syncItemB,
699                                                 String.valueOf(SyncItemState.UPDATED) +
700                                                 String.valueOf(SyncItemState.DELETED) );
701                     case SyncItemState.SYNCHRONIZED:
702                         syncItemA.setPropertyValue(syncItemB.PROPERTY_TIMESTAMP, nextSync);
703                         return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.UPDATE, false, true);
704                     case SyncItemState.NOT_EXISTING:
705                         syncItemA.setPropertyValue(syncItemB.PROPERTY_TIMESTAMP, nextSync);
706                         return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.NEW, false, true);
707                 }  // end inner switch
708 
709            //
710            // SYNCHRONIZED
711            //
712            case SyncItemState.SYNCHRONIZED:
713                 switch (syncItemB.getState()) {
714                     case SyncItemState.NEW:
715                         return new SyncConflict(syncItemA, syncItemB,
716                                                 String.valueOf(SyncItemState.SYNCHRONIZED) +
717                                                 String.valueOf(SyncItemState.NEW)       );
718                     case SyncItemState.UPDATED:
719                         return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.UPDATE, true, false);
720                     case SyncItemState.DELETED:
721                         return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.DELETE, true, false);
722                     case SyncItemState.SYNCHRONIZED:
723                         return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.NOP, false, false);
724                     case SyncItemState.NOT_EXISTING:
725                         return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.NEW, false, true);
726                 }  // end inner switch
727 
728            //
729            // NOTEXISITNG
730            //
731            case SyncItemState.NOT_EXISTING:
732                 switch (syncItemB.getState()) {
733                     case SyncItemState.NEW:
734                     case SyncItemState.UPDATED:
735                         return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.NEW, true, false);
736                     case SyncItemState.SYNCHRONIZED:
737                         return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.NEW, true, false);
738                     case SyncItemState.NOT_EXISTING:
739                     case SyncItemState.DELETED:
740                         return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.NOP, false, false);
741                 }  // end inner switch
742 
743            //
744            // PARTIAL
745            //
746            case SyncItemState.PARTIAL:
747                 switch (syncItemB.getState()) {
748                     case SyncItemState.NEW:
749                         return new SyncConflict(syncItemA, syncItemB,
750                                                 String.valueOf(SyncItemState.UPDATED) +
751                                                 String.valueOf(SyncItemState.NEW)     );
752                     case SyncItemState.UPDATED:
753                         return new SyncConflict(syncItemA, syncItemB,
754                                                 String.valueOf(SyncItemState.UPDATED) +
755                                                 String.valueOf(SyncItemState.UPDATED) );
756                     case SyncItemState.DELETED:
757                         return new SyncConflict(syncItemA, syncItemB,
758                                                 String.valueOf(SyncItemState.UPDATED) +
759                                                 String.valueOf(SyncItemState.DELETED) );
760                     case SyncItemState.SYNCHRONIZED:
761                         return new SyncOperationImpl(principal, syncItemA, null, SyncOperation.ACCEPT_CHUNK, false, true);
762                     case SyncItemState.NOT_EXISTING:
763                         return new SyncOperationImpl(principal, syncItemA, null, SyncOperation.ACCEPT_CHUNK, false, true);
764                 }  // end inner switch
765 
766             //
767             // CONFLICT
768             // In this case itemA has a mapped twin and itemB not existing
769             //
770             case SyncItemState.CONFLICT:
771                 return new SyncConflict(syncItemA, syncItemB, "CX");
772         }  // end switch
773 
774         return new SyncOperationImpl(principal, syncItemA, syncItemB, SyncOperation.NOP, false, false);
775     }
776 
777     /**
778      * Executes the given SyncOperation. Note that conflicts are ignored!
779      * <p>
780      * Note also that the number of status returned is equal to the number of
781      * sources affected by the operation (0 for NOP, 1 for NEW and UPDATE and
782      * 1 or 2 for DELETE).
783      *
784      * @param operation     the SyncOperation to execute
785      *
786      * @return an array of <i>SyncOperationStatus</i> objects representing the
787      *         status of the executed operation. For instance, in case of error,
788      *         <i>SyncOperation.error</i> will be set to the catched exception.
789      */
790     protected SyncOperationStatus[] execSyncOperation(SyncOperationImpl operation) {
791         SyncItem syncItemA = operation.getSyncItemA(),
792                  syncItemB = operation.getSyncItemB();
793 
794         Principal   owner = operation.getOwner();
795         SyncOperationStatus[] status = null;
796         ModificationCommand cmd = null;
797 
798         int size = 0, s = 0;
799 
800         switch (operation.getOperation()) {
801             case SyncOperation.NEW:
802                 status = new SyncOperationStatus[1];
803                 if (operation.isAOperation()) {
804                     cmd = (ModificationCommand)syncItemA.getPropertyValue(SyncItemHelper.PROPERTY_COMMAND);
805                     try {
806                         syncItemA = sources[1].setSyncItem(owner, syncItemB);
807                         operation.setSyncItemA(syncItemA);