00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
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 private OpenMSPSynchroProcessListener processListener;
00072
00076 private OpenMSPSynchroManager() {
00077 super();
00078 this.listenerOrdonancer = new ListenerOrdonancer();
00079 this.moduleOrdonancer = new ListenerOrdonancer();
00080 this.messageFactory = new OpenMSPSyncMessageFactory();
00081 }
00082
00083 public static OpenMSPSynchroManager getManager() {
00084 if (manager == null) {
00085 synchronized (OpenMSPSynchroManager.class) {
00086 if (manager == null) {
00087 manager = new OpenMSPSynchroManager();
00088 ApplicationContextManager.getManager().addManager(manager);
00089 }
00090 }
00091 }
00092 return manager;
00093 }
00094
00095 public void setOpenMSPSynchroProcessListener(OpenMSPSynchroProcessListener listener) {
00096 this.processListener = listener;
00097 }
00098
00099 public void clearListeners(){
00100 this.listenerOrdonancer.clearListeners();
00101 }
00102
00103 public String getProcessorName() {
00104 return OpenMSPSynchroManager.OPENMSPPROCESSORNAME;
00105 }
00106
00107 public void notifyFailure(String listernerName) {
00108 OpenMSPSyncListener listener = this.getListenerByName(listernerName);
00109 if (listener != null) {
00110 listener.notifySynchroFailure();
00111 listenerOrdonancer.notifySynchroError(listener.getSyncName());
00112 moduleOrdonancer.notifySynchroError(listener.getSyncName());
00113 }
00114 globalSynchroStatut = Status.STATUS_FAILED;
00115 }
00116
00122 public OpenMSPSyncListener getListenerByName(String listenerName) {
00123 return listenerOrdonancer.getListenerByName(listenerName);
00124 }
00133 public OpenMSPSyncListener getModuleListenerByName(String listenerName) {
00134 return moduleOrdonancer.getListenerByName(listenerName);
00135 }
00136
00137 public void doSynchro(Credential cred, SynchroDescriptor descriptor) throws SynchroException {
00138 globalSynchroStatut = Status.STATUS_SYNC_IN_PROGRESS;
00139 if (processListener != null) processListener.notifySynchroStart();
00140 this.lastSynchroLogin = cred.getPrincipal();
00141
00142 String prgprop = PropertiesManager.getManager().getProperty("org.openmobileis.synchro.ui.progressbar");
00143 if ((prgprop != null) && (prgprop.equals("true"))) {
00144 }
00145
00146
00147 PersistentPropertiesManager.getManager().saveProperty("OpenMSPSynchroManager", "login", this.lastSynchroLogin);
00148 ListenerOrdonancer currentOrdonnancer = this.listenerOrdonancer;
00149 currentOrdonnancer.beginSynchro();
00150 this.messageFactory.beginSynchro(cred, descriptor);
00151 Array listenerList = currentOrdonnancer.getNextListenerList();
00152 boolean moduleSynchro = false;
00153 if (listenerList.size() == 0) {
00154 currentOrdonnancer.endSynchro();
00155 currentOrdonnancer = this.moduleOrdonancer;
00156 currentOrdonnancer.beginSynchro();
00157 listenerList = currentOrdonnancer.getNextListenerList();
00158 moduleSynchro = true;
00159 }
00160 try {
00161 while (listenerList.size() != 0) {
00162 int listsize = listenerList.size();
00163 for (int i=0; i<listsize; i++) {
00164 OpenMSPSyncListener listener = (OpenMSPSyncListener) listenerList.get(i);
00165 if (processListener != null) processListener.notifyListenerStartSync(listener.getSyncName());
00166 listener.startSync(cred, descriptor);
00167 }
00168 while (true) {
00169 if (processListener != null) processListener.notifyGenerateOpenMSPMessage();
00170 Message message = this.messageFactory.getOpenMSPMessage(listenerList);
00171 if (message.isEmpty()) {
00172
00173 break;
00174 }
00175 String xmlString = message.encode();
00176 ConduitParameter[] parameters = new ConduitParameter[] {new ConduitParameter("openMISGroup", descriptor.getSynchroGroup())};
00177 if (processListener != null) processListener.notifyBeforeSendMessage();
00178 String reqResult = descriptor.getSynchroConduit().sendRequest(parameters, new String(compressAndEncodeRequest(xmlString)), descriptor.getServerURL());
00179
00180 if (processListener != null) processListener.notifyReceiveMessageReturn();
00181 Message receivedMessage = MessageFactory.getFactory().getMessage(reqResult);
00182 String target = receivedMessage.getHeader().getTarget();
00183 if (processListener != null) processListener.notifyBeforeProcessMessageReturn();
00184 if (!target.equals(OpenMSPSyncMessageFactory.OpenMSPSOURCE)) {
00185 throw new OpenMSPException("Bad OpenMSP Sync Source in Server answer message. Synchro Abort.");
00186 } else {
00187 this.messageFactory.receiveOpenMSPMessage(listenerList, receivedMessage);
00188 }
00189 if (processListener != null) processListener.notifyAfterProcessMessageReturn();
00190 }
00191 for (int i=0; i<listsize; i++) {
00192 OpenMSPSyncListener listener = (OpenMSPSyncListener) listenerList.get(i);
00193 if (processListener != null) processListener.notifyListenerEndSync(listener.getSyncName());
00194 listener.endSync();
00195 }
00196 listenerList = currentOrdonnancer.getNextListenerList();
00197 if (listenerList.size() == 0 && !moduleSynchro) {
00198 currentOrdonnancer.endSynchro();
00199 currentOrdonnancer = this.moduleOrdonancer;
00200 currentOrdonnancer.beginSynchro();
00201 listenerList = currentOrdonnancer.getNextListenerList();
00202 moduleSynchro = true;
00203 }
00204 }
00205 if (processListener != null) processListener.notifyEndProcessListener();
00206 globalSynchroStatut = Status.STATUS_OK;
00207 } catch (UserNotFoundException ex) {
00208 notifyFailureToListeners(listenerList);
00209 globalSynchroStatut = Status.STATUS_UNAUTHORIZED;
00210 if (processListener != null) processListener.notifySynchroFailure(Status.STATUS_UNAUTHORIZED);
00211 throw new OpenMSPException(ex);
00212 } catch (Throwable ex) {
00213 notifyFailureToListeners(listenerList);
00214 if (processListener != null) processListener.notifySynchroFailure(Status.STATUS_FAILED);
00215 throw new OpenMSPException(ex);
00216 } finally {
00217 this.listenerOrdonancer.endSynchro();
00218 this.moduleOrdonancer.endSynchro();
00219 this.messageFactory.endSynchro();
00220 if (processListener != null) processListener.notifySynchroEnd();
00221 }
00222 }
00223
00227 public void registerSynchroListenerAddNotifier(SynchroListenerAddNotifier listener) {
00228 addlistener = listener;
00229 }
00230
00242 public void addListener(OpenMSPSyncListener listener, String[] depends) {
00243
00244 try {
00245 listener.initListener();
00246 }catch (OpenMSPException ex) {
00247 LogManager.traceError(0, ex);
00248 return;
00249 }
00250
00251 if (addlistener != null) {
00252 addlistener.notifyAddListener(listener, depends);
00253 if (!addlistener.isBlocking()) {
00254 listenerOrdonancer.addListener(listener, depends);
00255 }
00256 } else {
00257 listenerOrdonancer.addListener(listener, depends);
00258 }
00259 }
00260
00261
00262
00272 public void addModuleListener(OpenMSPSyncListener listener, String[] depends) {
00273 moduleOrdonancer.addListener(listener, depends);
00274 }
00275
00276 private void notifyFailureToListeners(Array listenerList) {
00277 for (int i=0; i<listenerList.size(); i++) {
00278 OpenMSPSyncListener listener = (OpenMSPSyncListener)listenerList.get(i);
00279 listener.notifySynchroFailure();
00280 listenerOrdonancer.notifySynchroError(listener.getSyncName());
00281 moduleOrdonancer.notifySynchroError(listener.getSyncName());
00282 }
00283 globalSynchroStatut = Status.STATUS_FAILED;
00284 }
00285
00286 private byte[] compressAndEncodeRequest(String request) throws IOException {
00287
00288 byte[] compressedData = null;
00289 ByteArrayOutputStream byteStream = new ByteArrayOutputStream(512);
00290 GZIPOutputStream zipStream = new GZIPOutputStream(byteStream);
00291 try {
00292 zipStream.write(request.getBytes());
00293 } finally {
00294 zipStream.close();
00295 }
00296 compressedData = byteStream.toByteArray();
00297
00298
00299 byte[] returnData = GeneralCoder.encodeBase64(compressedData);
00300 return returnData;
00301 }
00302
00303 public String getLastSynchroLogin() {
00304 if (this.lastSynchroLogin == null){
00305 this.lastSynchroLogin = PersistentPropertiesManager.getManager().getProperty("OpenMSPSynchroManager", "login");
00306
00307 }
00308 return this.lastSynchroLogin;
00309 }
00310
00319 public String getSynchroUserAgent(SynchroDescriptor descriptor) {
00320 String usera = PropertiesManager.getManager().getProperty("org.openmobileis.synchro.direct.useragent");
00321 if (usera == null) {
00322 Plateform plateform = ApplicationContextManager.getManager().getApplicationContext().getPlateform();
00323 StringBuffer useragent = new StringBuffer("OpenMSPPlug-");
00324 useragent.append(plateform.getOpenMobileISMajorVersion()).append('.').append(plateform.getOpenMobileISMinorVersion()).append('-');
00325 useragent.append(plateform.getOS()).append('[').append(plateform.getOSVersion()).append("]-");
00326 String language = IntlResourceManager.getManager().getManagerLocaleString();
00327 useragent.append(language);
00328 String synctype = descriptor.getProperty("OpenMSPsynchrotype");
00329 if (synctype != null) {
00330 useragent.append('-').append(synctype);
00331 }
00332 usera = useragent.toString();
00333 }
00334 return usera;
00335 }
00336
00337 public int getGlobalSynchroStatut() {
00338 return globalSynchroStatut;
00339 }
00340
00341 }