/**
 * This code is provided under the MIT License (http://www.opensource.org/licenses/mit-license.php).
 * It depends on the following 3rd-party packages:
 *
 * * Apache Solr: http://lucene.apache.org/solr/
 * * Spring Framework: http://www.springsource.org/
 */
package com.zoominfo.util.solrembed;

import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.solr.client.solrj.SolrServer;
import org.apache.solr.client.solrj.SolrRequest;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.core.CoreDescriptor;
import org.apache.solr.core.CoreContainer;
import org.apache.solr.client.solrj.embedded.EmbeddedSolrServer;
import org.apache.solr.core.SolrCore;
import org.apache.solr.schema.IndexSchema;
import org.apache.solr.search.SolrIndexSearcher;
import org.apache.solr.util.RefCounted;
import org.springframework.beans.factory.annotation.Required;
import org.xml.sax.SAXException;

/**
 * A class that manages the life-cycle of an in-process Solr server.
 */
public class InProcessSolrServer extends SolrServer implements Closeable {

    private File solrdir = null;
    private File datadir = null;
    private SolrServer delegate = null;
    private transient SolrCore core = null;

    /**
     * <p>Sets your Solr root directory. In Solr’s documentation,
     * this is generally referred to as "/solr-root". Your "conf"
     * directory (containing your schema, stopwords, synonyms, …)
     * will be a subdirectory of this.</p>.
     *
     * @param solrdir
     */
    @Required
    public final void setSolrdir(final File solrdir) {
        this.solrdir = solrdir;

        System.setProperty("solr.home", solrdir.getPath());

        if (this.datadir == null) {
            setDatadir(new File(solrdir, "data"));
        }
    }

    /**
     * <p>Sets your Solr data directory. This is the parent directory
     * of your "index" and "spellchecker" directories.</p>
     *
     * @param datadir
     */
    public final void setDatadir(final File datadir) {
        this.datadir = datadir;
        System.setProperty("solr.data.dir", datadir.getPath());
    }

    /**
     * <p>The only @SolrServer method that you need to override. This method
     * passes all queries and indexing events on to an in-process delegate.</p>
     *
     * @param req
     * @return
     * @throws SolrServerException
     * @throws IOException
     */
    @Override
    public NamedList<Object> request(final SolrRequest req)
            throws SolrServerException,
            IOException {
        try {
            return getDelegate().request(req);
        } catch (final SolrServerException e) {
            throw e;
        } catch (final IOException e) {
            throw e;
        } catch (final Exception e) {
            throw new SolrServerException(e);
        }
    }

    @Override
    public synchronized void close() {
        if (core != null) {
            core.close();
            core = null;
        }
    }

    @Override
    @SuppressWarnings("FinalizeDeclaration")
    protected void finalize() throws Throwable {
        close();
        super.finalize();
    }

    /**
     * This method creates an in-process Solr server that otherwise behaves just
     * as you’d expect.
     */
    private synchronized SolrServer getDelegate() throws SolrServerException {
        if (delegate != null) {
            return delegate;
        }

        try {
            File solrconfigXml = new File(new File(solrdir, "conf"), "solrconfig.xml");

            CoreContainer container = new CoreContainer(solrdir.getPath(), solrconfigXml);
            CoreDescriptor descriptor = new CoreDescriptor(container, "core1", solrdir.getCanonicalPath());

            core = container.create(descriptor);
            container.register("core1", core, false);
            delegate = new EmbeddedSolrServer(container, "core1");

            return delegate;
        } catch (ParserConfigurationException ex) {
            throw new SolrServerException(ex);
        } catch (SAXException ex) {
            throw new SolrServerException(ex);
        } catch (IOException ex) {
            throw new SolrServerException(ex);
        }
    }

    /**
     * SolrIndexSearcher adds schema awareness and caching functionality over the Lucene IndexSearcher.
     *
     * @return
     * @throws SolrServerException
     */
    public RefCounted<SolrIndexSearcher> getIndexSearcher() throws SolrServerException {
        // http://lucene.apache.org/solr/api/org/apache/solr/search/SolrIndexSearcher.html
        getDelegate(); // force the delegate to be created

        return core.getSearcher();
    }

