Laboratoire ICAR » Plateforme TXM

@Test(groups="functional")

    public void runAllPossibleConversions() throws IOException {

        OfficeManager officeManager = new DefaultOfficeManagerConfiguration().buildOfficeManager();

        OfficeDocumentConverter converter = new OfficeDocumentConverter(officeManager);

        DocumentFormatRegistry formatRegistry = converter.getFormatRegistry();

        officeManager.start();

        try {

            File dir = new File("src/test/resources/documents");

            File[] files = dir.listFiles(new FilenameFilter() {

            	public boolean accept(File dir, String name) {

            		return !name.startsWith(".");

            	}

            });

                String inputExtension = FilenameUtils.getExtension(inputFile.getName());

                DocumentFormat inputFormat = formatRegistry.getFormatByExtension(inputExtension);

                assertNotNull(inputFormat, "unknown input format: " + inputExtension);

                Set<DocumentFormat> outputFormats = formatRegistry.getOutputFormats(inputFormat.getInputFamily());

                for (DocumentFormat outputFormat : outputFormats) {

                    File outputFile = File.createTempFile("test", "." + outputFormat.getExtension());

                    outputFile.deleteOnExit();

                    System.out.printf("-- converting %s to %s... ", inputFormat.getExtension(), outputFormat.getExtension());

                    converter.convert(inputFile, outputFile, outputFormat);

                    System.out.printf("done.\n");

                    assertTrue(outputFile.isFile() && outputFile.length() > 0);

                    //TODO use file detection to make sure outputFile is in the expected format

                }

            }

        } finally {

            officeManager.stop();

        }

    }

    private ReflectionUtils() {

        throw new AssertionError("utility class must not be instantiated");

    }

    public static Object getPrivateField(Object instance, String fieldName) throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException {

        return getPrivateField(instance.getClass(), instance, fieldName);

    }

    public static Object getPrivateField(Class<?> type, Object instance, String fieldName) throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException {

        Field field = type.getDeclaredField(fieldName);

        field.setAccessible(true);

        return field.get(instance);

    }

    private long delayTime = 0L;

    private boolean completed = false;

    public MockOfficeTask() {

        // default

    }

    public MockOfficeTask(long delayTime) {

        this.delayTime = delayTime;

    }

    public void execute(OfficeContext context) throws OfficeException {

        XComponentLoader loader = cast(XComponentLoader.class, context.getService(SERVICE_DESKTOP));

        assert loader != null : "desktop object is null";

        try {

            PropertyValue[] arguments = new PropertyValue[] { property("Hidden", true) };

            XComponent document = loader.loadComponentFromURL("private:factory/swriter", "_blank", 0, arguments);

            if (delayTime > 0) {

                Thread.sleep(delayTime);

            }

            cast(XCloseable.class, document).close(true);

            completed = true;

        } catch (Exception exception) {

            throw new OfficeException("failed to create document", exception);

        }

    }

    public boolean isCompleted() {

        return completed;

    }

@Test(groups="integration")

    public void executeTask() throws Exception {

        UnoUrl unoUrl = UnoUrl.socket(2002);

        OfficeProcess officeProcess = new OfficeProcess(OfficeUtils.getDefaultOfficeHome(), unoUrl,

            null, null, new File(System.getProperty("java.io.tmpdir")), new PureJavaProcessManager());

        officeProcess.start();

        Thread.sleep(2000);

        Integer exitCode = officeProcess.getExitCode();

        if (exitCode != null && exitCode.equals(Integer.valueOf(81))) {

            officeProcess.start(true);

            Thread.sleep(2000);

        }

        ExternalOfficeManager manager = new ExternalOfficeManager(unoUrl, true);

        manager.start();

        MockOfficeTask task = new MockOfficeTask();

        manager.execute(task);

        assertTrue(task.isCompleted());

        manager.stop();

        //TODO replace when OfficeProcess has a forciblyTerminate()

        Process process = (Process) ReflectionUtils.getPrivateField(officeProcess, "process");

        process.destroy();

    }

    //TODO test auto-reconnection

