modification to convert jupiter time stamps to new jupiter clients.

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/concurrent/jupiter/Algorithm.java

@@ -57,5 +57,10 @@ public interface Algorithm {
 	 */
 	int[] transformIndices(Timestamp timestamp, int[] indices) throws TransformationException;
 	
-	public Operation receiveTransformedRequest(Request req) throws TransformationException;
+	/**
+	 * 
+	 * @param timestamp
+	 * @throws TransformationException 
+	 */
+	void updateVectorTime(Timestamp timestamp) throws TransformationException;
 }

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/concurrent/jupiter/JupiterClient.java

@@ -13,4 +13,12 @@ public interface JupiterClient extends JupiterEditor{
 	 * @return
 	 */
 	public JID getJID();
+	
+	/**
+	 * get the current vector time.
+	 * @return
+	 */
+	public Timestamp getTimestamp();
+	
+	public void updateVectorTime(Timestamp timestamp) throws TransformationException;
 }

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/concurrent/jupiter/JupiterServer.java

@@ -26,4 +26,7 @@ public interface JupiterServer extends SynchronizedQueue, RequestForwarder, Jupi
 	 */
 	public boolean isExist(JID jid);
 	
+	
+	public void updateVectorTime(JID source, JID dest);
+
 }

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/concurrent/jupiter/internal/Jupiter.java

@@ -127,22 +127,6 @@ public class Jupiter implements Algorithm {
 		return newOp;
 	}
 	
-	public Operation receiveTransformedRequest(Request req) throws TransformationException{
-		Timestamp timestamp = req.getTimestamp();
-		if (!(timestamp instanceof JupiterVectorTime)) {
-			throw new IllegalArgumentException("Jupiter expects timestamps of type JupiterVectorTime");
-		}
-		//TODO: check preconditions
-//		try{
-		checkPreconditions((JupiterVectorTime) timestamp);
-//		}catch(TransformationException e){
-//			logger.warn(e);
-//		}
-		discardAcknowledgedOperations((JupiterVectorTime) timestamp);
-		vectorTime.incrementRemoteRequestCount();
-		return req.getOperation();
-	}
-	
 	/**
 	 * @see de.fu_berlin.inf.dpp.concurrent.jupiter.Algorithm#acknowledge(int, de.fu_berlin.inf.dpp.concurrent.jupiter.Timestamp)
 	 */
@@ -376,4 +360,14 @@ public class Jupiter implements Algorithm {
 		return isClientSide;
 	}
 
+	public void updateVectorTime(Timestamp timestamp) throws TransformationException{
+		if(ackRequestList.size()> 0){
+			throw new TransformationException("ackRequestList have entries. Update Vector time failed.");
+		}
+		int local = timestamp.getComponents()[0];
+		int remote = timestamp.getComponents()[1];
+		this.vectorTime = new JupiterVectorTime(local, remote);
+		
+	}
+	
 }

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/concurrent/jupiter/internal/JupiterDocumentClient.java

@@ -8,6 +8,7 @@ import de.fu_berlin.inf.dpp.concurrent.jupiter.JupiterClient;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.Operation;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.Request;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.RequestForwarder;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.Timestamp;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.TransformationException;
 import de.fu_berlin.inf.dpp.net.JID;
 
@@ -71,5 +72,13 @@ public class JupiterDocumentClient implements JupiterClient {
 		
 	}
 
+	public Timestamp getTimestamp() {
+		return jupiter.getTimestamp();
+	}
+
+	public void updateVectorTime(Timestamp timestamp) throws TransformationException {
+		jupiter.updateVectorTime(timestamp);
+	}
+
 	
 }

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/concurrent/jupiter/internal/JupiterDocumentServer.java

@@ -14,6 +14,8 @@ import de.fu_berlin.inf.dpp.concurrent.jupiter.JupiterServer;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.OperationSerializer;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.Request;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.RequestForwarder;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.Timestamp;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.TransformationException;
 import de.fu_berlin.inf.dpp.concurrent.management.OutgoingMessageForwarder;
 import de.fu_berlin.inf.dpp.net.JID;
 
@@ -231,6 +233,24 @@ public class JupiterDocumentServer implements JupiterServer{
 		return false;
 	}
 