    /**
     * Returns the index schema used by this Solr server
     *
     * @return
     * @throws SolrServerException
     */
    public IndexSchema getIndexSchema() throws SolrServerException {
        getDelegate(); // force the delegate to be created

        return core.getSchema();
    }
}
 

package com.zoominfo.util.solrembed;

import org.apache.solr.client.solrj.SolrServer;
import java.io.IOException;
import com.zoominfo.util.ZipUtil;
import com.zoominfo.util.solrembed.InProcessSolrServer;
import java.io.File;
import static org.apache.commons.io.FileUtils.deleteDirectory;

public abstract class InProcessSolrServerTestBase {

    private InProcessSolrServer solrServer = null;
    private File solrOutFolder = null;

    public SolrServer getSolrServer() {
        return solrServer;
    }

    /**
     * <p>Deploys a pre-built Solr index, and creates an in-process Solr server.
     * This is meant to be called from an @Before or @BeforeClass type of method.</p>
     *
     * @param solrIndexZip a pre-built Solr index, bundled into a ZIP
     * @throws IOException
     */
    protected void deploySolrIndex(final File solrIndexZip) throws IOException {
        assert solrOutFolder == null;

        solrOutFolder = File.createTempFile("solr", "index");
        solrOutFolder.delete();
        solrOutFolder.mkdirs();

        // unzip a canned solr index. code not provided.
        ZipUtil.unzipFolder(solrIndexZip, solrOutFolder);

        // create an in-process solr server
        solrServer = new InProcessSolrServer(solrOutFolder);
    }

    /**
     * <p>Un-deploys the in-process Solr server.
     * Meant to be called from an @After or @AfterClass method.</p>

     * @throws IOException
     */
    protected void tearDown() throws IOException {
        if (solrOutFolder != null) {
            solrServer.close(); // turn off the solr server
            deleteDirectory(solrOutFolder); // delete the solr directory, recursively
        }
    }
}
 

    /**
     * Runs the specified query, passing every result to the specified Callback argument
     *
     * @see SolrIndexSearcher.getDocList
     *
     * @param solrServer the Solr Server you want to search
     * @param query the Solr query
     * @param filterList the list of documents to not return. may be null
     * @param sort criteria by which to sort (if null, query relevance is used)
     * @param start offset into the list of documents to return
     * @param length maximum number of documents to return. -1 returns all documents
     * @param callback action performed for each matching document
     * @param closeIndexSearcher pass true to keep the searcher open for more queries
     * @throws Exception
     */
    public static void run(final InProcessSolrServer solrServer, final Query query,
            final List<Query> filterList, final Sort sort,
            final int start, int length, final Callback callback, final boolean closeIndexSearcher) throws Exception {
        RefCounted<SolrIndexSearcher> indexSearcherRef = null;

        try {
            indexSearcherRef = solrServer.getIndexSearcher();

            SolrIndexSearcher indexSearcher = indexSearcherRef.get();
            if (length < 0) {
                length = indexSearcher.getIndexReader().maxDoc();
            }

            DocList docList = indexSearcher.getDocList(query, filterList, sort, start, length, 0);

            callback.setIndexSchema(solrServer.getIndexSchema());
            callback.begin();

            DocIterator iter = docList.iterator();
            while (iter.hasNext()) {
                Document doc = indexSearcher.doc(iter.nextDoc());
                callback.collect(doc);
            }

            callback.end();
            if(closeIndexSearcher) {
                indexSearcher.close();
            }

        } finally {
            if (indexSearcherRef != null) {
                indexSearcherRef.decref();
            }
        }
    }

    /**
     * A utility method that converts a Lucene document to a Solr document
     *
     * @param doc a Lucene document
     * @return an equivalent Solr document
     * @throws Exception
     */
    public SolrDocument convertToSolrDocument(final Document doc) throws Exception {
        SolrDocument solrDoc = new SolrDocument();

        // load the solr doc from the lucene doc
        new org.apache.solr.update.DocumentBuilder(schema).loadStoredFields(solrDoc, doc);

        return solrDoc;
    }

    /**
     * A utility method that converts a Solr document to a Lucene document
     *
     * @param doc a Solr document
     * @return an equivalent Lucene document
     */
    public Document convertToLuceneDocument(final SolrDocument doc) {
        // load the lucene doc from the solr doc
        return DocumentBuilder.toDocument(org.apache.solr.client.solrj.util.ClientUtils.toSolrInputDocument(doc), schema);
    }

