CIFSFileRepository

package com.trendmicro.grid.acl.ds.cifs;

import jcifs.smb.SmbException;
import jcifs.smb.SmbFile;
import jcifs.smb.SmbFileInputStream;
import jcifs.smb.SmbFileOutputStream;
import jcifs.util.transport.TransportException;
import net.sf.tinyjee.config.Connection;
import net.sf.tinyjee.config.PropertySection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;

import java.io.*;
import java.net.MalformedURLException;
import java.net.UnknownHostException;
import java.security.NoSuchAlgorithmException;
import java.util.Collection;
import java.util.Date;

import static com.trendmicro.grid.acl.ds.cifs.CIFSPropertySection.*;
import static jcifs.smb.NtStatus.NT_STATUS_NO_SUCH_FILE;
import static jcifs.smb.NtStatus.NT_STATUS_OBJECT_PATH_NOT_FOUND;

/**
 * Implements the FileRepository API using a CIFS / Samba backend.
 *
 * @author juergen_kellerer, 2010-05-05
 * @version 1.0
 */
@Repository
public class CIFSFileRepository extends AbstractStructuredFileRepository {

	private static final Logger log = LoggerFactory.getLogger(CIFSFileRepository.class);

	/**
	 * Is the NT status code when a rename fails as 2 paths are on different devices.
	 */
	public static final int NT_NOT_SAME_DEVICE = 0xC00000D4;

	private CIFSLoginHandler loginHandler;

	public CIFSFileRepository() {
	}

	public CIFSFileRepository(String hostname, String pathPrefix, String domain, String username, String password) {
		Collection<Connection> connections = getCIFSConnections();
		connections.clear();
		connections.add(createCIFSConnection(hostname, pathPrefix, domain, username, password));
	}


	/**
	 * {@inheritDoc}
	 */
	@Override
	protected void initialize(PropertySection section) throws NoSuchAlgorithmException {
		super.initialize(section);

		for (Connection connection : getCIFSConnections()) {

			final String hostname = connection.getAddressValue();
			String pathPrefix = connection.getPropertyValue(KEY_CONNECTION_PATH_PREFIX, "").replace('\\', '/');
			if (!pathPrefix.isEmpty() && !pathPrefix.endsWith("/"))
				pathPrefix = pathPrefix.concat("/");


			if (hostname == null || hostname.isEmpty()) {
				log.error("TMACL-01410:No cifs host was defined, CIFS file repository will be unavailable.");
				continue;
			}

			loginHandler = new CIFSLoginHandler(hostname, pathPrefix);

			String domain = connection.getPropertyValue(KEY_CONNECTION_DOMAIN, null);
			String username = connection.getPropertyValue(KEY_CONNECTION_USERNAME, null);
			String password = connection.getPropertyValue(KEY_CONNECTION_PASSWORD, "");
			loginHandler.loginAsynchronously(domain, username, password);

			break;
		}
	}

	/**
	 * Fixes the bad exception design the the JCIFS library that prevents a full log output when exceptions occure.
	 *
	 * @param e the exception to fix.
	 */
	static void fixExceptionChain(Throwable e) {
		if (e == null)
			return;

		if (e instanceof SmbException) {
			SmbException se = (SmbException) e;
			if (se.getRootCause() != null && se.getCause() == null)
				se.initCause(se.getRootCause());
		} else if (e instanceof TransportException) {
			TransportException te = (TransportException) e;
			if (te.getRootCause() != null && te.getCause() == null)
				te.initCause(te.getRootCause());
		}

		fixExceptionChain(e.getCause());
	}

