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
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
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
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
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
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
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
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 }