/**
 * This code is provided under the MIT License (http://www.opensource.org/licenses/mit-license.php).
 * It depends on the following 3rd-party packages:
 *
 * * Apache Mina FtpServer: http://mina.apache.org/ftpserver/
 * * Apache Commons I/O: http://commons.apache.org/io/
 * * Apache Commons Net: http://commons.apache.org/net/
 * * JUnit: http://www.junit.org/
 */
package ftpserverapplication;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
import static org.apache.commons.io.FileUtils.deleteDirectory;

import org.apache.ftpserver.FtpServer;
import org.apache.ftpserver.FtpServerFactory;
import org.apache.ftpserver.ftplet.FtpException;
import org.apache.ftpserver.listener.ListenerFactory;
import org.apache.ftpserver.usermanager.ClearTextPasswordEncryptor;
import org.apache.ftpserver.usermanager.PropertiesUserManagerFactory;

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;

/**
 * <p>This class is intended to be a base class for any test that needs to interact
 * with a FTP server. It creates a new sandboxed FTP server for each @Test
 * that gets executed.</p>
 */
public class FtpServerTest {

    // HACK UTILITY METHOD
    private static File createTempFileName(final String name) throws IOException {
        // File.createTempFile() actually creates the file. We only want a name.
        // Don’t use this in production code, as it could be exploited or suffer
        // from race conditions, similar to C’s "tmpnam()" function.
        File f = File.createTempFile(name, ".temp");
        f.delete();
        return f;
    }
    private FtpServer server;
    private File propsFile;
    private File ftpBaseDirectory;
    private FTPClient client;

    /**
     * <p>This method sets up some basic configuration parameters for the FTP Server.
     * It creates a single user account, tied to a base directory.</p>
     *
     * @param ftpDirectory the root directory for the FTP Server
     * @return the FTP Properties file that will drive its configuration
     */
    private static File generateFtpProperties(File ftpDirectory) throws IOException {
        Properties props = new Properties();

        // create an account for the user "ftpuser" whose password is "password"
        // most of these are just "stock" values that won’t affect your functional
        // testing, so don’t worry too much about them
        props.put("ftpserver.user.ftpuser.userpassword", "password");
        props.put("ftpserver.user.ftpuser.homedirectory", ftpDirectory.getCanonicalPath());
        props.put("ftpserver.user.ftpuser.enableflag", "true");
        props.put("ftpserver.user.ftpuser.writepermission", "true");
        props.put("ftpserver.user.ftpuser.maxloginnumber", "0");
        props.put("ftpserver.user.ftpuser.maxloginperip", "0");
        props.put("ftpserver.user.ftpuser.idletime", "0");
        props.put("ftpserver.user.ftpuser.uploadrate", "0");
        props.put("ftpserver.user.ftpuser.downloadrate", "0");

        // create a sandboxed properties file
        File propsFile = File.createTempFile("ftpserver", "properties");

        FileOutputStream os = new FileOutputStream(propsFile);
        props.store(os, "Apache Mina FtpServer configuration");
        os.close();

        // ensure that the properties file gets cleaned up when the tests are done
        propsFile.deleteOnExit();

        return propsFile;
    }