	private static FileNotFoundException createFileNotFound(Throwable cause) throws FileNotFoundException {
		fixExceptionChain(cause);
		FileNotFoundException e = new FileNotFoundException(cause.getMessage());
		e.initCause(cause);
		return e;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected String getBaseURI(String baseURI) {
		try {
			return baseURI.isEmpty() ? loginHandler.getAuthenticatedRepositoryBaseURI() : baseURI;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	private SmbFile toTargetFile(String path, boolean createPathIfMissing) throws FileNotFoundException {
		try {
			final SmbFile basePath = loginHandler.getAuthenticatedRepositoryBasePath();
			final SmbFile file = new SmbFile(basePath, path);

			if (createPathIfMissing) {
				String parent = file.getParent();
				SmbFile parentFile = new SmbFile(basePath, parent);
				if (!parentFile.isDirectory()) {
					if (log.isTraceEnabled())
						log.trace("Creating directory on CIFS host with address '{}'", parentFile.getURL());
					parentFile.mkdirs();
				}
			}

			return file;

		} catch (MalformedURLException e) {
			throw createFileNotFound(e);
		} catch (UnknownHostException e) {
			loginHandler.forceReLogin();
			throw createFileNotFound(e);
		} catch (SmbException e) {
			loginHandler.forceReLogin();
			throw createFileNotFound(e);
		}
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected boolean isExisting(String path) {
		try {
			// !! don't use "exists()" it spawns lot of "Query Threads" !!
			return !"".equals(path) && toTargetFile(path, false).isFile();
		} catch (Exception e) {
			return false;
		}
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected Date getLastModified(String path) {
		try {
			if (path.equals(""))
				return null;
			long lm = toTargetFile(path, false).lastModified();
			return lm == 0L ? null : new Date(lm);
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected OutputStream openForWrite(String path)
			throws IllegalStateException, FileNotFoundException {
		try {
			return new BufferedOutputStream(new SmbFileOutputStream(toTargetFile(path, true)));
		} catch (MalformedURLException e) {
			log.error("TMACL-01230:Can't open '" + path + "' for writing, the path is invalid.", e);
			throw createFileNotFound(e);
		} catch (UnknownHostException e) {
			throw createFileNotFound(e);
		} catch (SmbException e) {
			log.error("TMACL-01240:Can't open '" + path + "' for writing.", e);
			throw createFileNotFound(e);
		}
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected InputStream openForRead(String path) throws FileNotFoundException {
		try {
			return new BufferedInputStream(new SmbFileInputStream(toTargetFile(path, false)));
		} catch (MalformedURLException e) {
			log.error("TMACL-01250:Can't open '" + path + "' for reading, the path is invalid.", e);
			throw createFileNotFound(e);
		} catch (UnknownHostException e) {
			throw createFileNotFound(e);
		} catch (SmbException e) {
			if (e.getNtStatus() == NT_STATUS_NO_SUCH_FILE || e.getNtStatus() == NT_STATUS_OBJECT_PATH_NOT_FOUND) {
				log.error("TMACL-01261:Can't open '" + path + "' for reading, the file does not exist.");
				throw new FileNotFoundException(e.getMessage());
			} else
				log.error("TMACL-01260:Can't open '" + path + "' for reading.", e);
			throw createFileNotFound(e);
		}
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected void rename(String fromPath, String toPath) throws FileNotFoundException {
		SmbFile from = toTargetFile(fromPath, false);
		try {
			if (from.isFile()) {
				SmbFile to = toTargetFile(toPath, true);
				try {
					from.renameTo(to);
				} catch (SmbException e) {
					if (e.getNtStatus() == NT_NOT_SAME_DEVICE) {
						if (log.isDebugEnabled())
							log.debug("Failed renaming file '{}' to '{}', falling back to file copy.", from, to);
						from.copyTo(to);
						if (log.isDebugEnabled())
							log.debug("Successfully copied file '{}' to '{}', deleting the source now.", from, to);
						from.delete();
					} else
						throw e;
				}
			} else
				throw new FileNotFoundException(from + " is not a file or does not exist.");
		} catch (FileNotFoundException e) {
			log.error("TMACL-01270:Can't rename '" + fromPath + "' to '" + toPath + "'.", e);
			throw e;
		} catch (SmbException e) {
			log.error("TMACL-01280:Can't rename '" + fromPath + "' to '" + toPath + "'.", e);
			throw createFileNotFound(e);
		}
	}
}