/*
|
* The contents of this file are subject to the terms of the Common Development and
|
* Distribution License (the License). You may not use this file except in compliance with the
|
* License.
|
*
|
* You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
|
* specific language governing permission and limitations under the License.
|
*
|
* When distributing Covered Software, include this CDDL Header Notice in each file and include
|
* the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
|
* Header, with the fields enclosed by brackets [] replaced by your own identifying
|
* information: "Portions copyright [year] [name of copyright owner]".
|
*
|
* Copyright 2026 3A Systems, LLC.
|
*/
|
package org.opends.quicksetup;
|
|
import static java.nio.charset.Charset.defaultCharset;
|
import static java.nio.file.StandardOpenOption.APPEND;
|
import static org.testng.Assert.assertEquals;
|
import static org.testng.Assert.assertFalse;
|
import static org.testng.Assert.assertNotEquals;
|
import static org.testng.Assert.assertTrue;
|
import static org.testng.Assert.fail;
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.lang.reflect.Method;
|
import java.nio.file.Files;
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.List;
|
|
import org.opends.server.DirectoryServerTestCase;
|
import org.opends.server.TestCaseUtils;
|
import org.opends.server.loggers.ErrorLogger;
|
import org.testng.SkipException;
|
import org.testng.annotations.AfterClass;
|
import org.testng.annotations.BeforeClass;
|
import org.testng.annotations.Test;
|
|
/**
|
* Tests that a {@link TempLogFile} can be placed in a directory of the caller's choosing (the
|
* instance {@code logs/} directory for setup, so that {@code start-ds} does not sweep it away
|
* with the rest of {@code tmp/}, see issue #1030), and that it tells whether the file is still
|
* there to be read.
|
*/
|
@SuppressWarnings("javadoc")
|
@Test(groups = { "precommit", "quicksetup" }, sequential = true)
|
public class TempLogFileTest extends DirectoryServerTestCase
|
{
|
private static final String PREFIX = "opendj-setup-";
|
|
private File tempDir;
|
private final List<TempLogFile> created = new ArrayList<>();
|
|
@BeforeClass
|
public void setUp() throws IOException
|
{
|
tempDir = TestCaseUtils.createTemporaryDirectory("tempLogFileTest");
|
}
|
|
@AfterClass
|
public void tearDown() throws IOException
|
{
|
for (TempLogFile logFile : created)
|
{
|
logFile.deleteLogFileAfterSuccess();
|
}
|
TestCaseUtils.deleteDirectory(tempDir);
|
}
|
|
private TempLogFile track(TempLogFile logFile)
|
{
|
created.add(logFile);
|
return logFile;
|
}
|
|
private static File parentOf(TempLogFile logFile) throws IOException
|
{
|
return logFile.getLogFile().getCanonicalFile().getParentFile();
|
}
|
|
/** The directory does not exist before setup lays the instance down: it has to be created. */
|
@Test
|
public void testLogFileIsCreatedInTheRequestedDirectory() throws Exception
|
{
|
final File logs = new File(tempDir, "not-yet-laid-down/logs");
|
assertFalse(logs.exists());
|
|
final TempLogFile logFile = track(TempLogFile.newTempLogFile(PREFIX, logs));
|
|
assertTrue(logFile.isEnabled());
|
assertTrue(logFile.isReadable());
|
assertEquals(parentOf(logFile), logs.getCanonicalFile());
|
assertTrue(logFile.getLogFile().getName().startsWith(PREFIX), logFile.getPath());
|
assertTrue(logFile.getLogFile().getName().endsWith(".log"), logFile.getPath());
|
}
|
|
@Test
|
public void testReadContentsReturnsWhatIsInTheFile() throws Exception
|
{
|
final TempLogFile logFile = track(TempLogFile.newTempLogFile(PREFIX, new File(tempDir, "logs")));
|
// The log's own stream is not in append mode and sits at the end of its own bytes, so a
|
// record written after the marker would be written over it: shut the writer first, and
|
// the marker is the last thing in the file whatever else the JVM logs.
|
logFile.writer.shutdown();
|
final String marker = "the last line written before the failure";
|
Files.write(logFile.getLogFile().toPath(), (marker + "\n").getBytes(defaultCharset()), APPEND);
|
|
assertTrue(logFile.readContents().endsWith(marker + "\n"));
|
}
|
|
/** Being enabled means messages are logged; being readable means the file is there to hand over. */
|
@Test
|
public void testIsReadableFollowsTheFileNotTheLogger() throws Exception
|
{
|
final TempLogFile logFile = track(TempLogFile.newTempLogFile(PREFIX, new File(tempDir, "logs")));
|
assertTrue(logFile.isReadable());
|
|
// Not File.delete(): the writer still holds the file, and Windows does not delete a file
|
// that is open. deleteLogFileAfterSuccess() shuts the writer first, as setup does.
|
logFile.deleteLogFileAfterSuccess();
|
assertFalse(logFile.getLogFile().exists());
|
|
assertTrue(logFile.isEnabled());
|
assertFalse(logFile.isReadable());
|
try
|
{
|
logFile.readContents();
|
fail("reading a deleted log must fail");
|
}
|
catch (IOException expected)
|
{
|
// the caller reports it instead of promising the file
|
}
|
}
|
|
/** A directory where the log was is not a log: there is nothing to hand over either. */
|
@Test
|
public void testADirectoryAtTheLogPathIsNotReadable() throws Exception
|
{
|
final TempLogFile logFile = track(TempLogFile.newTempLogFile(PREFIX, new File(tempDir, "logs")));
|
logFile.deleteLogFileAfterSuccess();
|
assertTrue(logFile.getLogFile().mkdir());
|
|
assertTrue(Files.isReadable(logFile.getLogFile().toPath()));
|
assertFalse(logFile.isReadable());
|
}
|
|
@Test
|
public void testNoDirectoryMeansTheTemporaryDirectory() throws Exception
|
{
|
final TempLogFile logFile = track(TempLogFile.newTempLogFile(PREFIX, null));
|
|
assertTrue(logFile.isEnabled());
|
assertEquals(parentOf(logFile), new File(System.getProperty("java.io.tmpdir")).getCanonicalFile());
|
}
|
|
/** A directory that cannot be used must not cost the log: fall back to the temporary directory. */
|
@Test
|
public void testUnusableDirectoryFallsBackToTheTemporaryDirectory() throws Exception
|
{
|
final File notADirectory = new File(tempDir, "not-a-directory");
|
assertTrue(notADirectory.createNewFile());
|
|
final TempLogFile logFile = track(TempLogFile.newTempLogFile(PREFIX, notADirectory));
|
|
assertTrue(logFile.isEnabled());
|
assertTrue(logFile.isReadable());
|
assertNotEquals(parentOf(logFile), notADirectory.getCanonicalFile());
|
assertEquals(parentOf(logFile), new File(System.getProperty("java.io.tmpdir")).getCanonicalFile());
|
|
// Why the log is not where it was asked for is warned about once there is a log to carry
|
// the warning: at the point the directory failed, no publisher was installed yet.
|
assumeTheLogGoesToTheFile();
|
logFile.writer.shutdown();
|
final String contents = logFile.readContents();
|
assertTrue(contents.contains("falling back to the temporary directory"), contents);
|
assertTrue(contents.contains(notADirectory.toString()), contents);
|
}
|
|
/**
|
* The publishers the constructor puts on the logger singletons come off again with the log:
|
* the singletons outlive the file, and what a leaked publisher is handed goes to a closed
|
* stream and is swallowed.
|
*/
|
@Test
|
public void testDeletingTheLogTakesItsPublisherOffTheLogger() throws Exception
|
{
|
final int before = errorLogPublishers();
|
|
final TempLogFile logFile = track(TempLogFile.newTempLogFile(PREFIX, new File(tempDir, "logs")));
|
assertEquals(errorLogPublishers(), before + 1, "the log logs through a publisher of its own");
|
|
logFile.deleteLogFileAfterSuccess();
|
|
assertEquals(errorLogPublishers(), before, "the publisher must not outlive the log");
|
}
|
|
/** How many publishers the error logger holds; {@code getLogPublishers()} is protected. */
|
private static int errorLogPublishers() throws Exception
|
{
|
final Method getLogPublishers = ErrorLogger.class.getDeclaredMethod("getLogPublishers");
|
getLogPublishers.setAccessible(true);
|
return ((Collection<?>) getLogPublishers.invoke(ErrorLogger.getInstance())).size();
|
}
|
|
/**
|
* {@code OPENDJ_LOG_TO_STDOUT} sends the records to stdout and leaves the file empty, so a
|
* case which reads the log back has nothing to look at.
|
*/
|
private static void assumeTheLogGoesToTheFile()
|
{
|
if ("true".equalsIgnoreCase(System.getenv("OPENDJ_LOG_TO_STDOUT")))
|
{
|
throw new SkipException("OPENDJ_LOG_TO_STDOUT writes the log to stdout, not to the file");
|
}
|
}
|
}
|
