CheckInstance.java revision 62ecec3a82a8b838ee76c1f6610902d8fd7015cb
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
* add the following below this CDDL HEADER, with the fields enclosed
* by brackets "[]" replaced with your own identifying information:
* Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
*
* Copyright 2006-2009 Sun Microsystems, Inc.
*/
package org.opends.server.tools.configurator;
import java.io.File;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import org.opends.quicksetup.ReturnCode;
import org.opends.server.util.args.ArgumentException;
import org.opends.server.util.args.ArgumentParser;
import org.opends.server.util.args.StringArgument;
import java.io.InputStreamReader;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.opends.messages.Message;
import org.opends.quicksetup.Installation;
import org.opends.server.util.args.BooleanArgument;
import java.util.StringTokenizer;
import org.opends.quicksetup.BuildInformation;
import org.opends.quicksetup.QuickSetupLog;
import static org.opends.messages.ToolMessages.*;
import static org.opends.messages.QuickSetupMessages.*;
import static org.opends.server.util.DynamicConstants.*;
/**
* This class is called by the configure command line to move the default
* Directory Server instance.
*/
public class CheckInstance {
static private final Logger LOG = Logger.getLogger(
CheckInstance.class.getName());
/** Prefix for log files. */
static public final String LOG_FILE_PREFIX = "opends-checkinstance-";
private static String installRootFromSystem;
private static String instanceRootFromSystem;
/**
* The user that launches this application.
*/
public static final String CURRENT_USER_OPTION_LONG = "currentUser";
/**
* The value for the short option 'currentUser'.
*/
public static final Character CURRENT_USER_OPTION_SHORT = null;
/**
* Should version be verified.
*/
public static final String CHECK_VERSION_OPTION_LONG = "checkVersion";
/**
* The value for the short option 'checkVersion'.
*/
public static final Character CHECK_VERSION_OPTION_SHORT = null;
private static StringArgument currentUserArg;
private static BooleanArgument checkVersionArg;
private static String currentUser;
private static String instanceOwner;
private static boolean isWin;
private static int SUCCESS = 0;
private static int ARGS_ERROR = 1;
private static int USER_ERROR = 2;
private static int VERSION_ERROR = 3;
/**
* Creates a copy of the specified file.
*
* @param from The source file to be copied.
* @param to The destination file to be created.
*
* @throws IOException If a problem occurs.
*/
private static void copyFile(File from, File to)
throws IOException
{
byte[] buffer = new byte[4096];
FileInputStream inputStream = null;
FileOutputStream outputStream = null;
try
{
inputStream = new FileInputStream(from);
outputStream = new FileOutputStream(to, false);
int bytesRead = inputStream.read(buffer);
while (bytesRead > 0)
{
outputStream.write(buffer, 0, bytesRead);
bytesRead = inputStream.read(buffer);
}
}
finally
{
if (inputStream != null)
{
try
{
inputStream.close();
}
catch (Exception e)
{
}
}
if (outputStream != null)
{
outputStream.close();
}
}
}
/**
* The main method which is called by the configure command lines.
*
* @param args the arguments passed by the command line.
*/
public static void main(String[] args) {
try {
QuickSetupLog.initLogFileHandler(
File.createTempFile(LOG_FILE_PREFIX,
QuickSetupLog.LOG_FILE_SUFFIX));
} catch (Throwable t) {
System.err.println(INFO_ERROR_INITIALIZING_LOG.get());
t.printStackTrace();
}
// Create the command-line argument parser for use with this program.
Message toolDescription = INFO_CHECK_DESCRIPTION.get();
ArgumentParser argParser =
new ArgumentParser(CheckInstance.class.getName(),
toolDescription, false);
installRootFromSystem = System.getProperty("INSTALL_ROOT");
if (installRootFromSystem == null) {
System.err
.println(ERR_INTERNAL.get(ERR_INSTALL_ROOT_NOT_SPECIFIED.get()));
System.exit(ReturnCode.APPLICATION_ERROR.getReturnCode());
}
instanceRootFromSystem = System.getProperty("INSTANCE_ROOT");
if (instanceRootFromSystem == null) {
System.err.println(ERR_INTERNAL
.get(ERR_INSTANCE_ROOT_NOT_SPECIFIED.get()));
System.exit(ReturnCode.APPLICATION_ERROR.getReturnCode());
}
isWin = System.getProperty("file.separator").equals("\\");
// Initialize all the command-line argument types and register them with the
// parser.
try {
if (!isWin) {
currentUserArg = new StringArgument(CURRENT_USER_OPTION_LONG,
CURRENT_USER_OPTION_SHORT,
CURRENT_USER_OPTION_LONG,
true, true,
INFO_CURRENT_USER_PLACEHOLDER.get(),
INFO_CHECK_DESCRIPTION_CURRENT_USER.get());
argParser.addArgument(currentUserArg);
}
checkVersionArg = new BooleanArgument(CHECK_VERSION_OPTION_LONG,
CHECK_VERSION_OPTION_SHORT,
CHECK_VERSION_OPTION_LONG,
INFO_CHECK_DESCRIPTION_CHECK_VERSION.get());
argParser.addArgument(checkVersionArg);
} catch (ArgumentException ae) {
System.err.println(ERR_INTERNAL.get(ae.getMessageObject()));
System.exit(ReturnCode.APPLICATION_ERROR.getReturnCode());
}
// Parse the command-line arguments provided to this program.
try {
argParser.parseArguments(args);
} catch (ArgumentException ae) {
System.err.println(ERR_INTERNAL.get(ae.getMessageObject()));
System.exit(ARGS_ERROR);
}
File confDir = new File(instanceRootFromSystem,
Installation.CONFIG_PATH_RELATIVE);
if (!isWin) {
// Check user
File conf = new File (confDir, Installation.CURRENT_CONFIG_FILE_NAME);
String cmd = null;
Process proc = null;
int exit = 0;
InputStreamReader reader = null;
int c;
StringBuffer sb = new StringBuffer();
cmd = "ls -l " + conf.getAbsolutePath();
try {
proc = Runtime.getRuntime().exec(cmd);
proc.waitFor();
reader = new InputStreamReader(proc.getInputStream());
while (((c = reader.read()) != -1)) {
sb.append((char) c);
}
exit = proc.exitValue();
if (exit != 0) {
LOG.log(Level.FINEST, cmd + " error= " + exit);
System.err.println(ERR_CONFIG_LDIF_NOT_FOUND.get(conf.getAbsolutePath(),
installRootFromSystem + File.separator + "instance.loc"));
System.exit(ReturnCode.APPLICATION_ERROR.getReturnCode());
}
} catch (InterruptedException ex) {
LOG.log(Level.SEVERE, "InterruptedException" + ex.getMessage());
System.err.println(ERR_CONFIG_LDIF_NOT_FOUND.get(conf.getAbsolutePath(),
installRootFromSystem + File.separator + "instance.loc"));
System.exit(ReturnCode.APPLICATION_ERROR.getReturnCode());
} catch (IOException ex) {
LOG.log(Level.SEVERE, "IOException" + ex.getMessage() );
System.err.println(ERR_CONFIG_LDIF_NOT_FOUND.get(conf.getAbsolutePath(),
installRootFromSystem + File.separator + "instance.loc"));
System.exit(ReturnCode.APPLICATION_ERROR.getReturnCode());
}
LOG.log(Level.FINEST, cmd + " returns [" + sb.toString() + "]");
StringTokenizer tok = new StringTokenizer(sb.toString());
if (tok.hasMoreTokens()) {
// access rights
tok.nextToken();
if (tok.hasMoreTokens()) {
// inode
tok.nextToken();
if (tok.hasMoreTokens()) {
instanceOwner = tok.nextToken();
LOG.log(Level.FINEST, "instanceOwner=[" + instanceOwner + "]");
} else {
LOG.log(Level.SEVERE, "no instanceOwner");
System.err.println(ERR_INTERNAL.get(Message.raw("no instanceOwner")));
System.exit(ReturnCode.APPLICATION_ERROR.getReturnCode());
}
} else {
LOG.log(Level.SEVERE, "no inode");
System.err.println(ERR_INTERNAL.get(Message.raw("no inode")));
System.exit(ReturnCode.APPLICATION_ERROR.getReturnCode());
}
} else {
LOG.log(Level.SEVERE, "no access rights");
System.err.println(ERR_INTERNAL.get(Message.raw("no access rights")));
System.exit(ReturnCode.APPLICATION_ERROR.getReturnCode());
}
currentUser = currentUserArg.getValue();
LOG.log(Level.FINEST, "currentUser=[" + currentUser + "]");
if ((currentUser != null) && !(currentUser.equals(instanceOwner))) {
System.err.println(ERR_CHECK_USER_ERROR.get(instanceOwner));
System.exit(USER_ERROR);
}
}
// Initialize buildinfo in not already done (ZIP delivery)
BuildInformation installBi =
BuildInformation.fromBuildString(MAJOR_VERSION +
"." + MINOR_VERSION +
"." + POINT_VERSION +
"." + REVISION_NUMBER);
File bif = new File(confDir, Installation.BUILDINFO_RELATIVE_PATH);
if (!bif.exists()) {
FileWriter fwriter = null;
try {
fwriter = new FileWriter(bif, true);
fwriter.append(installBi.getBuildString());
} catch (Exception e) {
} finally {
try {
fwriter.close();
} catch (Exception e) {
}
}
}
// Check version
if (checkVersionArg.isPresent()) {
BuildInformation instanceBi = installBi;
try {
if (bif.exists()) {
BufferedReader breader = new BufferedReader(new FileReader(bif));
// Read the first line and close the file.
String line;
try {
line = breader.readLine();
instanceBi = BuildInformation.fromBuildString(line);
} finally {
try {
breader.close();
} catch (Exception e) {
}
}
// For pkg(5) delivery: update the file to avoid overwrite
// during upgrade
FileWriter fwriter = new FileWriter(bif, true);
try {
fwriter.append('\n');
} finally {
try {
fwriter.close();
} catch (Exception e) {
}
}
}
} catch (Exception e) {
LOG.log(Level.SEVERE, "error getting build information for " +
"current instance", e);
}
if (!installBi.equals(instanceBi)) {
System.err.println(ERR_CHECK_VERSION_NOT_MATCH.get());
System.exit(VERSION_ERROR);
}
} else {
LOG.log(Level.FINEST, "checkVersion not specified");
}
// For pkg(5) delivery: if config/upgrade/*.ldif.REV does not exist
try {
File upgradeDir = new File(confDir, Installation.UPGRADE_PATH);
File tmplUpgradeDir = new File(installRootFromSystem + File.separator +
Installation.TMPL_INSTANCE_RELATIVE_PATH +
File.separator + Installation.CONFIG_PATH_RELATIVE +
File.separator + Installation.UPGRADE_PATH);
File concatenatedSchema = new File(upgradeDir,
"schema.ldif." + REVISION_NUMBER);
if (!concatenatedSchema.exists()) {
File tmplConcatenatedSchema = new File(tmplUpgradeDir,
"schema.ldif." + REVISION_NUMBER);
copyFile(tmplConcatenatedSchema, concatenatedSchema);
} else {
LOG.log(Level.INFO, concatenatedSchema.getAbsolutePath() +
"already exists");
}
File initialConfig = new File(upgradeDir,
"config.ldif." + REVISION_NUMBER);
if (!initialConfig.exists()) {
File tmplInitialConfig = new File(tmplUpgradeDir,
"config.ldif." + REVISION_NUMBER);
copyFile(tmplInitialConfig, initialConfig);
} else {
LOG.log(Level.INFO, initialConfig.getAbsolutePath() + "already exists");
}
} catch (Exception e) {
LOG.log(Level.SEVERE, "error initializing config/upgrade files", e);
}
System.exit(SUCCESS);
}
}