// java CommandLine -user admin -password manager -ping {host}
// java CommandLine -user admin -password manager
//   -ftp {host} -get {path_to_file}
// java CommandLine -user admin -password manager
//   -ftp {host} -ls {path_to_file}

private void createPingCmdOptions() {
    // ping command
    // java CommandProcessor -user admin -password manager -ping {host}

    pingOptions = new Options();

    Option user = createUserOption();
    pingOptions.addOption(user);

    Option passwd = createPasswordOption();
    pingOptions.addOption(passwd);

    Option ping = OptionBuilder.withArgName("ping")
                         　    .hasArg()
                               .isRequired()
                               .withDescription("Ping a remote system")
                               .create("ping");
    pingOptions.addOption(ping);
}

Option ftp = OptionBuilder.withArgName("ftp")
    .hasArg()
    .isRequired()
    .withDescription("File transfer protocol")
    .create("ftp");
ftpOptions.addOption(ftp);

// For additional ftp commands like ls, put, and mget,
// a OptionGroup needs to be created
// to indicate the options are mutually exclusive
Option get = OptionBuilder.withArgName("get")
    .hasArg()
    .withDescription("Get a file from the server")
    .create("get");

Option ls = OptionBuilder.withArgName("ls")
    .hasArg()
    .withDescription("List the folder contents in the server")
    .create("ls");
OptionGroup ftpArgs = new OptionGroup();
ftpArgs.addOption(get);
ftpArgs.addOption(ls);
ftpArgs.setRequired(true);
ftpOptions.addOptionGroup(ftpArgs);

public void process(String args[]) {

    // remaining code

    CommandLineParser parser = new BasicParser();
    org.apache.commons.cli.CommandLine line = null;
    Context chainContext = null;

    // remaining code
        case PING : {
            try {
                line = parser.parse(pingOptions, args);
                chainContext = getPingContext(line);
            } catch (ParseException e) {
                System.out.println(e.toString());
                HelpFormatter formatter = new HelpFormatter();
                formatter.printHelp(
                    "Ping options", pingOptions);
            }
        } break;
    // remaining code
}

private Context getPingContext(
    org.apache.commons.cli.CommandLine line) {
    String user = line.getOptionValue("user");
    String passwd = line.getOptionValue("password");
    String host = line.getOptionValue("ping");
    return new CommandlineContext(
        user, passwd, new CLICommand("-ping", new String[] {host}));
}

private int classifyCommand(String args[])
    throws CommandLineException {
    if(args != null && args.length > 0) {
        for(String arg : args) {
            if(arg.equals("-ping")) {
                return PING;
            }

            if(arg.equals("-ftp")) {
                return FTP;
            }
        }
    } else {
        throw new CommandLineException(
            "Invalid command options. See usage.");
    }
    throw new CommandLineException(
        "Invalid command options. See usage");
}

/**
 * Initialize the DefaultFileSystemManager to support
 * file, zip and jar providers. A virtual file system
 * is created and passed to the SearchableVirtualFileSystem
 * decorator class.
 *
 * @throws SearchException Error in initializing the file
 *                         FileSystemManager
 */
private void init() throws SearchException {
    defFileSysMgr = new DefaultFileSystemManager();

    try {

        defFileSysMgr.addProvider(
            "file", new DefaultLocalFileProvider());
        defFileSysMgr.addProvider(
            "zip", new ZipFileProvider());
        defFileSysMgr.addProvider(
            "jar", new JarFileProvider());
        defFileSysMgr.init();

        // Create the virtual file system
        VirtualFileSystem vfs = 
        (VirtualFileSystem)defFileSysMgr
            .createVirtualFileSystem("vfs://").getFileSystem();

        searchableVfs = new SearchableVirtualFileSystem(vfs);

    } catch (FileSystemException e) {
        throw new SearchException(
            "Unable to initialize the FileSystemManager.", e);
    }
}

/**
 * Adds the folder, zip, and a jar file to search
 * 
 * @throws Exception Error in the test.
 */
public void testSearchInZips() throws Exception {
    SearchBuddy searchTool = new SearchBuddy();
    searchTool.addSearchableZip("testroot.zip");
    searchTool.addSearchableJar("testjar.jar");
    searchTool.addSearchableFolder(".");
        
    System.out.println("Searching for news.txt");
    searchTool.search("news", "txt");
        
    System.out.println("Searching for Range.class");
    searchTool.search("range", "class");
        
    System.out.println("Searching for test.xml");
    searchTool.search("test", "xml");
 
    System.out.println("Searching for *.properties");
    searchTool.search(null, "properties");
    searchTool.close();
} 

