xref: /external/mockftpserver/tags/2.4/src/main/java/org/mockftpserver/fake/FakeFtpServer.java

/*
 * Copyright 2008 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.mockftpserver.fake;

import org.mockftpserver.core.command.CommandHandler;
import org.mockftpserver.core.command.CommandNames;
import org.mockftpserver.core.command.ConnectCommandHandler;
import org.mockftpserver.core.command.ReplyTextBundleUtil;
import org.mockftpserver.core.command.UnsupportedCommandHandler;
import org.mockftpserver.core.server.AbstractFtpServer;
import org.mockftpserver.fake.command.*;
import org.mockftpserver.fake.filesystem.FileSystem;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <b>FakeFtpServer</b> is the top-level class for a "fake" implementation of an FTP Server,
 * suitable for testing FTP client code or standing in for a live FTP server.
 * <p/>
 * <b>FakeFtpServer</b> provides a high-level abstraction for an FTP Server and is suitable
 * for most testing and simulation scenarios. You define a filesystem (internal, in-memory) containing
 * an arbitrary set of files and directories. These files and directories can (optionally) have
 * associated access permissions. You also configure a set of one or more user accounts that
 * control which users can login to the FTP server, and their home (default) directories. The
 * user account is also used when assigning file and directory ownership for new files.
 * <p> <b>FakeFtpServer</b> processes FTP client requests and responds with reply codes and
 * reply messages consistent with its configuration and the contents of its internal filesystem,
 * including file and directory permissions, if they have been configured.
 * <p/>
 * <b>FakeFtpServer</b> can be fully configured programmatically or within the
 * <a href="http://www.springframework.org/">Spring Framework</a> or other dependency-injection container.
 * <p/>
 * In general the steps for setting up and starting the <b>FakeFtpServer</b> are:
 * <ol>
 * <li>Create a new <b>FakeFtpServer</b> instance, and optionally set the server control port.</li>
 * <li>Create and configure a <b>FileSystem</b>, and attach to the <b>FakeFtpServer</b> instance.</li>
 * <li>Create and configure one or more <b>UserAccount</b> objects and attach to the <b>FakeFtpServer</b> instance.</li>
 * <li>Start the <b>FakeFtpServer</b> instance.</li>
 * </ol>
 * <h4>Example Code</h4>
 * <pre><code>
 * FakeFtpServer fakeFtpServer = new FakeFtpServer();
 *
 * FileSystem fileSystem = new WindowsFakeFileSystem();
 * fileSystem.add(new DirectoryEntry("c:\\"));
 * fileSystem.add(new DirectoryEntry("c:\\data"));
 * fileSystem.add(new FileEntry("c:\\data\\file1.txt", "abcdef 1234567890"));
 * fileSystem.add(new FileEntry("c:\\data\\run.exe"));
 * fakeFtpServer.setFileSystem(fileSystem);
 *
 * // Create UserAccount with username, password, home-directory
 * UserAccount userAccount = new UserAccount("joe", "joe123", "c:\\");
 * fakeFtpServer.addUserAccounts(userAccount);
 *
 * fakeFtpServer.start();
 * </code></pre>
 *
 * <h4>Example Code with Permissions</h4>
 * You can optionally set the permissions and owner/group for each file and directory, as in the following example.
 * <pre><code>
 * FileSystem fileSystem = new UnixFakeFileSystem();
 * DirectoryEntry directoryEntry1 = new DirectoryEntry("/");
 * directoryEntry1.setPermissions(new Permissions("rwxrwx---"));
 * directoryEntry1.setOwner("joe");
 * directoryEntry1.setGroup("dev");
 *
 * DirectoryEntry directoryEntry2 = new DirectoryEntry("/data");
 * directoryEntry2.setPermissions(Permissions.ALL);
 * directoryEntry2.setOwner("joe");
 * directoryEntry2.setGroup("dev");
 *
 * FileEntry fileEntry1 = new FileEntry("/data/file1.txt", "abcdef 1234567890");
 * fileEntry1.setPermissionsFromString("rw-rw-rw-");
 * fileEntry1.setOwner("joe");
 * fileEntry1.setGroup("dev");
 *
 * FileEntry fileEntry2 = new FileEntry("/data/run.exe");
 * fileEntry2.setPermissionsFromString("rwxrwx---");
 * fileEntry2.setOwner("mary");
 * fileEntry2.setGroup("dev");
 *
 * fileSystem.add(directoryEntry1);
 * fileSystem.add(directoryEntry2);
 * fileSystem.add(fileEntry1);
 * fileSystem.add(fileEntry2);
 *
 * FakeFtpServer fakeFtpServer = new FakeFtpServer();
 * fakeFtpServer.setFileSystem(fileSystem);
 *
 * // Create UserAccount with username, password, home-directory
 * UserAccount userAccount = new UserAccount("joe", "joe123", "/");
 * fakeFtpServer.addUserAccounts(userAccount);
 *
 * fakeFtpServer.start();
 * </code></pre>
 *
 * <h4>FTP Server Control Port</h4>
 * By default, <b>FakeFtpServer</b> binds to the server control port of 21. You can use a different server control
 * port by setting the <code>serverControlPort</code> property. If you specify a value of <code>0</code>,
 * then a free port number will be chosen automatically; call <code>getServerControlPort()</code> AFTER
 * <code>start()</code> has been called to determine the actual port number being used. Using a non-default
 * port number is usually necessary when running on Unix or some other system where that port number is
 * already in use or cannot be bound from a user process.
 *
 * <h4>Other Configuration</h4>
 * The <code>systemName</code> property specifies the value returned by the <code>SYST</code>
 * command. Note that this is typically used by an FTP client to determine how to parse
 * system-dependent reply text, such as directory listings. This value defaults to <code>"WINDOWS"</code>.
 * <p/>
 * The <code>helpText</code> property specifies a <i>Map</i> of help text replies sent by the
 * <code>HELP</code> command. The keys in that <i>Map</i> correspond to the command names passed as
 * parameters to the <code>HELP</code> command. An entry with the key of an empty string ("") indicates the
 * text used as the default help text when no command name parameter is specified for the <code>HELP</code> command.
 *
 * <h4>FTP Command Reply Text ResourceBundle</h4>
 * The default text asociated with each FTP command reply code is contained within the
 * "ReplyText.properties" ResourceBundle file. You can customize these messages by providing a
 * locale-specific ResourceBundle file on the CLASSPATH, according to the normal lookup rules of
 * the ResourceBundle class (e.g., "ReplyText_de.properties"). Alternatively, you can
 * completely replace the ResourceBundle file by calling the calling the
 * {@link #setReplyTextBaseName(String)} method.
 *
 * @author Chris Mair
 * @version $Revision$ - $Date$
 */
