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.common.util.log.LogManager;
00042 import org.openmobileis.database.fastobjectdb.synchro.client.SynchroListenerAddNotifier;
00043 import org.openmobileis.synchro.client.SynchroDescriptor;
00044 import org.openmobileis.synchro.client.SynchroProcessor;
00045 import org.openmobileis.synchro.openmsp.OpenMSPException;
00046 import org.openmobileis.synchro.openmsp.client.conduit.ConduitParameter;
00047 import org.openmobileis.synchro.openmsp.client.core.ListenerOrdonancer;
00048 import org.openmobileis.synchro.openmsp.client.core.OpenMSPSyncMessageFactory;
00049 import org.openmobileis.synchro.openmsp.protocol.Message;
00050 import org.openmobileis.synchro.openmsp.protocol.MessageFactory;
00051 import org.openmobileis.synchro.openmsp.protocol.Status;
00052 import org.openmobileis.synchro.security.auth.Credential;
00053 
00061 public class OpenMSPSynchroManager implements SynchroProcessor {
00062   public static final String OPENMSPPROCESSORNAME="OpenMSPSync";
00063 
00064   private static OpenMSPSynchroManager manager;
00065   private ListenerOrdonancer listenerOrdonancer;
00066   private ListenerOrdonancer moduleOrdonancer;
00067   private OpenMSPSyncMessageFactory messageFactory;
00068   private String lastSynchroLogin;
00069   private int globalSynchroStatut;
00070   private SynchroListenerAddNotifier addlistener;
00071 
00075   private OpenMSPSynchroManager() {
00076     super();
00077     this.listenerOrdonancer = new ListenerOrdonancer();
00078     this.moduleOrdonancer = new ListenerOrdonancer();
00079     this.messageFactory = new OpenMSPSyncMessageFactory();
00080   }
00081 
00082   public static OpenMSPSynchroManager getManager() {
00083     if (manager == null)  {
00084       synchronized (OpenMSPSynchroManager.class) {
00085         if (manager == null)  {
00086           manager = new OpenMSPSynchroManager();
00087           ApplicationContextManager.getManager().addManager(manager);
00088         }
00089       }
00090     }
00091     return manager;
00092   }
00093  
00094   public String getProcessorName()  {
00095     return OpenMSPSynchroManager.OPENMSPPROCESSORNAME;   
00096   }
00097 
00098   public void notifyFailure(String listernerName) {
00099     OpenMSPSyncListener listener = this.getListenerByName(listernerName);
00100     if (listener != null) {
00101       listener.notifySynchroFailure();
00102       listenerOrdonancer.notifySynchroError(listener.getSyncName());
00103       moduleOrdonancer.notifySynchroError(listener.getSyncName());
00104     }
00105     globalSynchroStatut = Status.STATUS_FAILED;
00106   }
00107   
00113   public OpenMSPSyncListener getListenerByName(String listenerName) {
00114     return listenerOrdonancer.getListenerByName(listenerName);
00115   }
00124   public OpenMSPSyncListener getModuleListenerByName(String listenerName) {
00125     return moduleOrdonancer.getListenerByName(listenerName);
00126   }
00127   
00128   public void doSynchro(Credential cred, SynchroDescriptor descriptor) throws SynchroException {
00129     globalSynchroStatut = Status.STATUS_SYNC_IN_PROGRESS;
00130     this.lastSynchroLogin = cred.getPrincipal();
00131     //save login
00132     PersistentPropertiesManager.getManager().saveProperty("OpenMSPSynchroManager", "login", this.lastSynchroLogin);
00133     ListenerOrdonancer currentOrdonnancer = this.listenerOrdonancer;
00134     currentOrdonnancer.beginSynchro();
00135     this.messageFactory.beginSynchro(cred, descriptor);
00136     Array listenerList = currentOrdonnancer.getNextListenerList();
00137     boolean moduleSynchro = false;
00138     if (listenerList.size() == 0)   {
00139       currentOrdonnancer.endSynchro();
00140       currentOrdonnancer = this.moduleOrdonancer;
00141       currentOrdonnancer.beginSynchro();
00142       listenerList = currentOrdonnancer.getNextListenerList(); 
00143       moduleSynchro = true;
00144     }
00145     try {
00146       while (listenerList.size() != 0)  {
00147         int listsize = listenerList.size();
00148         for (int i=0; i<listsize; i++)  {
00149           OpenMSPSyncListener listener = (OpenMSPSyncListener) listenerList.get(i);
00150           listener.startSync(cred, descriptor);
00151         }
00152         while (true) {
00153           Message message = this.messageFactory.getOpenMSPMessage(listenerList);
00154           if (message.isEmpty()) {
00155             //get next listener phase.
00156             break;
00157           }
00158           String xmlString = message.encode();
00159           ConduitParameter[] parameters = new ConduitParameter[] {new ConduitParameter("openMISGroup", descriptor.getSynchroGroup())};
00160  
00161           String reqResult = descriptor.getSynchroConduit().sendRequest(parameters, new String(compressAndEncodeRequest(xmlString)), descriptor.getServerURL());
00162           // third step : Process responses
00163           Message receivedMessage = MessageFactory.getFactory().getMessage(reqResult);
00164           String target = receivedMessage.getHeader().getTarget();
00165           if (!target.equals(OpenMSPSyncMessageFactory.OpenMSPSOURCE)) {
00166             throw new OpenMSPException("Bad OpenMSP Sync Source in Server answer message. Synchro Abort.");
00167           } else {
00168             this.messageFactory.receiveOpenMSPMessage(listenerList, receivedMessage);
00169           }
00170         }
00171         for (int i=0; i<listsize; i++)  {
00172           OpenMSPSyncListener listener = (OpenMSPSyncListener) listenerList.get(i);
00173           listener.endSync();
00174         }
00175         listenerList = currentOrdonnancer.getNextListenerList();
00176         if (listenerList.size() == 0 && !moduleSynchro)   {
00177           currentOrdonnancer.endSynchro();
00178           currentOrdonnancer = this.moduleOrdonancer;
00179           currentOrdonnancer.beginSynchro();
00180           listenerList = currentOrdonnancer.getNextListenerList();     
00181           moduleSynchro = true;
00182         }
00183       }
00184       globalSynchroStatut = Status.STATUS_OK;
00185     } catch (UserNotFoundException ex)  {
00186       notifyFailureToListeners(listenerList);
00187       globalSynchroStatut = Status.STATUS_UNAUTHORIZED;
00188       throw new OpenMSPException(ex);
00189     } catch (Throwable ex)  {
00190       notifyFailureToListeners(listenerList);
00191       throw new OpenMSPException(ex);
00192     } finally {
00193       this.listenerOrdonancer.endSynchro();
00194       this.moduleOrdonancer.endSynchro();
00195       this.messageFactory.endSynchro();      
00196     }
00197   }
00198   
00202   public void registerSynchroListenerAddNotifier(SynchroListenerAddNotifier listener) {
00203     addlistener = listener;
00204   }
00205   
00217   public void addListener(OpenMSPSyncListener listener, String[] depends) {
00218         // init listener.
00219         try     {
00220                 listener.initListener();
00221         }catch  (OpenMSPException ex)   {
00222                 LogManager.traceError(0, ex);
00223                 return;
00224         }
00225         
00226     if (addlistener != null) {
00227       addlistener.notifyAddListener(listener, depends);
00228       if (!addlistener.isBlocking())    {
00229         listenerOrdonancer.addListener(listener, depends);
00230       }
00231     } else  {
00232       listenerOrdonancer.addListener(listener, depends);
00233     }
00234   }
00235   
00236   
00237   
00247   public void addModuleListener(OpenMSPSyncListener listener, String[] depends) {
00248     moduleOrdonancer.addListener(listener, depends);
00249   }
00250  
00251   private void notifyFailureToListeners(Array listenerList) {
00252     for (int i=0; i<listenerList.size(); i++) {
00253       OpenMSPSyncListener listener = (OpenMSPSyncListener)listenerList.get(i);
00254       listener.notifySynchroFailure();
00255       listenerOrdonancer.notifySynchroError(listener.getSyncName());
00256       moduleOrdonancer.notifySynchroError(listener.getSyncName());
00257     }
00258     globalSynchroStatut = Status.STATUS_FAILED;   
00259   }
00260 
00261   private byte[] compressAndEncodeRequest(String request) throws IOException {
00262     // compresse data
00263     byte[] compressedData = null;
00264     ByteArrayOutputStream byteStream = new ByteArrayOutputStream(512);
00265     GZIPOutputStream zipStream = new GZIPOutputStream(byteStream);
00266     try {
00267       zipStream.write(request.getBytes());
00268     } finally  {
00269       zipStream.close();
00270     }
00271     compressedData = byteStream.toByteArray();
00272 
00273     // encode compressed data
00274     byte[] returnData = GeneralCoder.encodeBase64(compressedData);
00275     return returnData;
00276   }
00277 
00278   public String getLastSynchroLogin() {
00279     if (this.lastSynchroLogin == null){
00280       this.lastSynchroLogin = PersistentPropertiesManager.getManager().getProperty("OpenMSPSynchroManager", "login");
00281 
00282     }
00283     return this.lastSynchroLogin;
00284   }
00285   
00294   public String getSynchroUserAgent(SynchroDescriptor descriptor) {
00295     String usera = PropertiesManager.getManager().getProperty("org.openmobileis.synchro.direct.useragent");      
00296     if (usera == null)  {
00297       Plateform plateform = ApplicationContextManager.getManager().getApplicationContext().getPlateform();
00298       StringBuffer useragent = new StringBuffer("OpenMSPPlug-");
00299       useragent.append(plateform.getOpenMobileISMajorVersion()).append('.').append(plateform.getOpenMobileISMinorVersion()).append('-');
00300       useragent.append(plateform.getOS()).append('[').append(plateform.getOSVersion()).append("]-");
00301       String language = IntlResourceManager.getManager().getManagerLocaleString();
00302       useragent.append(language);
00303       String synctype = descriptor.getProperty("OpenMSPsynchrotype");
00304       if (synctype != null) {
00305         useragent.append('-').append(synctype);
00306       }
00307       usera = useragent.toString();
00308     }
00309     return usera;
00310   }
00311 
00312   public int getGlobalSynchroStatut() {
00313     return globalSynchroStatut;
00314   }
00315 
00316 }

Generated on Mon Dec 4 11:03:28 2006 for OpenMobileIS by  doxygen 1.5.1-p1