/**
 * Mount a zip file to the searchable virtual
 * file system.
 *
 * @param pathToFolder Absolute or relative path to the zip file.
 * @throws SearchException Error while adding the zip file
 *         to the virtual file system.
 */
public void addSearchableZip(String pathToZip)
    throws SearchException {
    File zipFile = new File(pathToZip);
    if(!zipFile.exists()) {
        throw new SearchException("Invalid zip file path");
    }
    try {
        FileObject zipFileObject = defFileSysMgr.toFileObject(zipFile);
        searchableVfs.addJunction("/" + zipFile,
            defFileSysMgr.resolveFile("zip:" + zipFileObject + "!/"));
    } catch (FileSystemException e) {
        throw new SearchException(
            "Unable to add zip file to the virtual file system", e);
    }
}

Class SearchBuddy
/**
 * Delegate the search call to the Searchable virtual file
 * system decorator.
 *
 * @param fileNamePart Name of the file.
 * @param extension Extension to search
 * @throws SearchException Error from the VirtualFileSystem
           when searching for file.
 */
public void search(String fileNamePart, String extension)
    throws SearchException {
    searchableVfs.search(fileNamePart, extension);
}

Class SearchableVirtualFileSystem
/**
 * Iterate the junctions to search for the given file name.
 *
 * @param fileNamePart File name to search
 * @param extension Extension to search
 * @throws SearchException
 */
public void search(String fileNamePart, String extension)
    throws SearchException {
    try {
        Iterator<String> searchPoints = junctions.iterator();
        FileObject matchingFiles[];
        while(searchPoints.hasNext()) {
            String searchPoint = searchPoints.next();
            FileObject searchRoot = vfs.resolveFile(searchPoint);
            filter.setExtension(extension);
            filter.setFileNamePart(fileNamePart);
            matchingFiles = searchRoot.findFiles(filter);
            for(FileObject file : matchingFiles) {
                System.out.println("Result:" + file);
            }
        }
    } catch (FileSystemException e) {
        throw new SearchException("Search failed", e);
    }
}

application.properties
syncintervalhours=12
enablesync=true
#This property is set after the first run
lastsync=<timestamp in milliseconds>

sntpservers.xml
<servers>
    <name>server1</name>
    <name>server2</name>
    <name>server3</name>
</servers>

public interface IConfiguration {
    void setStringConfig(String nameSpace, String key, String value);
    String getStringConfig(String nameSpace, String key);
    String[] getStringArrayConfig(String nameSpace, String key);
    void setBooleanConfig(
        String nameSpace, String key, boolean value);
    boolean getBooleanConfig(String nameSpace, String key);
    void setIntConfig(String nameSpace, String key, int value);
    int getIntConfig(String nameSpace, String key);
}

/**
 * Get the config property value from configuration storage. The
 * properties are loaded if it is not already loaded for the
 * given namespace.
 * 
 * @param nameSpace Name of the configuration group
 * @param key Unique key within the namespace
 * @return Sring value of the property. Null if the property
 *         is not found or if the configuration cannot be loaded
 */
public String getStringConfig(String nameSpace, String key) {
    Configuration config = getConfiguration(nameSpace);
    if(config != null) {
        return config.getString(key);
    }
    return null;
}
 
private synchronized Configuration getConfiguration
    (String nameSpace) {
    Configuration config = configs.get(nameSpace);
    if(config == null) {
        try {
            if("application".equals(nameSpace)) {
                config = new PropertiesConfiguration(
                    "application.properties");
            } else if("sntpservers".equals(nameSpace)) {
                config = 
                new XMLConfiguration(
                    getClass().getResource("sntpservers.xml"));
            }
            configs.put(nameSpace, config);
        } catch (ConfigurationException e) {
            System.out.println("Unable to load the configuration:"
                + e.getMessage());
        }
    }
    return config;
}

private synchronized void save(Configuration config) {
    if(config instanceof FileConfiguration) {
        try {
            // If reloading strategy is set, then the properties
            // doesn’t get saved
        ((FileConfiguration)config).save();
        } catch (ConfigurationException e) {
            System.out.println("Config not saved. Error while saving."
                + e.getMessage());
        }
    } else {
        System.out.println("Config not saved. Not supported.");
    }
}

