bundles/org.eclipse.team.cvs.core/src/org/eclipse/team/internal/ccvs/core/resources/RemoteFile.java - gerrit/platform/eclipse.platform.team - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2002 IBM Corporation and others.
  * All rights reserved.   This program and the accompanying materials
  * are made available under the terms of the Common Public License v0.5
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/cpl-v05.html
  *
  * Contributors:
  * IBM - Initial API and implementation
  ******************************************************************************/
 package org.eclipse.team.internal.ccvs.core.resources;

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;

 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.team.core.TeamException;
 import org.eclipse.team.core.sync.IRemoteResource;
 import org.eclipse.team.internal.ccvs.core.CVSException;
 import org.eclipse.team.internal.ccvs.core.CVSProviderPlugin;
 import org.eclipse.team.internal.ccvs.core.CVSStatus;
 import org.eclipse.team.internal.ccvs.core.CVSTag;
 import org.eclipse.team.internal.ccvs.core.ICVSFile;
 import org.eclipse.team.internal.ccvs.core.ICVSFolder;
 import org.eclipse.team.internal.ccvs.core.ICVSRemoteFile;
 import org.eclipse.team.internal.ccvs.core.ICVSRemoteResource;
 import org.eclipse.team.internal.ccvs.core.ICVSRepositoryLocation;
 import org.eclipse.team.internal.ccvs.core.ICVSResource;
 import org.eclipse.team.internal.ccvs.core.ICVSResourceVisitor;
 import org.eclipse.team.internal.ccvs.core.ICVSRunnable;
 import org.eclipse.team.internal.ccvs.core.ILogEntry;
 import org.eclipse.team.internal.ccvs.core.Policy;
 import org.eclipse.team.internal.ccvs.core.client.Command;
 import org.eclipse.team.internal.ccvs.core.client.Session;
 import org.eclipse.team.internal.ccvs.core.client.Update;
 import org.eclipse.team.internal.ccvs.core.client.Command.LocalOption;
 import org.eclipse.team.internal.ccvs.core.client.Command.QuietOption;
 import org.eclipse.team.internal.ccvs.core.client.listeners.LogListener;
 import org.eclipse.team.internal.ccvs.core.connection.CVSServerException;
 import org.eclipse.team.internal.ccvs.core.syncinfo.MutableResourceSyncInfo;
 import org.eclipse.team.internal.ccvs.core.syncinfo.ResourceSyncInfo;
 import org.eclipse.team.internal.ccvs.core.util.Util;

 /**
  * This class provides the implementation of ICVSRemoteFile and IManagedFile for
  * use by the repository and sync view.
  */
 public class RemoteFile extends RemoteResource implements ICVSRemoteFile  {

 	// Contents will be cached to disk when this thrshold is exceeded
 	private static final int CACHING_THRESHOLD = 32768;

 	// buffer for file contents received from the server
 	private byte[] contents;
 	// cach the log entry for the remote file
 	private ILogEntry entry;

 	/**
 	 * Static method which creates a file as a single child of its parent.
 	 * This should only be used when one is only interested in the file alone.
 	 *
 	 * The returned RemoteFile represents the base of the local resource.
 	 * If the local resource does not have a base, then null is returned
 	 * even if the resource does exists remotely (e.g. created by another party).
 	 */
 	public static RemoteFile getBase(RemoteFolder parent, ICVSFile managed) throws CVSException {
 		ResourceSyncInfo info = managed.getSyncInfo();
 		if ((info == null) || info.isAdded()) {
 			// Either the file is unmanaged or has just been added (i.e. doesn't necessarily have a remote)
 			return null;
 		}
 		RemoteFile file = new RemoteFile(parent, managed.getSyncInfo());
 		parent.setChildren(new ICVSRemoteResource[] {file});
 		return file;
 	}

 	/**
 	 * Constructor for RemoteFile that should be used when nothing is know about the
 	 * file ahead of time.
 	 */
 	// XXX do we need the first two constructors?
 	public RemoteFile(RemoteFolder parent, int workspaceSyncState, String name, CVSTag tag) {
 		this(parent, workspaceSyncState, name, "", tag);  //$NON-NLS-1$
 		MutableResourceSyncInfo newInfo = info.cloneMutable();
 		newInfo.setAdded();
 	}

 	public RemoteFile(RemoteFolder parent, int workspaceSyncState, String name, String revision, CVSTag tag) {
 		this(parent, workspaceSyncState, null);
 		MutableResourceSyncInfo newInfo = new MutableResourceSyncInfo(name, revision);
 		newInfo.setKeywordMode(Command.KSUBST_TEXT_EXPAND);
 		newInfo.setTag(tag);
 		info = newInfo;
 	}

 	public RemoteFile(RemoteFolder parent, ResourceSyncInfo info) {
 		this(parent, Update.STATE_NONE, info);
 	}

 	public RemoteFile(RemoteFolder parent, int workspaceSyncState, ResourceSyncInfo newInfo) {
 		this.parent = parent;
 		info = newInfo;
 		setWorkspaceSyncState(workspaceSyncState);
 	}

 	/**
 	 * @see ICVSResource#accept(IManagedVisitor)
 	 */
 	public void accept(ICVSResourceVisitor visitor) throws CVSException {
 		visitor.visitFile(this);
 	}

 	/**
 	 * @see ICVSRemoteFile#getContents()
 	 */
 	public InputStream getContents(IProgressMonitor monitor) throws CVSException {
 		if (contents == null) {
 			// First, check to see if there's a cached contents for the file
 			InputStream cached = getCachedContents();
 			if (cached != null) {
 				return cached;
 			}

 			// We need to fetch the contents from the server
 			monitor.beginTask(Policy.bind("RemoteFile.getContents"), 100);//$NON-NLS-1$
 			Session.run(getRepository(), parent, false, new ICVSRunnable() {
 				public void run(IProgressMonitor monitor) throws CVSException {
 					IStatus status = Command.UPDATE.execute(
 						Command.NO_GLOBAL_OPTIONS,
 						new LocalOption[] {
 							Update.makeTagOption(new CVSTag(info.getRevision(), CVSTag.VERSION)),
 							Update.IGNORE_LOCAL_CHANGES },
 						new ICVSResource[] { RemoteFile.this },
 						null,
 						monitor);
 					if (status.getCode() == CVSStatus.SERVER_ERROR) {
 						throw new CVSServerException(status);
 					}
 				}
 			}, Policy.subMonitorFor(monitor, 100));

 			// If the update succeeded but no contents were retreived from the server
 			// than we can assume that the remote file has no contents.
 			if (contents == null) {
 				// The above is true unless there is a cache file
 				cached = getCachedContents();
 				if (cached != null) {
 					return cached;
 				} else {
 					contents = new byte[0];
 				}
 			}
 		}
 		return new ByteArrayInputStream(contents);
 	}

 	/*
 	 * @see ICVSRemoteFile#getLogEntry(IProgressMonitor)
 	 */
 	public ILogEntry getLogEntry(IProgressMonitor monitor) throws CVSException {
 		if (entry == null) {
 			Session.run(getRepository(), parent, false, new ICVSRunnable() {
 				public void run(IProgressMonitor monitor) throws CVSException {
 					monitor = Policy.monitorFor(monitor);
 					monitor.beginTask(Policy.bind("RemoteFile.getLogEntries"), 100); //$NON-NLS-1$
 					try {
 						final List entries = new ArrayList();
 						IStatus status = Command.LOG.execute(
 							Command.NO_GLOBAL_OPTIONS,
 							new LocalOption[] {
 								Command.LOG.makeRevisionOption(info.getRevision())},
 							new ICVSResource[] { RemoteFile.this },
 							new LogListener(RemoteFile.this, entries),
 							Policy.subMonitorFor(monitor, 100));
 						if (entries.size() == 1) {
 							entry = (ILogEntry)entries.get(0);
 						}
 						if (status.getCode() == CVSStatus.SERVER_ERROR) {
 							throw new CVSServerException(status);
 						}
 					} finally {
 						monitor.done();
 					}
 				}
 			}, monitor);
 		}
 		return entry;
 	}

 	/**
 	 * @see ICVSRemoteFile#getLogEntries()
 	 */
 	public ILogEntry[] getLogEntries(IProgressMonitor monitor) throws CVSException {
 		final List entries = new ArrayList();
 		Session.run(getRepository(), parent, false, new ICVSRunnable() {
 			public void run(IProgressMonitor monitor) throws CVSException {
 				monitor = Policy.monitorFor(monitor);
 				monitor.beginTask(Policy.bind("RemoteFile.getLogEntries"), 100); //$NON-NLS-1$
 				QuietOption quietness = CVSProviderPlugin.getPlugin().getQuietness();
 				try {
 					CVSProviderPlugin.getPlugin().setQuietness(Command.VERBOSE);
 					IStatus status = Command.LOG.execute(Command.NO_GLOBAL_OPTIONS, Command.NO_LOCAL_OPTIONS,
 						new ICVSResource[] { RemoteFile.this }, new LogListener(RemoteFile.this, entries),
 						Policy.subMonitorFor(monitor, 100));
 					if (status.getCode() == CVSStatus.SERVER_ERROR) {
 						throw new CVSServerException(status);
 					}
 				} finally {
 					CVSProviderPlugin.getPlugin().setQuietness(quietness);
 					monitor.done();
 				}
 			}
 		}, monitor);
 		return (ILogEntry[])entries.toArray(new ILogEntry[entries.size()]);
 	}

 	/**
 	 * @see ICVSRemoteFile#getRevision()
 	 */
 	public String getRevision() {
 		return info.getRevision();
 	}

 	/*
 	 * Get a different revision of the remote file.
 	 *
 	 * We must also create a new parent since the child is accessed through the parent from within CVS commands.
 	 * Therefore, we need a new parent so that we can fecth the contents of the remote file revision
 	 */
 	public RemoteFile toRevision(String revision) {
 		RemoteFolder newParent = new RemoteFolder(null, parent.getRepository(), new Path(parent.getRepositoryRelativePath()), parent.getTag());
 		RemoteFile file = new RemoteFile(newParent, getWorkspaceSyncState(), getName(), revision, CVSTag.DEFAULT);
 		newParent.setChildren(new ICVSRemoteResource[] {file});
 		return file;
 	}

 	/**
 	 * @see ICVSFile#getSize()
 	 */
 	public long getSize() {
 		if (contents == null) {
 			try {
 				File ioFile = getCacheFile();
 				if (ioFile.exists()) {
 					return ioFile.length();
 				}
 			} catch (IOException e) {
 				// Try to purge the cache and continue
 				try {
 					clearCachedContents();
 				} catch (IOException e2) {
 				}
 				CVSProviderPlugin.log(CVSException.wrapException(e).getStatus());
 			}
 		}
 		return contents == null ? 0 : contents.length;
 	}

 	/**
 	 * @see ICVSFile#getSyncInfo()
 	 */
 	public ResourceSyncInfo getSyncInfo() {
 		return info;
 	}

 	/**
 	 * @see ICVSResource#getRemoteLocation(ICVSFolder)
 	 */
 	public String getRemoteLocation(ICVSFolder stopSearching) throws CVSException {
 		return parent.getRemoteLocation(stopSearching) + Session.SERVER_SEPARATOR + getName();
 	}

 	/**
 	 * Get the remote path for the receiver relative to the repository location path
 	 */
 	public String getRepositoryRelativePath() {
 		String parentPath = parent.getRepositoryRelativePath();
 		return parentPath + Session.SERVER_SEPARATOR + getName();
 	}

 	/**
 	 * Return the server root directory for the repository
 	 */
 	public ICVSRepositoryLocation getRepository() {
 		return parent.getRepository();
 	}

 	/**
 	 * @see IManagedFile#setFileInfo(FileProperties)
 	 */
 	public void setSyncInfo(ResourceSyncInfo fileInfo) {
 		info = fileInfo;
 	}

 	/**
 	 * Set the revision for this remote file.
 	 *
 	 * @param revision to associated with this remote file
 	 */
 	public void setRevision(String revision) {
 		MutableResourceSyncInfo newInfo = getSyncInfo().cloneMutable();
 		newInfo.setRevision(revision);
 		info = newInfo;
 	}

 	public InputStream getContents() throws CVSException {
 		if (contents == null) {
 			// Check for cached contents for the file
 			InputStream cached = getCachedContents();
 			if (cached != null) {
 				return cached;
 			}
 		}
 		return new ByteArrayInputStream(contents == null ? new byte[0] : contents);
 	}

 	public void setContents(InputStream stream, int responseType, boolean keepLocalHistory, IProgressMonitor monitor) throws CVSException {
 		try {
 			try {
 				byte[] buffer = new byte[1024];
 				ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
 				OutputStream out = byteStream;
 				int read;
 				try {
 					try {
 						while ((read = stream.read(buffer)) >= 0) {
 							Policy.checkCanceled(monitor);
 							out.write(buffer, 0, read);
 							// Detect when the file is getting too big to keep in memory
 							// and switch to a caching strategy for the contents of the file
 							if (out == byteStream && byteStream.size() > CACHING_THRESHOLD) {
 								// Switch streams
 								byteStream.close();
 								out = switchToCacheOutputStream(byteStream);
 								// Continue looping until the whole file is read
 							}
 						}
 					} finally {
 						out.close();
 					}
 				} catch (IOException e) {
 					// Make sure we don't leave the cache file around as it may not have the right contents
 					if (byteStream != out) {
 						clearCachedContents();
 					}
 					throw e;
 				}

 				// Set the contents if we didn't cache them to disk
 				if (out == byteStream) {
 					contents = byteStream.toByteArray();
 				} else {
 					contents = null;
 				}
 			} finally {
 				stream.close();
 			}
 		} catch(IOException e) {
 			throw CVSException.wrapException(e);
 		}
 	}

 	/*
 	 * @see ICVSFile#setReadOnly(boolean)
 	 */
 	public void setReadOnly(boolean readOnly) throws CVSException {
  	}

 	/*
 	 * @see ICVSFile#isReadOnly()
 	 */
 	public boolean isReadOnly() throws CVSException {
 		return true;
 	}

 	/*
 	 * @see ICVSFile#getTimeStamp()
 	 */
 	public Date getTimeStamp() {
 		return info.getTimeStamp();
 	}

 	/*
 	 * @see ICVSFile#setTimeStamp(Date)
 	 */
 	public void setTimeStamp(Date date) throws CVSException {
 	}

 	public boolean isModified() throws CVSException {
 		// it is safe to always consider a remote file handle as modified. This will cause any
 		// CVS command to fetch new contents from the server.
 		return true;
 	}

 	/**
 	 * @see IManagedFile#moveTo(IManagedFile)
 	 */
 	public void copyTo(String mFile) throws CVSException, ClassCastException {
 		// Do nothing
 	}

 	/*
 	 * @see IRemoteResource#members(IProgressMonitor)
 	 */
 	public IRemoteResource[] members(IProgressMonitor progress) throws TeamException {
 		return new IRemoteResource[0];
 	}

 	/*
 	 * @see IRemoteResource#isContainer()
 	 */
 	public boolean isContainer() {
 		return false;
 	}

 	/*
 	 * @see ICVSResource#isFolder()
 	 */
 	public boolean isFolder() {
 		return false;
 	}

 	/*
 	 * @see ICVSResource#tag(CVSTag, LocalOption[], IProgressMonitor)
 	 *
 	 * The revision of the remote file is used as the base for the tagging operation
 	 */
 	 public IStatus tag(final CVSTag tag, final LocalOption[] localOptions, IProgressMonitor monitor) throws CVSException {
 		final IStatus[] result = new IStatus[] { null };
 		Session.run(getRepository(), this.getParent(), true, new ICVSRunnable() {
 			public void run(IProgressMonitor monitor) throws CVSException {
 				result[0] = Command.RTAG.execute(
 					Command.NO_GLOBAL_OPTIONS,
 					localOptions,
 					new CVSTag(getRevision(), CVSTag.VERSION),
 					tag,
 					new ICVSRemoteResource[] { RemoteFile.this },
 					monitor);
 			}
 		}, monitor);
 		return result[0];
 	 }

 	public boolean updateRevision(CVSTag tag, IProgressMonitor monitor) throws CVSException {
 		return parent.updateRevision(this, tag, monitor);
 	}

 	public boolean equals(Object target) {
 		if (this == target)
 			return true;
 		if (!(target instanceof RemoteFile))
 			return false;
 		RemoteFile remote = (RemoteFile) target;
 		return super.equals(target) && remote.getRevision().equals(getRevision());
 	}

 	/*
 	 * Return the cache relative path for the receiver as
 	 *   host/cvs/root/module/path/.#filename revision
 	 */
 	private String getCacheRelativePath() {
 		ICVSRepositoryLocation location = getRepository();
 		IPath path = new Path(location.getHost());
 		path = path.append(location.getRootDirectory());
 		path = path.append(parent.getRepositoryRelativePath());
 		path = path.append(getName() + ' ' + getRevision());
 		return path.toString();
 	}

 	private File getCacheFile() throws IOException {
 		return CVSProviderPlugin.getPlugin().getCacheFileFor(getCacheRelativePath());
 	}

 	private void clearCachedContents() throws IOException {
 		try {
 			File ioFile =  getCacheFile();
 			if (ioFile.exists()) {
 				ioFile.delete();
 			}
 		} catch (IOException e) {
 			CVSProviderPlugin.log(CVSException.wrapException(e).getStatus());
 		}
 	}

 	private InputStream getCachedContents() throws CVSException {
 		try {
 			try {
 				File ioFile = getCacheFile();
 				if (ioFile.exists()) {
 					return new BufferedInputStream(new FileInputStream(ioFile));
 				}
 			} catch (IOException e) {
 				// Try to purge the cache and continue
 				clearCachedContents();
 				throw e;
 			}
 		} catch (IOException e) {
 			// We will end up here if we couldn't read or delete the cache file
 			throw new CVSException(new CVSStatus(IStatus.ERROR, 0, Policy.bind("RemoteFile.errorRetrievingFromCache", e.getMessage()), e));//$NON-NLS-1$
 		}
 		return null;
 	}

 	private OutputStream switchToCacheOutputStream(ByteArrayOutputStream byteStream) throws IOException {
 		// Get the cache file and make sure it's parent exists
 		File ioFile = getCacheFile();
 		if ( ! ioFile.getParentFile().exists()) {
 			ioFile.getParentFile().mkdirs();
 		}
 		// Switch streams
 		OutputStream out = new BufferedOutputStream(new FileOutputStream(ioFile));
 		// Write what we've read so far
 		out.write(byteStream.toByteArray());
 		return out;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2002 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Common Public License v0.5
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/cpl-v05.html
	*
	* Contributors:
	* IBM - Initial API and implementation
	******************************************************************************/
	package org.eclipse.team.internal.ccvs.core.resources;

	import java.io.BufferedInputStream;
	import java.io.BufferedOutputStream;
	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.ArrayList;
	import java.util.Date;
	import java.util.List;

	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.team.core.TeamException;
	import org.eclipse.team.core.sync.IRemoteResource;
	import org.eclipse.team.internal.ccvs.core.CVSException;
	import org.eclipse.team.internal.ccvs.core.CVSProviderPlugin;
	import org.eclipse.team.internal.ccvs.core.CVSStatus;
	import org.eclipse.team.internal.ccvs.core.CVSTag;
	import org.eclipse.team.internal.ccvs.core.ICVSFile;
	import org.eclipse.team.internal.ccvs.core.ICVSFolder;
	import org.eclipse.team.internal.ccvs.core.ICVSRemoteFile;
	import org.eclipse.team.internal.ccvs.core.ICVSRemoteResource;
	import org.eclipse.team.internal.ccvs.core.ICVSRepositoryLocation;
	import org.eclipse.team.internal.ccvs.core.ICVSResource;
	import org.eclipse.team.internal.ccvs.core.ICVSResourceVisitor;
	import org.eclipse.team.internal.ccvs.core.ICVSRunnable;
	import org.eclipse.team.internal.ccvs.core.ILogEntry;
	import org.eclipse.team.internal.ccvs.core.Policy;
	import org.eclipse.team.internal.ccvs.core.client.Command;
	import org.eclipse.team.internal.ccvs.core.client.Session;
	import org.eclipse.team.internal.ccvs.core.client.Update;
	import org.eclipse.team.internal.ccvs.core.client.Command.LocalOption;
	import org.eclipse.team.internal.ccvs.core.client.Command.QuietOption;
	import org.eclipse.team.internal.ccvs.core.client.listeners.LogListener;
	import org.eclipse.team.internal.ccvs.core.connection.CVSServerException;
	import org.eclipse.team.internal.ccvs.core.syncinfo.MutableResourceSyncInfo;
	import org.eclipse.team.internal.ccvs.core.syncinfo.ResourceSyncInfo;
	import org.eclipse.team.internal.ccvs.core.util.Util;

	/**
	* This class provides the implementation of ICVSRemoteFile and IManagedFile for
	* use by the repository and sync view.
	*/
	public class RemoteFile extends RemoteResource implements ICVSRemoteFile {

	// Contents will be cached to disk when this thrshold is exceeded
	private static final int CACHING_THRESHOLD = 32768;

	// buffer for file contents received from the server
	private byte[] contents;
	// cach the log entry for the remote file
	private ILogEntry entry;

	/**
	* Static method which creates a file as a single child of its parent.
	* This should only be used when one is only interested in the file alone.
	*
	* The returned RemoteFile represents the base of the local resource.
	* If the local resource does not have a base, then null is returned
	* even if the resource does exists remotely (e.g. created by another party).
	*/
	public static RemoteFile getBase(RemoteFolder parent, ICVSFile managed) throws CVSException {
	ResourceSyncInfo info = managed.getSyncInfo();
	if ((info == null) \|\| info.isAdded()) {
	// Either the file is unmanaged or has just been added (i.e. doesn't necessarily have a remote)
	return null;
	}
	RemoteFile file = new RemoteFile(parent, managed.getSyncInfo());
	parent.setChildren(new ICVSRemoteResource[] {file});
	return file;
	}

	/**
	* Constructor for RemoteFile that should be used when nothing is know about the
	* file ahead of time.
	*/
	// XXX do we need the first two constructors?
	public RemoteFile(RemoteFolder parent, int workspaceSyncState, String name, CVSTag tag) {
	this(parent, workspaceSyncState, name, "", tag); //$NON-NLS-1$
	MutableResourceSyncInfo newInfo = info.cloneMutable();
	newInfo.setAdded();
	}

	public RemoteFile(RemoteFolder parent, int workspaceSyncState, String name, String revision, CVSTag tag) {
	this(parent, workspaceSyncState, null);
	MutableResourceSyncInfo newInfo = new MutableResourceSyncInfo(name, revision);
	newInfo.setKeywordMode(Command.KSUBST_TEXT_EXPAND);
	newInfo.setTag(tag);
	info = newInfo;
	}

	public RemoteFile(RemoteFolder parent, ResourceSyncInfo info) {
	this(parent, Update.STATE_NONE, info);
	}

	public RemoteFile(RemoteFolder parent, int workspaceSyncState, ResourceSyncInfo newInfo) {
	this.parent = parent;
	info = newInfo;
	setWorkspaceSyncState(workspaceSyncState);
	}

	/**
	* @see ICVSResource#accept(IManagedVisitor)
	*/
	public void accept(ICVSResourceVisitor visitor) throws CVSException {
	visitor.visitFile(this);
	}

	/**
	* @see ICVSRemoteFile#getContents()
	*/
	public InputStream getContents(IProgressMonitor monitor) throws CVSException {
	if (contents == null) {
	// First, check to see if there's a cached contents for the file
	InputStream cached = getCachedContents();
	if (cached != null) {
	return cached;
	}

	// We need to fetch the contents from the server
	monitor.beginTask(Policy.bind("RemoteFile.getContents"), 100);//$NON-NLS-1$
	Session.run(getRepository(), parent, false, new ICVSRunnable() {
	public void run(IProgressMonitor monitor) throws CVSException {
	IStatus status = Command.UPDATE.execute(
	Command.NO_GLOBAL_OPTIONS,
	new LocalOption[] {
	Update.makeTagOption(new CVSTag(info.getRevision(), CVSTag.VERSION)),
	Update.IGNORE_LOCAL_CHANGES },
	new ICVSResource[] { RemoteFile.this },
	null,
	monitor);
	if (status.getCode() == CVSStatus.SERVER_ERROR) {
	throw new CVSServerException(status);
	}
	}
	}, Policy.subMonitorFor(monitor, 100));

	// If the update succeeded but no contents were retreived from the server
	// than we can assume that the remote file has no contents.
	if (contents == null) {
	// The above is true unless there is a cache file
	cached = getCachedContents();
	if (cached != null) {
	return cached;
	} else {
	contents = new byte[0];
	}
	}
	}
	return new ByteArrayInputStream(contents);
	}

	/*
	* @see ICVSRemoteFile#getLogEntry(IProgressMonitor)
	*/
	public ILogEntry getLogEntry(IProgressMonitor monitor) throws CVSException {
	if (entry == null) {
	Session.run(getRepository(), parent, false, new ICVSRunnable() {
	public void run(IProgressMonitor monitor) throws CVSException {
	monitor = Policy.monitorFor(monitor);
	monitor.beginTask(Policy.bind("RemoteFile.getLogEntries"), 100); //$NON-NLS-1$
	try {
	final List entries = new ArrayList();
	IStatus status = Command.LOG.execute(
	Command.NO_GLOBAL_OPTIONS,
	new LocalOption[] {
	Command.LOG.makeRevisionOption(info.getRevision())},
	new ICVSResource[] { RemoteFile.this },
	new LogListener(RemoteFile.this, entries),
	Policy.subMonitorFor(monitor, 100));
	if (entries.size() == 1) {
	entry = (ILogEntry)entries.get(0);
	}
	if (status.getCode() == CVSStatus.SERVER_ERROR) {
	throw new CVSServerException(status);
	}
	} finally {
	monitor.done();
	}
	}
	}, monitor);
	}
	return entry;
	}

	/**
	* @see ICVSRemoteFile#getLogEntries()
	*/
	public ILogEntry[] getLogEntries(IProgressMonitor monitor) throws CVSException {
	final List entries = new ArrayList();
	Session.run(getRepository(), parent, false, new ICVSRunnable() {
	public void run(IProgressMonitor monitor) throws CVSException {
	monitor = Policy.monitorFor(monitor);
	monitor.beginTask(Policy.bind("RemoteFile.getLogEntries"), 100); //$NON-NLS-1$
	QuietOption quietness = CVSProviderPlugin.getPlugin().getQuietness();
	try {
	CVSProviderPlugin.getPlugin().setQuietness(Command.VERBOSE);
	IStatus status = Command.LOG.execute(Command.NO_GLOBAL_OPTIONS, Command.NO_LOCAL_OPTIONS,
	new ICVSResource[] { RemoteFile.this }, new LogListener(RemoteFile.this, entries),
	Policy.subMonitorFor(monitor, 100));
	if (status.getCode() == CVSStatus.SERVER_ERROR) {
	throw new CVSServerException(status);
	}
	} finally {
	CVSProviderPlugin.getPlugin().setQuietness(quietness);
	monitor.done();
	}
	}
	}, monitor);
	return (ILogEntry[])entries.toArray(new ILogEntry[entries.size()]);
	}

	/**
	* @see ICVSRemoteFile#getRevision()
	*/
	public String getRevision() {
	return info.getRevision();
	}

	/*
	* Get a different revision of the remote file.
	*
	* We must also create a new parent since the child is accessed through the parent from within CVS commands.
	* Therefore, we need a new parent so that we can fecth the contents of the remote file revision
	*/
	public RemoteFile toRevision(String revision) {
	RemoteFolder newParent = new RemoteFolder(null, parent.getRepository(), new Path(parent.getRepositoryRelativePath()), parent.getTag());
	RemoteFile file = new RemoteFile(newParent, getWorkspaceSyncState(), getName(), revision, CVSTag.DEFAULT);
	newParent.setChildren(new ICVSRemoteResource[] {file});
	return file;
	}

	/**
	* @see ICVSFile#getSize()
	*/
	public long getSize() {
	if (contents == null) {
	try {
	File ioFile = getCacheFile();
	if (ioFile.exists()) {
	return ioFile.length();
	}
	} catch (IOException e) {
	// Try to purge the cache and continue
	try {
	clearCachedContents();
	} catch (IOException e2) {
	}
	CVSProviderPlugin.log(CVSException.wrapException(e).getStatus());
	}
	}
	return contents == null ? 0 : contents.length;
	}

	/**
	* @see ICVSFile#getSyncInfo()
	*/
	public ResourceSyncInfo getSyncInfo() {
	return info;
	}

	/**
	* @see ICVSResource#getRemoteLocation(ICVSFolder)
	*/
	public String getRemoteLocation(ICVSFolder stopSearching) throws CVSException {
	return parent.getRemoteLocation(stopSearching) + Session.SERVER_SEPARATOR + getName();
	}

	/**
	* Get the remote path for the receiver relative to the repository location path
	*/
	public String getRepositoryRelativePath() {
	String parentPath = parent.getRepositoryRelativePath();
	return parentPath + Session.SERVER_SEPARATOR + getName();
	}

	/**
	* Return the server root directory for the repository
	*/
	public ICVSRepositoryLocation getRepository() {
	return parent.getRepository();
	}

	/**
	* @see IManagedFile#setFileInfo(FileProperties)
	*/
	public void setSyncInfo(ResourceSyncInfo fileInfo) {
	info = fileInfo;
	}

	/**
	* Set the revision for this remote file.
	*
	* @param revision to associated with this remote file
	*/
	public void setRevision(String revision) {
	MutableResourceSyncInfo newInfo = getSyncInfo().cloneMutable();
	newInfo.setRevision(revision);
	info = newInfo;
	}

	public InputStream getContents() throws CVSException {
	if (contents == null) {
	// Check for cached contents for the file
	InputStream cached = getCachedContents();
	if (cached != null) {
	return cached;
	}
	}
	return new ByteArrayInputStream(contents == null ? new byte[0] : contents);
	}

	public void setContents(InputStream stream, int responseType, boolean keepLocalHistory, IProgressMonitor monitor) throws CVSException {
	try {
	try {
	byte[] buffer = new byte[1024];
	ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
	OutputStream out = byteStream;
	int read;
	try {
	try {
	while ((read = stream.read(buffer)) >= 0) {
	Policy.checkCanceled(monitor);
	out.write(buffer, 0, read);
	// Detect when the file is getting too big to keep in memory
	// and switch to a caching strategy for the contents of the file
	if (out == byteStream && byteStream.size() > CACHING_THRESHOLD) {
	// Switch streams
	byteStream.close();
	out = switchToCacheOutputStream(byteStream);
	// Continue looping until the whole file is read
	}
	}
	} finally {
	out.close();
	}
	} catch (IOException e) {
	// Make sure we don't leave the cache file around as it may not have the right contents
	if (byteStream != out) {
	clearCachedContents();
	}
	throw e;
	}

	// Set the contents if we didn't cache them to disk
	if (out == byteStream) {
	contents = byteStream.toByteArray();
	} else {
	contents = null;
	}
	} finally {
	stream.close();
	}
	} catch(IOException e) {
	throw CVSException.wrapException(e);
	}
	}

	/*
	* @see ICVSFile#setReadOnly(boolean)
	*/
	public void setReadOnly(boolean readOnly) throws CVSException {
	}

	/*
	* @see ICVSFile#isReadOnly()
	*/
	public boolean isReadOnly() throws CVSException {
	return true;
	}

	/*
	* @see ICVSFile#getTimeStamp()
	*/
	public Date getTimeStamp() {
	return info.getTimeStamp();
	}

	/*
	* @see ICVSFile#setTimeStamp(Date)
	*/
	public void setTimeStamp(Date date) throws CVSException {
	}

	public boolean isModified() throws CVSException {
	// it is safe to always consider a remote file handle as modified. This will cause any
	// CVS command to fetch new contents from the server.
	return true;
	}

	/**
	* @see IManagedFile#moveTo(IManagedFile)
	*/
	public void copyTo(String mFile) throws CVSException, ClassCastException {
	// Do nothing
	}

	/*
	* @see IRemoteResource#members(IProgressMonitor)
	*/
	public IRemoteResource[] members(IProgressMonitor progress) throws TeamException {
	return new IRemoteResource[0];
	}

	/*
	* @see IRemoteResource#isContainer()
	*/
	public boolean isContainer() {
	return false;
	}

	/*
	* @see ICVSResource#isFolder()
	*/
	public boolean isFolder() {
	return false;
	}

	/*
	* @see ICVSResource#tag(CVSTag, LocalOption[], IProgressMonitor)
	*
	* The revision of the remote file is used as the base for the tagging operation
	*/
	public IStatus tag(final CVSTag tag, final LocalOption[] localOptions, IProgressMonitor monitor) throws CVSException {
	final IStatus[] result = new IStatus[] { null };
	Session.run(getRepository(), this.getParent(), true, new ICVSRunnable() {
	public void run(IProgressMonitor monitor) throws CVSException {
	result[0] = Command.RTAG.execute(
	Command.NO_GLOBAL_OPTIONS,
	localOptions,
	new CVSTag(getRevision(), CVSTag.VERSION),
	tag,
	new ICVSRemoteResource[] { RemoteFile.this },
	monitor);
	}
	}, monitor);
	return result[0];
	}

	public boolean updateRevision(CVSTag tag, IProgressMonitor monitor) throws CVSException {
	return parent.updateRevision(this, tag, monitor);
	}

	public boolean equals(Object target) {
	if (this == target)
	return true;
	if (!(target instanceof RemoteFile))
	return false;
	RemoteFile remote = (RemoteFile) target;
	return super.equals(target) && remote.getRevision().equals(getRevision());
	}

	/*
	* Return the cache relative path for the receiver as
	* host/cvs/root/module/path/.#filename revision
	*/
	private String getCacheRelativePath() {
	ICVSRepositoryLocation location = getRepository();
	IPath path = new Path(location.getHost());
	path = path.append(location.getRootDirectory());
	path = path.append(parent.getRepositoryRelativePath());
	path = path.append(getName() + ' ' + getRevision());
	return path.toString();
	}

	private File getCacheFile() throws IOException {
	return CVSProviderPlugin.getPlugin().getCacheFileFor(getCacheRelativePath());
	}

	private void clearCachedContents() throws IOException {
	try {
	File ioFile = getCacheFile();
	if (ioFile.exists()) {
	ioFile.delete();
	}
	} catch (IOException e) {
	CVSProviderPlugin.log(CVSException.wrapException(e).getStatus());
	}
	}

	private InputStream getCachedContents() throws CVSException {
	try {
	try {
	File ioFile = getCacheFile();
	if (ioFile.exists()) {
	return new BufferedInputStream(new FileInputStream(ioFile));
	}
	} catch (IOException e) {
	// Try to purge the cache and continue
	clearCachedContents();
	throw e;
	}
	} catch (IOException e) {
	// We will end up here if we couldn't read or delete the cache file
	throw new CVSException(new CVSStatus(IStatus.ERROR, 0, Policy.bind("RemoteFile.errorRetrievingFromCache", e.getMessage()), e));//$NON-NLS-1$
	}
	return null;
	}

	private OutputStream switchToCacheOutputStream(ByteArrayOutputStream byteStream) throws IOException {
	// Get the cache file and make sure it's parent exists
	File ioFile = getCacheFile();
	if ( ! ioFile.getParentFile().exists()) {
	ioFile.getParentFile().mkdirs();
	}
	// Switch streams
	OutputStream out = new BufferedOutputStream(new FileOutputStream(ioFile));
	// Write what we've read so far
	out.write(byteStream.toByteArray());
	return out;
	}
	}