Main Page | Packages | Class Hierarchy | Class List | Directories | File List | Class Members | Related Pages

OpenMSPSynchroManager.java

00001 /*
00002  * OpenMobileIS - a free Java(TM) Framework for mobile applications Java(TM)
00003  * Copyright (C) 2004-2006 Philippe Delrieu
00004  * All rights reserved.
00005  * Contact: pdelrieu@openmobileis.org
00006  *
00007  * This library is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or any later version.
00011  *
00012  * This library is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with this library; if not, write to the Free Software
00019  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
00020  * USA
00021  *
00022  *  Author : Philippe Delrieu
00023  * 
00024  */
00025 
00026 package org.openmobileis.synchro.openmsp.client;
00027 
00028 import java.io.ByteArrayOutputStream;
00029 import java.io.IOException;
00030 import java.util.zip.GZIPOutputStream;
00031 
00032 import org.openmobileis.common.context.ApplicationContextManager;
00033 import org.openmobileis.common.context.Plateform;
00034 import org.openmobileis.common.intl.IntlResourceManager;
00035 import org.openmobileis.common.user.UserNotFoundException;
00036 import org.openmobileis.common.util.PropertiesManager;
00037 import org.openmobileis.common.util.PersistentPropertiesManager;
00038 import org.openmobileis.common.util.codec.GeneralCoder;
00039 import org.openmobileis.common.util.collection.Array;
00040 import org.openmobileis.common.util.exception.SynchroException;
00041 import org.openmobileis.database.fastobjectdb.synchro.client.SynchroListenerAddNotifier;
00042 import org.openmobileis.synchro.client.SynchroDescriptor;
00043 import org.openmobileis.synchro.client.SynchroProcessor;
00044 import org.openmobileis.synchro.openmsp.OpenMSPException;
00045 import org.openmobileis.synchro.openmsp.client.conduit.ConduitParameter;
00046 import org.openmobileis.synchro.openmsp.client.core.ListenerOrdonancer;
00047 import org.openmobileis.synchro.openmsp.client.core.OpenMSPSyncMessageFactory;
00048 import org.openmobileis.synchro.openmsp.protocol.Message;
00049 import org.openmobileis.synchro.openmsp.protocol.MessageFactory;
00050 import org.openmobileis.synchro.openmsp.protocol.Status;
00051 import org.openmobileis.synchro.security.auth.Credential;
00052 
00060 public class OpenMSPSynchroManager implements SynchroProcessor {
00061   public static final String OPENMSPPROCESSORNAME="OpenMSPSync";
00062 
00063   private static OpenMSPSynchroManager manager;
00064   private ListenerOrdonancer ordonancer;
00065   private OpenMSPSyncMessageFactory messageFactory;
00066   private String lastSynchroLogin;
00067   private int globalSynchroStatut;
00068   private SynchroListenerAddNotifier addlistener;
00069 
00073   private OpenMSPSynchroManager() {
00074     super();
00075     this.ordonancer = new ListenerOrdonancer();
00076     this.messageFactory = new OpenMSPSyncMessageFactory();
00077   }
00078 
00079   public static OpenMSPSynchroManager getManager() {
00080     if (manager == null)  {
00081       synchronized (OpenMSPSynchroManager.class) {
00082         if (manager == null)  {
00083           manager = new OpenMSPSynchroManager();
00084           ApplicationContextManager.getManager().addManager(manager);
00085         }
00086       }
00087     }
00088     return manager;
00089   }
00090  
00091   public String getProcessorName()  {
00092     return OpenMSPSynchroManager.OPENMSPPROCESSORNAME;   
00093   }
00094 
00095   public void notifyFailure(String listernerName) {
00096     OpenMSPSyncListener listener = this.getListenerByName(listernerName);
00097     if (listener != null) {
00098       listener.notifySynchroFailure();
00099       ordonancer.notifySynchroError(listener.getSyncName());
00100     }
00101     globalSynchroStatut = Status.STATUS_FAILED;
00102   }
00103   
00104   public OpenMSPSyncListener getListenerByName(String listenerName) {
00105     return ordonancer.getListenerByName(listenerName);
00106   }
00107   
00108   public void doSynchro(Credential cred, SynchroDescriptor descriptor) throws SynchroException {
00109     globalSynchroStatut = Status.STATUS_SYNC_IN_PROGRESS;
00110     this.lastSynchroLogin = cred.getPrincipal();
00111     //save login
00112     PersistentPropertiesManager.getManager().saveProperty("OpenMSPSynchroManager", "login", this.lastSynchroLogin);
00113     this.ordonancer.beginSynchro();
00114     this.messageFactory.beginSynchro(cred, descriptor);
00115     Array listenerList = this.ordonancer.getNextListenerList();
00116     try {
00117       while (listenerList.size() != 0)  {
00118         int listsize = listenerList.size();
00119         for (int i=0; i<listsize; i++)  {
00120           OpenMSPSyncListener listener = (OpenMSPSyncListener) listenerList.get(i);
00121           listener.startSync(cred, descriptor);
00122         }
00123         while (true) {
00124           Message message = this.messageFactory.getOpenMSPMessage(listenerList);
00125           if (message.isEmpty()) {
00126             //get next listener phase.
00127             break;
00128           }
00129           String xmlString = message.encode();
00130           ConduitParameter[] parameters = new ConduitParameter[] {new ConduitParameter("openMISGroup", descriptor.getSynchroGroup())};
00131  
00132           String reqResult = descriptor.getSynchroConduit().sendRequest(parameters, new String(compressAndEncodeRequest(xmlString)), descriptor.getServerURL());
00133           // third step : Process responses
00134           Message receivedMessage = MessageFactory.getFactory().getMessage(reqResult);
00135           String target = receivedMessage.getHeader().getTarget();
00136           if (!target.equals(OpenMSPSyncMessageFactory.OpenMSPSOURCE)) {
00137             throw new OpenMSPException("Bad OpenMSP Sync Source in Server answer message. Synchro Abort.");
00138           } else {
00139             this.messageFactory.receiveOpenMSPMessage(listenerList, receivedMessage);
00140           }
00141         }
00142         for (int i=0; i<listsize; i++)  {
00143           OpenMSPSyncListener listener = (OpenMSPSyncListener) listenerList.get(i);
00144           listener.endSync();
00145         }
00146         listenerList = this.ordonancer.getNextListenerList();
00147       }
00148       globalSynchroStatut = Status.STATUS_OK;
00149     } catch (UserNotFoundException ex)  {
00150       notifyFailureToListeners(listenerList);
00151       globalSynchroStatut = Status.STATUS_UNAUTHORIZED;
00152       throw new OpenMSPException(ex);
00153     } catch (Throwable ex)  {
00154       notifyFailureToListeners(listenerList);
00155       throw new OpenMSPException(ex);
00156     } finally {
00157       this.ordonancer.endSynchro();
00158       this.messageFactory.endSynchro();      
00159     }
00160   }
00161   
00165   public void registerSynchroListenerAddNotifier(SynchroListenerAddNotifier listener) {
00166     addlistener = listener;
00167   }
00168   
00177   public void addListener(OpenMSPSyncListener listener, String[] depends) {
00178     if (addlistener != null) {
00179       addlistener.notifyAddListener(listener, depends);
00180       if (!addlistener.isBlocking()) ordonancer.addListener(listener, depends);
00181     } else  {
00182       ordonancer.addListener(listener, depends);
00183     }
00184   }
00185   
00186   private void notifyFailureToListeners(Array listenerList) {
00187     for (int i=0; i<listenerList.size(); i++) {
00188       OpenMSPSyncListener listener = (OpenMSPSyncListener)listenerList.get(i);
00189       listener.notifySynchroFailure();
00190       ordonancer.notifySynchroError(listener.getSyncName());
00191     }
00192     globalSynchroStatut = Status.STATUS_FAILED;   
00193   }
00194 
00195   private byte[] compressAndEncodeRequest(String request) throws IOException {
00196     // compresse data
00197     byte[] compressedData = null;
00198     ByteArrayOutputStream byteStream = new ByteArrayOutputStream(512);
00199     GZIPOutputStream zipStream = new GZIPOutputStream(byteStream);
00200     try {
00201       zipStream.write(request.getBytes());
00202     } finally  {
00203       zipStream.close();
00204     }
00205     compressedData = byteStream.toByteArray();
00206 
00207     // encode compressed data
00208     byte[] returnData = GeneralCoder.encodeBase64(compressedData);
00209     return returnData;
00210   }
00211 
00212   public String getLastSynchroLogin() {
00213     if (this.lastSynchroLogin == null){
00214       this.lastSynchroLogin = PersistentPropertiesManager.getManager().getProperty("OpenMSPSynchroManager", "login");
00215 
00216     }
00217     return this.lastSynchroLogin;
00218   }
00219   
00228   public String getSynchroUserAgent(SynchroDescriptor descriptor) {
00229     String usera = PropertiesManager.getManager().getProperty("org.openmobileis.synchro.direct.useragent");      
00230     if (usera == null)  {
00231       Plateform plateform = ApplicationContextManager.getManager().getApplicationContext().getPlateform();
00232       StringBuffer useragent = new StringBuffer("OpenMSPPlug-");
00233       useragent.append(plateform.getOpenMobileISMajorVersion()).append('.').append(plateform.getOpenMobileISMinorVersion()).append('-');
00234       useragent.append(plateform.getOS()).append('[').append(plateform.getOSVersion()).append("]-");
00235       String language = IntlResourceManager.getManager().getManagerLocaleString();
00236       useragent.append(language);
00237       String synctype = descriptor.getProperty("OpenMSPsynchrotype");
00238       if (synctype != null) {
00239         useragent.append('-').append(synctype);
00240       }
00241       usera = useragent.toString();
00242     }
00243     return usera;
00244   }
00245 
00246   public int getGlobalSynchroStatut() {
00247     return globalSynchroStatut;
00248   }
00249 
00250 }

Generated on Mon Jul 10 10:29:31 2006 for OpenMobileIS by  doxygen 1.4.4