void syncTime() {
    if(shouldSyncNow()) {
        context.getLogger().log(Level.INFO, "Sync started");
        sync();
        recordSyncTime();
    } else {
        context.getLogger().log(Level.INFO,
            "Sync skipped. Time not yet arrived");
    }
}

private boolean shouldSyncNow() {
    boolean enableSync = context.getConfiguration()
        .getBooleanConfig("application", "enablesync");
    context.getLogger().log(Level.INFO, "enablesync:" + enableSync);
    if(enableSync) {
        if(getCurrentTime() > readLastSync() + getInterval()) {
            return true;
        }
    }
    return false;
}

/**
 * Use SNTP API to sync the time.
 */
private void sync() {
    String servers[] = context.getConfiguration()
                      .getStringArrayConfig("sntpservers", "name");
    for(String server : servers) {
        context.getLogger().log(Level.INFO, "Time Server:" + server);
    }

    // Use the list of server to sync the system time.
    // sntp API for java can be used here
    context.getLogger().log(Level.INFO, "Syncing time..");
}

public class TestSyncTime extends TestCase {
    public void testSyncTime() {
        Logger consoleLogger = Logger.getAnonymousLogger();
        ApplicationContext context = new ApplicationContext();
        context.setLogger(consoleLogger);
        context.setConfiguration(new ApplicationConfiguration());

        SyncTime sync = new SyncTime(context);
        sync.syncTime();
        sync.syncTime();
    }
}

public interface IJNDIConnection {

    /**
     * Execute the given query against the directory server.
     *
     * @param query JNDI query of the form ((objectclass=user)(cn=john))
     * @return Search result
     * @throws NamingException Directory server error
     */
    NamingEnumeration executeQuery(String query)
        throws NamingException;

    /**
     * Fetch the attributed of a given DN of an object.
     *
     * @param dn Distinguished name of the object
     * @return Attributes of an object
     * @throws NamingException Directory server error
     */
    Attributes getAttributes(String dn) throws NamingException;
}

String host = "localhost";
String port = "389";
String binDN = "CN=guest,CN=Users,DC=narayanan,DC=co,DC=in";
String password = "guest";
String baseDN = "DC=narayanan,DC=co,DC=in";

JNDIConnectionManager manager =
    JNDIConnectionManager.getJNDIConnectionManager(
        host,
        port,
        binDN,
        password,
        baseDN);
IJNDIConnection connection = manager.getConnection();

String query = "(objectclass=container)";
NamingEnumeration users = connection.executeQuery(query);
while (users.hasMoreElements()) {
    System.out.println(users.next());
}

public class JNDIConnectionFactory implements PoolableObjectFactory {
    private JNDIConnectionInfo connInfo;
    public JNDIConnectionFactory(String host,
            String port,
            String bindDN, 
            String password,
            String baseDN) {
        connInfo = new JNDIConnectionInfo(
            host, port, bindDN, password, baseDN);
    }
 
    public Object makeObject() throws Exception {
        Hashtable dirProps = connInfo.getJNDIConnectionProps();
        DirContext dirContext = new InitialDirContext(dirProps);
        return dirContext;
    }
 
    public void destroyObject(Object context) throws Exception {
        DirContext dirContext = (DirContext)context;
        dirContext.close();
    }
    // remaining methods
    // inner class JNDIConnectionInfo
}

public class JNDIConnectionManager {
    // remaining declarations
    private GenericObjectPool pool;
    private PoolableObjectFactory factory;

    private JNDIConnectionManager(
        String host,
        String port,
        String bindDN,
        String password,
        String baseDN) {
        factory = new JNDIConnectionFactory(
            host, port, bindDN, password, baseDN);
        pool = new GenericObjectPool(factory);
    }

    // remaining code

    public IJNDIConnection getConnection() {
        try {
            return new JNDIConnection((DirContext)pool.borrowObject());
        } catch (Exception e) {
            return null;
        }
    }

    public void returnConnection(IJNDIConnection connection) {
        try {
            pool.returnObject(
                ((JNDIConnection)connection).getContext());
        } catch (Exception e) {
            System.out.println("Unable return the object back to pool");
        }
    }
}