@Test(groups="integration")

    private static final UnoUrl CONNECTION_MODE = UnoUrl.socket(2002);

    private static final long RESTART_WAIT_TIME = 2 * 1000;

    public void executeTask() throws Exception {

        PooledOfficeManager officeManager = new PooledOfficeManager(CONNECTION_MODE);

        ManagedOfficeProcess managedOfficeProcess = (ManagedOfficeProcess) ReflectionUtils.getPrivateField(officeManager, "managedOfficeProcess");

        OfficeProcess process = (OfficeProcess) ReflectionUtils.getPrivateField(managedOfficeProcess, "process");

        OfficeConnection connection = (OfficeConnection) ReflectionUtils.getPrivateField(managedOfficeProcess, "connection");

        officeManager.start();

        assertTrue(process.isRunning());

        assertTrue(connection.isConnected());

        MockOfficeTask task = new MockOfficeTask();

        officeManager.execute(task);

        assertTrue(task.isCompleted());

        officeManager.stop();

        assertFalse(connection.isConnected());

        assertFalse(process.isRunning());

        assertEquals(process.getExitCode(0, 0), 0);

    }

    public void restartAfterCrash() throws Exception {

        final PooledOfficeManager officeManager = new PooledOfficeManager(CONNECTION_MODE);

        ManagedOfficeProcess managedOfficeProcess = (ManagedOfficeProcess) ReflectionUtils.getPrivateField(officeManager, "managedOfficeProcess");

        OfficeProcess process = (OfficeProcess) ReflectionUtils.getPrivateField(managedOfficeProcess, "process");

        OfficeConnection connection = (OfficeConnection) ReflectionUtils.getPrivateField(managedOfficeProcess, "connection");

        assertNotNull(connection);

        officeManager.start();

        assertTrue(process.isRunning());

        assertTrue(connection.isConnected());

        new Thread() {

            public void run() {

                MockOfficeTask badTask = new MockOfficeTask(10 * 1000);

                try {

                    officeManager.execute(badTask);

                    fail("task should be cancelled");

                    //FIXME being in a separate thread the test won't actually fail

                } catch (OfficeException officeException) {

                    assertTrue(officeException.getCause() instanceof CancellationException);

                }

            }

        }.start();

        Thread.sleep(500);

        Process underlyingProcess = (Process) ReflectionUtils.getPrivateField(process, "process");

        assertNotNull(underlyingProcess);

        underlyingProcess.destroy();  // simulate crash

        Thread.sleep(RESTART_WAIT_TIME);

        assertTrue(process.isRunning());

        assertTrue(connection.isConnected());

        MockOfficeTask goodTask = new MockOfficeTask();

        officeManager.execute(goodTask);

        assertTrue(goodTask.isCompleted());

        officeManager.stop();

        assertFalse(connection.isConnected());

        assertFalse(process.isRunning());

        assertEquals(process.getExitCode(0, 0), 0);

    }

    public void restartAfterTaskTimeout() throws Exception {

        PooledOfficeManagerSettings configuration = new PooledOfficeManagerSettings(CONNECTION_MODE);

        configuration.setTaskExecutionTimeout(1500L);

        final PooledOfficeManager officeManager = new PooledOfficeManager(configuration);

        ManagedOfficeProcess managedOfficeProcess = (ManagedOfficeProcess) ReflectionUtils.getPrivateField(officeManager, "managedOfficeProcess");

        OfficeProcess process = (OfficeProcess) ReflectionUtils.getPrivateField(managedOfficeProcess, "process");

        OfficeConnection connection = (OfficeConnection) ReflectionUtils.getPrivateField(managedOfficeProcess, "connection");

        assertNotNull(connection);

        officeManager.start();

        assertTrue(process.isRunning());

        assertTrue(connection.isConnected());

        MockOfficeTask longTask = new MockOfficeTask(2000);

        try {

            officeManager.execute(longTask);

            fail("task should be timed out");

        } catch (OfficeException officeException) {

            assertTrue(officeException.getCause() instanceof TimeoutException);

        }

        Thread.sleep(RESTART_WAIT_TIME);

        assertTrue(process.isRunning());

        assertTrue(connection.isConnected());

        MockOfficeTask goodTask = new MockOfficeTask();

        officeManager.execute(goodTask);

        assertTrue(goodTask.isCompleted());

        officeManager.stop();

        assertFalse(connection.isConnected());

        assertFalse(process.isRunning());

        assertEquals(process.getExitCode(0, 0), 0);

    }

    public void restartWhenMaxTasksPerProcessReached() throws Exception {

        PooledOfficeManagerSettings configuration = new PooledOfficeManagerSettings(CONNECTION_MODE);

        configuration.setMaxTasksPerProcess(3);

        final PooledOfficeManager officeManager = new PooledOfficeManager(configuration);

        ManagedOfficeProcess managedOfficeProcess = (ManagedOfficeProcess) ReflectionUtils.getPrivateField(officeManager, "managedOfficeProcess");

        OfficeProcess process = (OfficeProcess) ReflectionUtils.getPrivateField(managedOfficeProcess, "process");

        OfficeConnection connection = (OfficeConnection) ReflectionUtils.getPrivateField(managedOfficeProcess, "connection");

        assertNotNull(connection);

        officeManager.start();

        assertTrue(process.isRunning());

        assertTrue(connection.isConnected());

        for (int i = 0; i < 3; i++) {

            MockOfficeTask task = new MockOfficeTask();

            officeManager.execute(task);

            assertTrue(task.isCompleted());

            int taskCount = (Integer) ReflectionUtils.getPrivateField(officeManager, "taskCount");

            assertEquals(taskCount, i + 1);

        }

        MockOfficeTask task = new MockOfficeTask();

        officeManager.execute(task);

        assertTrue(task.isCompleted());

        int taskCount = (Integer) ReflectionUtils.getPrivateField(officeManager, "taskCount");

        assertEquals(taskCount, 0);  //FIXME should be 1 to be precise

        officeManager.stop();

        assertFalse(connection.isConnected());

        assertFalse(process.isRunning());

        assertEquals(process.getExitCode(0, 0), 0);

    }

    public void testToUrl() {

        //TODO create separate tests for Windows

        assertEquals(toUrl(new File("/tmp/document.odt")), "file:///tmp/document.odt");

        assertEquals(toUrl(new File("/tmp/document with spaces.odt")), "file:///tmp/document%20with%20spaces.odt");

    }

    private static class SortedJsonObject extends JSONObject {

         public SortedJsonObject() {

             try {

                 Field field = JSONObject.class.getDeclaredField("myHashMap");

                 field.setAccessible(true);

                 field.set(this, new LinkedHashMap<String,Object>());

             } catch (Exception exception) {

                 // pass; will not be sorted

             }

        }

    }

    private static JSONObject toJson(DocumentFormat format) throws JSONException {

        JSONObject jsonFormat = new SortedJsonObject();

        jsonFormat.put("name", format.getName());

        jsonFormat.put("extension", format.getExtension());

        jsonFormat.put("mediaType", format.getMediaType());

        if (format.getInputFamily() != null) {

            jsonFormat.put("inputFamily", format.getInputFamily().name());

        }

        if (format.getLoadProperties() != null) {

            jsonFormat.put("loadProperties", toJson(format.getLoadProperties()));

        }

        if (format.getStorePropertiesByFamily() != null) {

            JSONObject jsonStorePropertiesByFamily = new SortedJsonObject();

            for (Map.Entry<DocumentFamily,Map<String,?>> entry : format.getStorePropertiesByFamily().entrySet()) {

                jsonStorePropertiesByFamily.put(entry.getKey().name(), toJson(entry.getValue()));

            }

            jsonFormat.put("storePropertiesByFamily", jsonStorePropertiesByFamily);

        }

        return jsonFormat;

    }

    @SuppressWarnings("unchecked")

    private static JSONObject toJson(Map<String,?> properties) throws JSONException {

        JSONObject jsonProperties = new SortedJsonObject();

        for (Map.Entry<String,?> entry : properties.entrySet()) {

            if (entry.getValue() instanceof Map) {

                Map<String,?> jsonValue = (Map<String,?>) entry.getValue();

                jsonProperties.put(entry.getKey(), toJson(jsonValue));

            } else {

                jsonProperties.put(entry.getKey(), entry.getValue());

            }

        }

        return jsonProperties;

    }

    public static void main(String[] args) throws Exception {

        DefaultDocumentFormatRegistry registry = new DefaultDocumentFormatRegistry();

        @SuppressWarnings("unchecked")

        List<DocumentFormat> formats = (List<DocumentFormat>) ReflectionUtils.getPrivateField(SimpleDocumentFormatRegistry.class, registry, "documentFormats");

        JSONArray array = new JSONArray();

        for (DocumentFormat format : formats) {

            array.put(toJson(format));

        }

        System.out.println(array.toString(2));

    }

    public void readJsonRegistry() throws JSONException, IOException {

        InputStream input = getClass().getResourceAsStream("/document-formats.js");

        DocumentFormatRegistry registry = null;

        try {

            registry = new JsonDocumentFormatRegistry(input);

        } finally {

            IOUtils.closeQuietly(input);

        }

        DocumentFormat odt = registry.getFormatByExtension("odt");

        assertNotNull(odt);

        assertNotNull(odt.getStoreProperties(DocumentFamily.TEXT));

    }

    public void linuxProcessManager() throws Exception {

        if (!PlatformUtils.isLinux()) {

            throw new SkipException("LinuxProcessManager can only be tested on Linux");

        }

        ProcessManager processManager = new LinuxProcessManager();

        Process process = new ProcessBuilder("sleep", "5s").start();

        ProcessQuery query = new ProcessQuery("sleep", "5s");

        long pid = processManager.findPid(query);

        assertFalse(pid == ProcessManager.PID_NOT_FOUND);

        Integer javaPid = (Integer) ReflectionUtils.getPrivateField(process, "pid");

        assertEquals(pid, javaPid.longValue());

        processManager.kill(process, pid);

        assertEquals(processManager.findPid(query), ProcessManager.PID_NOT_FOUND);

    }

    public void sigarProcessManager() throws Exception {

        ProcessManager processManager = new SigarProcessManager();

        Process process = new ProcessBuilder("sleep", "5s").start();

        ProcessQuery query = new ProcessQuery("sleep", "5s");

        long pid = processManager.findPid(query);

        assertFalse(pid == ProcessManager.PID_NOT_FOUND);

        if (PlatformUtils.isLinux()) {

            Integer javaPid = (Integer) ReflectionUtils.getPrivateField(process, "pid");

            assertEquals(pid, javaPid.longValue());

        }

        processManager.kill(process, pid);

        assertEquals(processManager.findPid(query), ProcessManager.PID_NOT_FOUND);

    }

  <id>dist</id>

  <formats>

    <format>zip</format>

  </formats>

  <dependencySets>

    <dependencySet>

      <outputDirectory>lib</outputDirectory>

      <excludes>

        <exclude>org.hyperic:sigar</exclude>

      </excludes>

    </dependencySet>

  </dependencySets>

  <fileSets>

    <fileSet>

      <includes>

        <include>LICENSE.txt</include>

        <include>README.txt</include>

      </includes>

    </fileSet>

    <fileSet>

      <directory>target</directory>

      <outputDirectory>/</outputDirectory>

      <includes>

        <include>${project.artifactId}-${project.version}-javadoc.jar</include>

        <include>${project.artifactId}-${project.version}-sources.jar</include>

      </includes>

    </fileSet>

    <fileSet>

      <directory>src/main/resources</directory>

      <outputDirectory>/conf</outputDirectory>

      <includes>

        <include>document-formats.js</include>

      </includes>

    </fileSet>

  </fileSets>

    public static final int STATUS_OK = 0;

    public static final int STATUS_MISSING_INPUT_FILE = 1;

    public static final int STATUS_INVALID_ARGUMENTS = 255;

    private static final Option OPTION_OUTPUT_FORMAT = new Option("o", "output-format", true, "output format (e.g. pdf)");

    private static final Option OPTION_PORT = new Option("p", "port", true, "office socket port (optional; defaults to 2002)");

    private static final Option OPTION_REGISTRY = new Option("r", "registry", true, "document formats registry configuration file (optional)");

    private static final Option OPTION_TIMEOUT = new Option("t", "timeout", true, "maximum conversion time in seconds (optional; defaults to 120)");

    private static final Option OPTION_USER_PROFILE = new Option("u", "user-profile", true, "use settings from the given user installation dir (optional)");

    private static final Options OPTIONS = initOptions();

    private static final int DEFAULT_OFFICE_PORT = 2002;

    private static Options initOptions() {

        Options options = new Options();

        options.addOption(OPTION_OUTPUT_FORMAT);

        options.addOption(OPTION_PORT);

        options.addOption(OPTION_REGISTRY);

        options.addOption(OPTION_TIMEOUT);

        options.addOption(OPTION_USER_PROFILE);

        return options;

    }

    public static void main(String[] arguments) throws ParseException, JSONException, IOException {

        CommandLineParser commandLineParser = new PosixParser();

        CommandLine commandLine = commandLineParser.parse(OPTIONS, arguments);

        String outputFormat = null;

        if (commandLine.hasOption(OPTION_OUTPUT_FORMAT.getOpt())) {

            outputFormat = commandLine.getOptionValue(OPTION_OUTPUT_FORMAT.getOpt());

        }

        int port = DEFAULT_OFFICE_PORT;

        if (commandLine.hasOption(OPTION_PORT.getOpt())) {

            port = Integer.parseInt(commandLine.getOptionValue(OPTION_PORT.getOpt()));

        }

        String[] fileNames = commandLine.getArgs();

        if ((outputFormat == null && fileNames.length != 2) || fileNames.length < 1) {

            String syntax = "java -jar jodconverter-core.jar [options] input-file output-file\n"

                    + "or [options] -o output-format input-file [input-file...]";

            HelpFormatter helpFormatter = new HelpFormatter();

            helpFormatter.printHelp(syntax, OPTIONS);

//            System.exit(STATUS_INVALID_ARGUMENTS);

        }

        DocumentFormatRegistry registry;

        if (commandLine.hasOption(OPTION_REGISTRY.getOpt())) {

            File registryFile = new File(commandLine.getOptionValue(OPTION_REGISTRY.getOpt()));

            registry = new JsonDocumentFormatRegistry(FileUtils.readFileToString(registryFile));

        } else {

            registry = new DefaultDocumentFormatRegistry();

        }

        DefaultOfficeManagerConfiguration configuration = new DefaultOfficeManagerConfiguration();

        configuration.setPortNumber(port);

        if (commandLine.hasOption(OPTION_TIMEOUT.getOpt())) {

            int timeout = Integer.parseInt(commandLine.getOptionValue(OPTION_TIMEOUT.getOpt()));

            configuration.setTaskExecutionTimeout(timeout * 1000);

        }

        if (commandLine.hasOption(OPTION_USER_PROFILE.getOpt())) {

            String templateProfileDir = commandLine.getOptionValue(OPTION_USER_PROFILE.getOpt());

            configuration.setTemplateProfileDir(new File(templateProfileDir));

        }

        OfficeManager officeManager = configuration.buildOfficeManager();

        officeManager.start();

        OfficeDocumentConverter converter = new OfficeDocumentConverter(officeManager, registry);

        try {

            if (outputFormat == null) {

                File inputFile = new File(fileNames[0]);

                File outputFile = new File(fileNames[1]);

                converter.convert(inputFile, outputFile);

            } else {

                for (int i = 0; i < fileNames.length; i++) {

                    File inputFile = new File(fileNames[i]);

                    String outputName = FilenameUtils.getBaseName(fileNames[i]) + "." + outputFormat;

                    File outputFile = new File(FilenameUtils.getFullPath(fileNames[i]) + outputName);

                    converter.convert(inputFile, outputFile);

                }

            }

        } finally {

            officeManager.stop();

        }

    }

    private final DocumentFormat outputFormat;

    private Map<String,?> defaultLoadProperties;

    private DocumentFormat inputFormat;

    public StandardConversionTask(File inputFile, File outputFile, DocumentFormat outputFormat) {

        super(inputFile, outputFile);

        this.outputFormat = outputFormat;

    }

    public void setDefaultLoadProperties(Map<String, ?> defaultLoadProperties) {

        this.defaultLoadProperties = defaultLoadProperties;

    }

    public void setInputFormat(DocumentFormat inputFormat) {

        this.inputFormat = inputFormat;

    }

    @Override

    protected void modifyDocument(XComponent document) throws OfficeException {

        XRefreshable refreshable = cast(XRefreshable.class, document);

        if (refreshable != null) {

            refreshable.refresh();

        }

    }

    @Override

    protected Map<String,?> getLoadProperties(File inputFile) {

        Map<String,Object> loadProperties = new HashMap<String,Object>();

        if (defaultLoadProperties != null) {

            loadProperties.putAll(defaultLoadProperties);

        }

        if (inputFormat != null && inputFormat.getLoadProperties() != null) {

            loadProperties.putAll(inputFormat.getLoadProperties());

        }

        return loadProperties;

    }

    @Override

    protected Map<String,?> getStoreProperties(File outputFile, XComponent document) {

        DocumentFamily family = OfficeDocumentUtils.getDocumentFamily(document);

        return outputFormat.getStoreProperties(family);

    }

    private OfficeDocumentUtils() {

        throw new AssertionError("utility class must not be instantiated");

    }

    public static DocumentFamily getDocumentFamily(XComponent document) throws OfficeException {

        XServiceInfo serviceInfo = cast(XServiceInfo.class, document);

        if (serviceInfo.supportsService("com.sun.star.text.GenericTextDocument")) {

            // NOTE: a GenericTextDocument is either a TextDocument, a WebDocument, or a GlobalDocument

            // but this further distinction doesn't seem to matter for conversions

            return DocumentFamily.TEXT;

        } else if (serviceInfo.supportsService("com.sun.star.sheet.SpreadsheetDocument")) {

            return DocumentFamily.SPREADSHEET;

        } else if (serviceInfo.supportsService("com.sun.star.presentation.PresentationDocument")) {

            return DocumentFamily.PRESENTATION;

        } else if (serviceInfo.supportsService("com.sun.star.drawing.DrawingDocument")) {

            return DocumentFamily.DRAWING;

        } else {

            throw new OfficeException("document of unknown family: " + serviceInfo.getImplementationName());

        }

    }

    public static final long DEFAULT_RETRY_INTERVAL = 250L;

    private final UnoUrl unoUrl;

    private File officeHome = OfficeUtils.getDefaultOfficeHome();

    private String[] runAsArgs;

    private File templateProfileDir;

    private File workDir = new File(System.getProperty("java.io.tmpdir"));

    private ProcessManager processManager = new PureJavaProcessManager();

    private long retryTimeout = DefaultOfficeManagerConfiguration.DEFAULT_RETRY_TIMEOUT;

    private long retryInterval = DEFAULT_RETRY_INTERVAL;

    public ManagedOfficeProcessSettings(UnoUrl unoUrl) {

        this.unoUrl = unoUrl;

    }

    public UnoUrl getUnoUrl() {

        return unoUrl;

    }

    public File getOfficeHome() {

        return officeHome;

    }

    public void setOfficeHome(File officeHome) {

        this.officeHome = officeHome;

    }

    public String[] getRunAsArgs() {

    public void setRunAsArgs(String[] runAsArgs) {

    public File getTemplateProfileDir() {

        return templateProfileDir;

    }

    public void setTemplateProfileDir(File templateProfileDir) {

        this.templateProfileDir = templateProfileDir;

    }

    public File getWorkDir() {

        return workDir;

    }

    public void setWorkDir(File workDir) {

        this.workDir = workDir;

    }

    public ProcessManager getProcessManager() {

        return processManager;

    }

    public void setProcessManager(ProcessManager processManager) {

        this.processManager = processManager;

    }

    public long getRetryTimeout() {

        return retryTimeout;

    }

    public void setRetryTimeout(long retryTimeout) {

        this.retryTimeout = retryTimeout;

    }

    public long getRetryInterval() {

        return retryInterval;

    }

    public void setRetryInterval(long retryInterval) {

        this.retryInterval = retryInterval;

    }

    /**

     * @throws TemporaryException for an error condition that can be temporary - i.e. retrying later could be successful

     * @throws Exception for all other error conditions

     */

    protected abstract void attempt() throws TemporaryException, Exception;

    public void execute(long interval, long timeout) throws RetryTimeoutException, Exception {

        execute(0L, interval, timeout);

    }

    public void execute(long delay, long interval, long timeout) throws RetryTimeoutException, Exception {

        long start = System.currentTimeMillis();

        if (delay > 0L) {

            sleep(delay);

        }

        while (true) {

            try {

                attempt();

                return;

            } catch (TemporaryException temporaryException) {

                if (System.currentTimeMillis() - start < timeout) {

                    sleep(interval);

                    // continue

                } else {

                    throw new RetryTimeoutException(temporaryException.getCause());

                }

            }

        }

    }

    private void sleep(long millis) {

        try {

            Thread.sleep(millis);

        } catch (InterruptedException interruptedException) {

            // continue

        }

    }