    /**
     * Here, we create our in-process FTP Server, as well as a client connected to it.
     */
    @Before
    public void setup() throws IOException, FtpException {
        FtpServerFactory serverFactory = new FtpServerFactory();

        // generate a random, sandboxed directory that will serve as the base
        // directory for our FTP Server
        ftpBaseDirectory = createTempFileName("ftpserver");
        boolean createdDirectories = ftpBaseDirectory.mkdirs(); // create the directory
        if (!createdDirectories) {
            throw new IOException("Could not create directory: " + ftpBaseDirectory.getCanonicalPath());
        }

        propsFile = generateFtpProperties(ftpBaseDirectory);

        PropertiesUserManagerFactory userManagerFactory = new PropertiesUserManagerFactory();
        userManagerFactory.setPasswordEncryptor(new ClearTextPasswordEncryptor());
        userManagerFactory.setFile(propsFile);

        serverFactory.setUserManager(userManagerFactory.createUserManager());

        ListenerFactory listenerFactory = new ListenerFactory();

        // let the ftp server bind to any available port
        listenerFactory.setPort(0);

        // replace the default listener
        serverFactory.addListener("default", listenerFactory.createListener());

        server = serverFactory.createServer();

        // start the FTP server
        server.start();

        // creates a new FTP client
        client = new FTPClient();

        // connect to the ftp server on the correct port
        client.connect("127.0.0.1", serverFactory.getListener("default").getPort());

        // check the reply code to verify success
        if (!FTPReply.isPositiveCompletion(client.getReplyCode())) {
            client.disconnect();
            throw new IOException("FTP server refused connection. Reason: " + client.getReplyString());
        }

        // log in to the ftp server
        boolean isLoggedIn = client.login("ftpuser", "password");
        if (!isLoggedIn) {
            throw new IOException("Login failed to FTP server. Reason: " + client.getReplyString());
        }

        // transfer data in binary mode, otherwise the FTP server will
        // un-helpfully convert line endings for you
        boolean supportsBinary = client.setFileType(FTP.BINARY_FILE_TYPE);
        if (!supportsBinary) {
            throw new IOException("Could not set mode to ‘binary’. Reason: " + client.getReplyString());
        }
    }

    /**
     * This method cleans up the various sandboxes we created and stops the FTP server.
     */
    @After
    public void tearDown() throws IOException {
        // disconnect the client
        client.disconnect();

        // stop the server
        server.stop();

        // clean up the FTP server’s properties file
        propsFile.delete();

        // clean up the temporary ftp directory, recursively
        deleteDirectory(ftpBaseDirectory);
    }

    @Test
    public void test() throws IOException {
        String remoteFileName = "test.txt";
        byte[] testTextBytes;

        {
            // This block is where you would put your business logic.
            // I’ve dummied up some business logic for illustrative purposes.
            // All this does is create a simple file on the server.

            String testText = "hello world!\n"
                    + "this file has several lines in it.\n"
                    + "it is an otherwise boring file.";

            testTextBytes = testText.getBytes("UTF-8");
            ByteArrayInputStream localInput = new ByteArrayInputStream(testTextBytes);

            boolean storedOk = client.storeFile(remoteFileName, localInput);

            localInput.close();

            if (!storedOk) {
                throw new IOException("Transfer failed to FTP server. Reason: " + client.getReplyString());
            }
        }

        {
            // In this block, we assert that our business logic worked appropriately.
            // For this use case, we simply assert that the file exists on the local
            // hard drive, and that it has the same size as we’d expect it to.

            // assert that the file exists
            File storedFile = new File(ftpBaseDirectory, remoteFileName);
            assertTrue(storedFile.exists());

            // assert that the file has the correct size in bytes
            long length = storedFile.length();
            assertEquals(testTextBytes.length, length);
        }
    }
}
 

    static Iterable<Integer> range(int hi) {

        return range(0, hi);
    }

    static Iterable<Integer> range(int lo, int hi) {

        return range(lo, hi, 1);
    }

    static Iterable<Integer> range(final int lo, final int hi, final int step) {

        return new Generator<Integer>() {

            @Override

            protected void run() {
                for (int i = lo; i != hi; i += step) {

                    yield(i);
                }

            }
        };
    }

    static Iterable<Character> reverse(final CharSequence string) {
        return new Generator<Character>() {

            @Override
            protected void run() {

                for (int i : range(string.length() – 1, -1, -1)) {

                    yield(string.charAt(i));
                }

            }
        };
    }

    static Iterable<Integer> firstn(final int n) {
        return new Generator<Integer>() {

            @Override
            protected void run() {

                int num = 0;
                while (num < n) {

                    yield(num);
                    num += 1;

                }
            }
        };

    }