public class FakeFtpServer extends AbstractFtpServer implements ServerConfiguration {

    private FileSystem fileSystem;
    private String systemName = "WINDOWS";
    private String systemStatus = "Connected";
    private Map helpText = new HashMap();
    private Map userAccounts = new HashMap();

    public FileSystem getFileSystem() {
        return fileSystem;
    }

    public void setFileSystem(FileSystem fileSystem) {
        this.fileSystem = fileSystem;
    }

    public String getSystemName() {
        return systemName;
    }

    public void setSystemName(String systemName) {
        this.systemName = systemName;
    }

    public Map getHelpText() {
        return helpText;
    }

    public void setHelpText(Map helpText) {
        this.helpText = helpText;
    }

    public FakeFtpServer() {
        setCommandHandler(CommandNames.ACCT, new AcctCommandHandler());
        setCommandHandler(CommandNames.ABOR, new AborCommandHandler());
        setCommandHandler(CommandNames.ALLO, new AlloCommandHandler());
        setCommandHandler(CommandNames.APPE, new AppeCommandHandler());
        setCommandHandler(CommandNames.CWD, new CwdCommandHandler());
        setCommandHandler(CommandNames.CDUP, new CdupCommandHandler());
        setCommandHandler(CommandNames.DELE, new DeleCommandHandler());
        setCommandHandler(CommandNames.EPRT, new EprtCommandHandler());
        setCommandHandler(CommandNames.EPSV, new EpsvCommandHandler());
        setCommandHandler(CommandNames.HELP, new HelpCommandHandler());
        setCommandHandler(CommandNames.LIST, new ListCommandHandler());
        setCommandHandler(CommandNames.MKD, new MkdCommandHandler());
        setCommandHandler(CommandNames.MODE, new ModeCommandHandler());
        setCommandHandler(CommandNames.NLST, new NlstCommandHandler());
        setCommandHandler(CommandNames.NOOP, new NoopCommandHandler());
        setCommandHandler(CommandNames.PASS, new PassCommandHandler());
        setCommandHandler(CommandNames.PASV, new PasvCommandHandler());
        setCommandHandler(CommandNames.PWD, new PwdCommandHandler());
        setCommandHandler(CommandNames.PORT, new PortCommandHandler());
        setCommandHandler(CommandNames.QUIT, new QuitCommandHandler());
        setCommandHandler(CommandNames.REIN, new ReinCommandHandler());
        setCommandHandler(CommandNames.REST, new RestCommandHandler());
        setCommandHandler(CommandNames.RETR, new RetrCommandHandler());
        setCommandHandler(CommandNames.RMD, new RmdCommandHandler());
        setCommandHandler(CommandNames.RNFR, new RnfrCommandHandler());
        setCommandHandler(CommandNames.RNTO, new RntoCommandHandler());
        setCommandHandler(CommandNames.SITE, new SiteCommandHandler());
        setCommandHandler(CommandNames.SMNT, new SmntCommandHandler());
        setCommandHandler(CommandNames.STAT, new StatCommandHandler());
        setCommandHandler(CommandNames.STOR, new StorCommandHandler());
        setCommandHandler(CommandNames.STOU, new StouCommandHandler());
        setCommandHandler(CommandNames.STRU, new StruCommandHandler());
        setCommandHandler(CommandNames.SYST, new SystCommandHandler());
        setCommandHandler(CommandNames.TYPE, new TypeCommandHandler());
        setCommandHandler(CommandNames.USER, new UserCommandHandler());
        setCommandHandler(CommandNames.XPWD, new PwdCommandHandler());

        // "Special" Command Handlers
        setCommandHandler(CommandNames.CONNECT, new ConnectCommandHandler());
        setCommandHandler(CommandNames.UNSUPPORTED, new UnsupportedCommandHandler());
    }