+	public void updateVectorTime(JID source, JID dest) {
+		JupiterClient proxy = proxies.get(source);
+		if(proxy != null){
+			try {
+				Timestamp ts = proxy.getTimestamp();
+				getProxies().get(dest).updateVectorTime(new JupiterVectorTime(ts.getComponents()[1],ts.getComponents()[0]));
+			} catch (TransformationException e) {
+				logger.error("Error during update vector time for "+dest,e);
+			} catch (InterruptedException e) {
+				logger.error("Error during update vector time for "+dest,e);
+			}
+		}
+		else{
+			logger.error("No proxy found for given source jid: "+source);
+		}
+		
+	}
+
 	/* end transfer section  */
 	
 

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/concurrent/jupiter/internal/ProxyJupiterDocument.java

@@ -9,6 +9,7 @@ import de.fu_berlin.inf.dpp.concurrent.jupiter.Operation;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.Request;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.RequestForwarder;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.SynchronizedQueue;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.Timestamp;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.TransformationException;
 import de.fu_berlin.inf.dpp.net.JID;
 
@@ -75,7 +76,16 @@ public class ProxyJupiterDocument implements JupiterClient{
 
 	public void setEditor(IPath path) {
 		this.editor = path;
+	}
+
+
+	public Timestamp getTimestamp() {
+		return jupiter.getTimestamp();
+	}
+
 
+	public void updateVectorTime(Timestamp timestamp) throws TransformationException{
+			jupiter.updateVectorTime(timestamp);	
 	}
 
 

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/concurrent/jupiter/internal/text/TimestampOperation.java

+package de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text;
+
+import de.fu_berlin.inf.dpp.concurrent.jupiter.Operation;
+
+/**
+ * This operation update have new vector time for the algorithm.
+ * @author orieger
+ *
+ */
+
+public class TimestampOperation implements Operation{
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 2756378905499193184L;
+
+	
+	/**
+	 * Returns the position.
+	 * 
+	 * @return the position
+	 */
+	public int getPosition() {
+		return 0;
+	}
+
+	/**
+	 * Sets the position of this operation.
+	 * 
+	 * @param position
+	 *            the position to set
+	 */
+	public void setPosition(int position) {
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * Returns the text length.
+	 * 
+	 * @return the length of the text
+	 */
+	public int getTextLength() {
+		return 0;
+	}
+
+	/**
+	 * Returns the text to be deleted.
+	 * 
+	 * @return the text to be deleted
+	 */
+	public String getText() {
+		return "";
+	}
+
+	/**
+	 * Sets the text to be deleted.
+	 * 
+	 * @param text
+	 *            the text to be deleted
+	 */
+	public void setText(String text) {
+		throw new UnsupportedOperationException();
+	}
+	
+	/**
+	 * {@inheritDoc}
+	 */
+	public String toString() {
+		return "Timestamp(0,'')";
+	}
+	
+	/**
+	 * {@inheritDoc}
+	 */
+	public boolean equals(Object obj) {
+		if (obj == this) {
+			return true;
+		} else if (obj == null) {
+			return false;
+		} else if (obj.getClass().equals(getClass())) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public int hashCode() {
+		int hashcode = 38;
+		return hashcode;
+	}
+}

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/concurrent/management/ConcurrentDocumentManager.java

@@ -18,12 +18,17 @@ import de.fu_berlin.inf.dpp.concurrent.jupiter.JupiterServer;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.Operation;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.Request;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.RequestForwarder;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.Timestamp;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.TransformationException;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.JupiterDocumentClient;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.JupiterDocumentServer;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.JupiterTimestampFactory;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.JupiterVectorTime;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.RequestImpl;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.DeleteOperation;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.InsertOperation;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.SplitOperation;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.TimestampOperation;
 import de.fu_berlin.inf.dpp.invitation.IIncomingInvitationProcess;
 import de.fu_berlin.inf.dpp.net.IActivitySequencer;
 import de.fu_berlin.inf.dpp.net.JID;
@@ -104,6 +109,8 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 
 		// editorActivitiy(activity, true);
 
+		editorActivitiy(activity);
+
 		if (createdTextEditActivity(activity)) {
 			/* handled by jupiter and is sended by request transmitting. */
 			return null;
@@ -111,10 +118,27 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 		return activity;
 	}
 
+	/**
+	 * handled closed editor activity to remove the local jupiter clients.
+	 * 
+	 * @param activity
+	 */
+	private void editorActivitiy(IActivity activity) {
+		if (activity instanceof EditorActivity) {
+			EditorActivity editor = (EditorActivity) activity;
+
+			if (!isHostSide()) {
+				if (editor.getType() == Type.Closed) {
+					// TODO: closing jupiter client for this document.
+				}
+			}
 
+		}
+	}
 
 	/**
 	 * handles text edit activities with jupiter.
+	 * 
 	 * @param activity
 	 * @return true if activity is transformed with jupiter.
 	 */
@@ -144,7 +168,6 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 				/* sync with local jupiter client */
 				Request req = jupClient.generateRequest(op);
 
-				
 				/* already set and forward inside of jup client. */
 				// /* add appropriate Editor path. */
 				// req.setEditorPath(textEdit.getEditor());
@@ -199,6 +222,80 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 
 	public IActivity exec(IActivity activity) {
 
+		if (activity instanceof EditorActivity) {
+			EditorActivity editorAc = (EditorActivity) activity;
+
+			if (isHostSide()) {
+				JID sourceJID = new JID(editorAc.getSource());
+
+				/* if one driver activate a new editor. */
+				if (drivers.contains(sourceJID)
+						&& (editorAc.getType() == Type.Activated || editorAc
+								.getType() == Type.Closed)) {
+					/* start jupiter proxy for this driver. */
+					if (concurrentDocuments.containsKey(editorAc.getPath())) {
+						JupiterServer server = concurrentDocuments.get(editorAc
+								.getPath());
+
+						/* client has no proxy for this editor. */
+						if (!server.isExist(sourceJID)) {
+							if (editorAc.getType() == Type.Activated) {
+								server.addProxyClient(sourceJID);
+								/* update vector time for new proxy. */
+								// TODO: stop serializer and after this update
+								// vector time.
+								server.updateVectorTime(myJID, sourceJID);
+								// TODO: forward vector time method.
+
+								/* get vector time of host for this editor path. */
+								try {
+									
+									JupiterClient jupC = clientDocs.get(editorAc.getPath());
+									if(jupC != null){
+									Timestamp ts = jupC.getTimestamp();
+
+									/* create update vector time request. */
+									Request updateRequest = new RequestImpl(0,
+											new JupiterVectorTime(ts
+													.getComponents()[1], ts
+													.getComponents()[0]),
+											new TimestampOperation());
+									updateRequest.setEditorPath(editorAc
+											.getPath());
+									updateRequest.setJID(sourceJID);
+
+									forwarder
+											.forwardOutgoingRequest(updateRequest);
+									}
+								} catch (Exception e) {
+
+									logger
+											.error("Error during get timestamp of host proxy for "
+													+ editorAc.getPath(),e);
+								}
+							}
+						} else {
+							/* remove proxy for this jid. */
+							if (editorAc.getType() == Type.Closed) {
+								server.removeProxyClient(sourceJID);
+							}
+						}
+					} else {
+						/* create new jupiter proxy client. */
+						if (editorAc.getType() == Type.Activated) {
+							Request createRequest = new RequestImpl(0,
+									new JupiterVectorTime(0, 0),
+									new TimestampOperation());
+							createRequest.setEditorPath(editorAc.getPath());
+							createRequest.setJID(sourceJID);
+							
+							
+						}
+					}
+				}
+			}
+		}
+
 		if (activity instanceof TextEditActivity) {
 			// check for jupiter client documents
 			TextEditActivity text = (TextEditActivity) activity;
@@ -254,17 +351,19 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 	}
 
 	/**
-	 * convert Operation op to text edit activity
+	 * Convert Operation op to text edit activity. NoOperation will ignore.
 	 * 
 	 * @param op
-	 * @return
+	 *            incoming transformed operation.
+	 * @return List with executable text edit activities.
 	 */
 	public List<TextEditActivity> getTextEditActivity(Operation op) {
 		List<TextEditActivity> result = new Vector<TextEditActivity>();
 		TextEditActivity textEdit = null;
 		if (op instanceof DeleteOperation) {
 			DeleteOperation del = (DeleteOperation) op;
-			textEdit = new TextEditActivity(del.getPosition(), "", del.getTextLength());
+			textEdit = new TextEditActivity(del.getPosition(), "", del
+					.getTextLength());
 			result.add(textEdit);
 		}
 		if (op instanceof InsertOperation) {
@@ -275,12 +374,16 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 		if (op instanceof SplitOperation) {
 			SplitOperation split = (SplitOperation) op;
 			TextEditActivity op1 = getTextEditActivity(split.getFirst()).get(0);
-			TextEditActivity op2 = getTextEditActivity(split.getSecond()).get(0);
+			TextEditActivity op2 = getTextEditActivity(split.getSecond())
+					.get(0);
 
-			/* if operation one is delete operation the offset of second
-			 * operation has to modified.*/
+			/*
+			 * if operation one is delete operation the offset of second
+			 * operation has to modified.
+			 */
 			if (op1.replace > 0 && op1.text.length() == 0) {
-				op2 = new TextEditActivity(op2.offset-op1.replace,"",op2.replace);
+				op2 = new TextEditActivity(op2.offset - op1.replace, "",
+						op2.replace);
 			}
 			result.add(op1);
 			result.add(op2);
@@ -388,6 +491,7 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 
 		/* 1. Sync with jupiter server component. */
 		if (isHostSide()) {
+
 			/* if host side and server jupiter side of request */
 			if (isHost(request.getJID()) && request.getSiteId() == 0) {
 				/* request already has transformed and have to be execute. */
@@ -412,15 +516,15 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 				}
 				concurrentDocuments.put(request.getEditorPath(), docServer);
 			}
-			docServer = concurrentDocuments.get(request
-					.getEditorPath());
+			docServer = concurrentDocuments.get(request.getEditorPath());
 			try {
 				/* check if sender id exists in proxy list. */
 				if (!docServer.getProxies().containsKey(request.getJID())) {
 					docServer.addProxyClient(request.getJID());
 				}
 			} catch (InterruptedException ie) {
-				logger.error("Error during get proxy list of jupiter server.",ie);
+				logger.error("Error during get proxy list of jupiter server.",
+						ie);
 			}
 
 			/* sync request with jupiter document server. */
@@ -428,6 +532,35 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 
 			return;
 		} else {
+			/* update timestamp of local jupiter client. */
+			if (request.getOperation() instanceof TimestampOperation) {
+				if (clientDocs.containsKey(request.getEditorPath())) {
+					logger.info("update vector time : "
+							+ request.getEditorPath());
+					JupiterClient jupClient = clientDocs.get(request
+							.getEditorPath());
+					try {
+						jupClient.updateVectorTime(request.getTimestamp());
+					} catch (TransformationException e) {
+						logger.error("Error during update jupiter client for "
+								+ request.getEditorPath(), e);
+					}
+				}
+				else{
+					/* if no jupiter client exists.*/
+					JupiterClient client = new JupiterDocumentClient(this.myJID, this.forwarder);
+					try {
+						client.updateVectorTime(request.getTimestamp());
+						clientDocs.put(request.getEditorPath(), client);
+					} catch (TransformationException e) {
+						logger.error("Error during update jupiter client for "
+								+ request.getEditorPath(), e);
+					}
+					
+				}
+			}
+			else{
+
 			/*
 			 * 2. receive request in local client component and return the
 			 * transformed operation as IActivity.
@@ -436,12 +569,11 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 			// return execTextEditActivity(request);
 			}
 		}
+	}
 
 	public void driverChanged(JID driver, boolean replicated) {
 		/*
-		 * 1. check if driver exists.
-		 * 2. add new driver or remove driver.
-		 * 3. 
+		 * 1. check if driver exists. 2. add new driver or remove driver. 3.
 		 */
 		// HOST
 		if (isHostSide()) {
@@ -452,12 +584,13 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 			/* new driver added to project. */
 			else {
 				drivers.add(driver);
+				//TODO: add driver to current open document proxy ?
 			}
 		}
 		// CLIENT
 		else {
 			if (driver.equals(myJID)) {
-				clientDocs = new HashMap<IPath, JupiterClient>();
+				clientDocs.clear();
 			}
 		}
 
@@ -469,6 +602,7 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 	}
 
 	public void userLeft(JID user) {
+		if (isHostSide()) {
 			/* remove user from driver list */
 			drivers.remove(user);
 
@@ -482,5 +616,6 @@ public class ConcurrentDocumentManager implements ConcurrentManager {
 				}
 			}
 		}
+	}
 
 }

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/net/internal/ActivitySequencer.java

@@ -31,6 +31,7 @@ import org.eclipse.jface.text.ITextSelection;
 import org.eclipse.jface.text.TextSelection;
 
 import de.fu_berlin.inf.dpp.Saros;
+import de.fu_berlin.inf.dpp.activities.EditorActivity;
 import de.fu_berlin.inf.dpp.activities.IActivity;
 import de.fu_berlin.inf.dpp.activities.TextEditActivity;
 import de.fu_berlin.inf.dpp.activities.TextSelectionActivity;
@@ -152,6 +153,10 @@ public class ActivitySequencer implements RequestForwarder, IActivitySequencer,
 	public void exec(IActivity activity) {
 		try {
 
+			if(activity instanceof EditorActivity){
+				concurrentManager.exec(activity);
+			}
+			
 			if (activity instanceof TextEditActivity) {
 				/* check if document is already managed by jupiter mechanism. */
 				if (!concurrentManager.isHostSide()
@@ -266,6 +271,14 @@ public class ActivitySequencer implements RequestForwarder, IActivitySequencer,
 	 */
 	public void activityCreated(IActivity activity) {
 
+		if(activity instanceof EditorActivity){
+				/* Host: start and stop jupiter server process depending on editor activities
+				 * of remote clients. 
+				 * Client: start and stop local jupiter clients depending on editor activities.
+				 * */
+				concurrentManager.activityCreated(activity);
+		}
+		
 		if (activity instanceof TextEditActivity){
 
 			/*
@@ -284,7 +297,7 @@ public class ActivitySequencer implements RequestForwarder, IActivitySequencer,
 			
 			/* activity is already managed by jupiter and executed now. */
 			if (executedJupiterActivity != null
-					&& concurrentManager.isHostSide()
+					&& isHostSide()
 					&& ((TextEditActivity) activity)
 							.sameLike(executedJupiterActivity)) {
 				/* Send message to all. */
@@ -307,17 +320,6 @@ public class ActivitySequencer implements RequestForwarder, IActivitySequencer,
 				}
 			}
 
-			//			
-			// // /* sync with jupiter logic. */
-			// IActivity resultAC = concurrentManager.activityCreated(activity);
-			//
-			// /**
-			// * host activity: put into outgoing queue and send to all if
-			// * activity is generated by host. otherwise: send request to host.
-			// */
-			// if (resultAC != null || concurrentManager.isHostSide()) {
-			// activities.add(activity);
-			// }
 		} else {
 
 			activities.add(activity);
@@ -473,38 +475,10 @@ public class ActivitySequencer implements RequestForwarder, IActivitySequencer,
 	}
 
 	public synchronized void forwardOutgoingRequest(Request req) {
-		// System.out.println("get request: "+req.toString());
 
-		/**
-		 * if request form host: send to jupiter server to sync with proxies.
-		 */
-		// if (concurrentManager.isHost(req.getJID())) {
-		/* send req to jupiter document server */
-		/*
-		 * Wichtig über sideID kann ermittelt werden, ob es sich um eine client
-		 * oder server nachricht vom host handelt!
-		 */
-		// if(req.getSiteId()== 1){
-		/* request is generated by jupiter client of host. */
-
-		// IActivity activity = concurrentManager.receiveRequest(req);
-		// if (activity != null) {
-		// /* execute transformed activity */
-		// execTransformedActivity(activity);
-		// }
-		// concurrentManager.receiveRequest(req);
-		// }else{
-		// /*request is generate by jupiter server and have to execute
-		// * in host client. */
-		// log.info("mal schauen?");
-		// }
-		// } else {
 		/* put request into outgoing queue. */
 		outgoingSyncActivities.add(req);
-		// }
 
-		// logger.debug("add request to outgoing queue : "+req.getJID()+"
-		// "+req.getOperation());
 		notify();
 	}
 
@@ -540,6 +514,10 @@ public class ActivitySequencer implements RequestForwarder, IActivitySequencer,
 		// return activity;
 	}
 
+	private boolean isHostSide(){
+		return concurrentManager.isHostSide();
+	}
+	
 	/**
 	 * Execute activity after jupiter transforming process.
 	 * 

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/net/internal/RequestExtensionProvider.java

@@ -19,6 +19,7 @@ import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.DeleteOperation;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.InsertOperation;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.NoOperation;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.SplitOperation;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.TimestampOperation;
 import de.fu_berlin.inf.dpp.net.JID;
 import de.fu_berlin.inf.dpp.net.TimedActivity;
 import de.fu_berlin.inf.dpp.project.ActivityRegistry;
@@ -161,6 +162,9 @@ public class RequestExtensionProvider implements PacketExtensionProvider{
 		if(parser.getName().equals(RequestPacketExtension.NO_OP)){
 			return new NoOperation();
 		}
+		if(parser.getName().equals(RequestPacketExtension.TIMESTAMP_OP)){
+			return new TimestampOperation();
+		}
 		return op;
 	}
 	

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/net/internal/RequestPacketExtension.java

@@ -12,6 +12,7 @@ import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.DeleteOperation;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.InsertOperation;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.NoOperation;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.SplitOperation;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.TimestampOperation;
 
 
 public class RequestPacketExtension  implements PacketExtension{
@@ -35,6 +36,8 @@ public class RequestPacketExtension  implements PacketExtension{
 	
 	public static final String SPLIT_OP = "split";
 	
+	public static final String TIMESTAMP_OP = "time";
+	
 	
 	public static final String LOCAL_TIME = "localtime";
 	
@@ -130,6 +133,9 @@ public class RequestPacketExtension  implements PacketExtension{
 //			NoOperation no = (NoOperation) op;
 			xml += "<"+NO_OP+ "/>";
 		}
+		if(op instanceof TimestampOperation){
+			xml += "<"+TIMESTAMP_OP+ "/>";
+		}
 		if(op instanceof SplitOperation){
 			SplitOperation split = (SplitOperation) op;
 			

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/net/internal/XMPPChatTransmitter.java

@@ -1066,7 +1066,7 @@ public class XMPPChatTransmitter implements ITransmitter,
 			List<TimedActivity> timedActivities = activitiesPacket
 					.getActivities();
 
-			log.info("Received activities from " + fromJID.toString() + ": "
+			log.debug("Received activities from " + fromJID.toString() + ": "
 					+ timedActivities);
 
 			if (!isProjectParticipant) {
@@ -1598,7 +1598,7 @@ public class XMPPChatTransmitter implements ITransmitter,
 			description = description + ':' + transferData.timestamp;
 		}
 
-		if (getFileTransferModeViaChat()) {
+		if (getFileTransferModeViaChat() || transferData.callback == null) {
 
 			if (transferData.content == null)
 				readFile(transferData);
@@ -1612,11 +1612,13 @@ public class XMPPChatTransmitter implements ITransmitter,
 					transferData.content, recipient);
 
 			log.info("Sent file " + transferData.path + " (by ChatTransfer)");
-
+			return;
 		}
 
 		// try {
 
+		
+	
 		if (jingle
 				&& (jingleManager.getState(recipient) != JingleConnectionState.ERROR)) {
 			log.info("Sent file " + transferData.path + " (with Jingle)");

de.fu_berlin.inf.dpp/src/de/fu_berlin/inf/dpp/project/internal/SharedProject.java

@@ -53,6 +53,7 @@ import de.fu_berlin.inf.dpp.User;
 import de.fu_berlin.inf.dpp.User.UserRole;
 import de.fu_berlin.inf.dpp.concurrent.ConcurrentManager;
 import de.fu_berlin.inf.dpp.concurrent.jupiter.Request;
+import de.fu_berlin.inf.dpp.concurrent.jupiter.internal.text.TimestampOperation;
 import de.fu_berlin.inf.dpp.concurrent.management.ConcurrentDocumentManager;
 import de.fu_berlin.inf.dpp.invitation.IOutgoingInvitationProcess;
 import de.fu_berlin.inf.dpp.invitation.IInvitationProcess.IInvitationUI;
@@ -194,7 +195,7 @@ public class SharedProject implements ISharedProject {
 				// TODO: durch hinzufügen von isharedprojectlistener zum
 				// concurrentmanager
 				// könnte dieser punkt ausgelagert werden.
-				activitySequencer.getConcurrentManager().addDriver(driver.getJid());
+//				activitySequencer.getConcurrentManager().addDriver(driver.getJid());
 			}
 			// client
 			else {
@@ -681,6 +682,7 @@ public class SharedProject implements ISharedProject {
 			Request request = activitySequencer.getNextOutgoingRequest();
 
 			if (isHost()) {
+							
 				/*
 				 * if jupiter server request to has to execute locally on host
 				 * side.