/******************************************************************************
* Copyright (c) 2008, 2009 Versant Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Remy Chi Jian Suen (Versant Corporation) - initial API and implementation
******************************************************************************/
package org.eclipse.team.internal.ecf.core;
import java.io.*;
import java.util.*;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.util.ECFException;
import org.eclipse.ecf.datashare.AbstractShare;
import org.eclipse.ecf.datashare.IChannelContainerAdapter;
import org.eclipse.osgi.util.NLS;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.core.variants.IResourceVariant;
import org.eclipse.team.internal.ecf.core.messages.*;
import org.eclipse.team.internal.ecf.core.variants.RemoteResourceVariant;
public class RemoteShare extends AbstractShare {
private Map participants = new HashMap();
private Object returnValue;
public RemoteShare(IChannelContainerAdapter adapter) throws ECFException {
super(adapter);
}
public synchronized boolean sendShareRequest(ID localId, ID remoteId, IResource[] resources, IProgressMonitor monitor) throws ECFException, InterruptedException {
Assert.isNotNull(localId);
Assert.isNotNull(remoteId);
Assert.isNotNull(resources);
sendMessage(remoteId, serialize(new ShareRequest(localId, resources)));
while (returnValue == null) {
Thread.sleep(100);
if (monitor.isCanceled()) {
throw new OperationCanceledException();
}
}
Object tmpValue = returnValue;
returnValue = null;
return ((Boolean) tmpValue).booleanValue();
}
public synchronized IResourceVariant[] fetchMembers(ID ownId, ID remoteId, IResourceVariant variant, IProgressMonitor monitor) throws TeamException {
RemoteResourceVariant remoteVariant = (RemoteResourceVariant) variant;
if (!remoteVariant.hasMembers()) {
// we've predetermined that this resource will not have any valid
// members, just return an empty array
return new IResourceVariant[0];
}
monitor.subTask(NLS.bind(Messages.RemoteShare_FetchingVariant, variant.getName()));
sendMessage(remoteId, new FetchVariantsRequest(ownId, remoteVariant.getPath(), remoteVariant.getType()));
while (returnValue == null) {
try {
Thread.sleep(100);
if (monitor.isCanceled()) {
throw new OperationCanceledException();
}
} catch (InterruptedException e) {
// TODO: do we want to handle this differently...?
Thread.interrupted();
throw new TeamException("Interrupted whilst fetching members"); //$NON-NLS-1$
}
}
monitor.done();
Object tmpValue = returnValue;
returnValue = null;
return (IResourceVariant[]) tmpValue;
}
public synchronized IResourceVariant fetchVariant(ID ownId, ID remoteId, IResource resource, IProgressMonitor monitor) throws TeamException {
monitor.subTask(NLS.bind(Messages.RemoteShare_FetchingVariant, resource.getFullPath().toString().substring(1)));
sendMessage(remoteId, new FetchVariantRequest(ownId, resource.getFullPath().toString(), resource.getType()));
while (returnValue == null) {
try {
Thread.sleep(100);
if (monitor.isCanceled()) {
throw new OperationCanceledException();
}
} catch (InterruptedException e) {
// TODO: do we want to handle this differently...?
Thread.interrupted();
throw new TeamException("Interrupted whilst fetching variant"); //$NON-NLS-1$
}
}
monitor.done();
Object tmpValue = returnValue;
returnValue = null;
return ((IResourceVariant[]) tmpValue)[0];
}
public synchronized IResourceVariant getResourceVariant(ID ownId, ID remoteId, IResource resource) throws TeamException {
sendMessage(remoteId, new FetchVariantRequest(ownId, resource.getFullPath().toString(), resource.getType()));
// FIXME: no progress monitor is available for this method, a timeout
// needs to be implemented at the preferences layer
while (returnValue == null) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO: do we want to handle this differently...?
Thread.interrupted();
throw new TeamException("Interrupted whilst getting variant"); //$NON-NLS-1$
}
}
Object tmpValue = returnValue;
returnValue = null;
return ((IResourceVariant[]) tmpValue)[0];
}
private void sendMessage(ID id, Serializable serializable) {
try {
sendMessage(id, serialize(serializable));
} catch (ECFException e) {
TeamSynchronization.log("Could not send message to peer " + id, e); //$NON-NLS-1$
}
}
protected void handleMessage(ID fromContainerId, byte[] data) {
Object message = deserialize(data);
if (message instanceof FetchVariantsRequest) {
FetchVariantRequest msg = (FetchVariantRequest) message;
String path = msg.getPath();
IContainer container = null;
switch (msg.getType()) {
case IResource.FILE :
// this shouldn't happen as the fetch request should not have
// been sent for files in the first place
TeamSynchronization.log("Files should not have any variants to request for"); //$NON-NLS-1$
break;
case IResource.PROJECT :
container = ResourcesPlugin.getWorkspace().getRoot().getProject(new Path(path).lastSegment());
break;
case IResource.FOLDER :
container = ResourcesPlugin.getWorkspace().getRoot().getFolder(new Path(path));
break;
default :
TeamSynchronization.log("Unsupported resource type specified: " //$NON-NLS-1$
+ msg.getType());
break;
}
sendFetchVariantsResponse(msg.getFromId(), container);
} else if (message instanceof FetchVariantRequest) {
FetchVariantRequest msg = (FetchVariantRequest) message;
IResource resource = null;
IPath path = new Path(msg.getPath());
switch (msg.getType()) {
case IResource.PROJECT :
resource = ResourcesPlugin.getWorkspace().getRoot().getProject(path.lastSegment());
break;
case IResource.FOLDER :
resource = ResourcesPlugin.getWorkspace().getRoot().getFolder(path);
break;
case IResource.FILE :
resource = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
break;
default :
TeamSynchronization.log("Unsupported resource type specified: " //$NON-NLS-1$
+ msg.getType());
break;
}
sendFetchVariantResponse(msg.getFromId(), resource);
} else if (message instanceof ShareRequest) {
ShareRequest request = (ShareRequest) message;
boolean response = prompt(request.getFromId(), request.getPaths());
if (response) {
response = false;
String[] paths = request.getPaths();
int[] types = request.getTypes();
IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
resourceLoop: for (int i = 0; i < paths.length; i++) {
switch (types[i]) {
case IResource.PROJECT :
if (workspaceRoot.getProject(new Path(paths[i]).lastSegment()).exists()) {
response = true;
break resourceLoop;
}
break;
case IResource.FOLDER :
if (workspaceRoot.getFolder(new Path(paths[i])).exists()) {
response = true;
break resourceLoop;
}
break;
case IResource.FILE :
if (workspaceRoot.getFile(new Path(paths[i])).exists()) {
response = true;
break resourceLoop;
}
break;
}
}
}
sendMessage(request.getFromId(), new ShareResponse(response));
} else if (message instanceof IResponse) {
returnValue = ((IResponse) message).getResponse();
}
}
protected boolean prompt(ID fromId, String[] paths) {
return false;
}
private void sendFetchVariantsResponse(ID fromId, IContainer container) {
// the container will be null if an invalid resource type was provided
if (container == null) {
sendMessage(fromId, new FetchResponse());
return;
}
try {
IResource[] members = container.members();
List variants = new ArrayList();
for (int i = 0; i < members.length; i++) {
if (!members[i].isDerived()) {
variants.add(new RemoteResourceVariant(members[i]));
}
}
IResourceVariant[] variantsArray = (IResourceVariant[]) variants.toArray(new IResourceVariant[variants.size()]);
sendMessage(fromId, new FetchResponse(variantsArray));
} catch (CoreException e) {
TeamSynchronization.log("Could not retrieve container members: " //$NON-NLS-1$
+ container.getFullPath(), e);
}
}
private void sendFetchVariantResponse(ID fromId, IResource resource) {
// resource will be null if an invalid resource type was provided
if (resource != null && resource.exists()) {
sendMessage(fromId, new FetchResponse(new RemoteResourceVariant(resource)));
} else {
sendMessage(fromId, new FetchResponse((IResourceVariant) null));
}
}
public synchronized void dispose() {
participants.clear();
super.dispose();
}
private static Object deserialize(byte[] data) {
try {
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ObjectInputStream inputStream = new ObjectInputStream(bais);
return inputStream.readObject();
} catch (IOException e) {
TeamSynchronization.log("Could not read deserialize data", e); //$NON-NLS-1$
return null;
} catch (ClassNotFoundException e) {
TeamSynchronization.log("Could not find class for deserialization", //$NON-NLS-1$
e);
return null;
}
}
private static byte[] serialize(Serializable serializable) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream outputStream = new ObjectOutputStream(baos);
outputStream.writeObject(serializable);
return baos.toByteArray();
} catch (IOException e) {
TeamSynchronization.log("Could not read serialize object", e); //$NON-NLS-1$
return null;
}
}
}