    /**
     * Initialize a CommandHandler that has been registered to this server.
     *
     * If the CommandHandler implements the <code>ServerConfigurationAware</code> interface, then set its
     * <code>ServerConfiguration</code> property to <code>this</code>.
     *
     * If the CommandHandler implements the <code>ReplyTextBundleAware</code> interface, then set its
     * <code>replyTextBundle</code> property using the reply text bundle for this server.
     *
     * @param commandHandler - the CommandHandler to initialize
     */
    protected void initializeCommandHandler(CommandHandler commandHandler) {
        if (commandHandler instanceof ServerConfigurationAware) {
            ServerConfigurationAware sca = (ServerConfigurationAware) commandHandler;
            sca.setServerConfiguration(this);
        }

        ReplyTextBundleUtil.setReplyTextBundleIfAppropriate(commandHandler, getReplyTextBundle());
    }

    /**
     * @return the {@link UserAccount}        configured for this server for the specified user name
     */
    public UserAccount getUserAccount(String username) {
        return (UserAccount) userAccounts.get(username);
    }

    /**
     * Return the help text for a command or the default help text if no command name is specified
     *
     * @param name - the command name; may be empty or null to indicate  a request for the default help text
     * @return the help text for the named command or the default help text if no name is supplied
     */
    public String getHelpText(String name) {
        String key = name == null ? "" : name;
        return (String) helpText.get(key);
    }

    /**
     * Add a single UserAccount. If an account with the same <code>username</code> already exists,
     * it will be replaced.
     *
     * @param userAccount - the UserAccount to add
     */
    public void addUserAccount(UserAccount userAccount) {
        userAccounts.put(userAccount.getUsername(), userAccount);
    }

    /**
     * Add the UserAccount objects in the <code>userAccountList</code> to the set of UserAccounts.
     *
     * @param userAccountList - the List of UserAccount objects to add
     */
    public void setUserAccounts(List userAccountList) {
        for (int i = 0; i < userAccountList.size(); i++) {
            UserAccount userAccount = (UserAccount) userAccountList.get(i);
            userAccounts.put(userAccount.getUsername(), userAccount);
        }
    }

    /**
     * Return the system status description
     *
     * @return the system status
     */
    public String getSystemStatus() {
        return systemStatus;
    }

    /**
     * Set the system status description text, used by the STAT command handler.
     *
     * @param systemStatus - the system status description text
     */
    public void setSystemStatus(String systemStatus) {
        this.systemStatus = systemStatus;
    }

}