org.apache.hadoop.hdfs.server.common.IncorrectVersionException java code examples

/**
 * Verify version.
 * @param version layout version
 * @throws IOException on layout version mismatch
 */
void verifyLayoutVersion(int version) throws IOException {
 if (version != HdfsServerConstants.NAMENODE_LAYOUT_VERSION)
  throw new IncorrectVersionException(
    HdfsServerConstants.NAMENODE_LAYOUT_VERSION, version, "data node");
}

private void verifySoftwareVersion(DatanodeRegistration dnReg)
  throws IncorrectVersionException {
 String dnVersion = dnReg.getSoftwareVersion();
 if (VersionUtil.compareVersions(dnVersion, minimumDataNodeVersion) < 0) {
  IncorrectVersionException ive = new IncorrectVersionException(
    minimumDataNodeVersion, dnVersion, "DataNode", "NameNode");
  LOG.warn(ive.getMessage() + " DN: " + dnReg);
  throw ive;
 }
 String nnVersion = VersionInfo.getVersion();
 if (!dnVersion.equals(nnVersion)) {
  String messagePrefix = "Reported DataNode version '" + dnVersion +
    "' of DN " + dnReg + " does not match NameNode version '" +
    nnVersion + "'";
  long nnCTime = nn.getFSImage().getStorage().getCTime();
  long dnCTime = dnReg.getStorageInfo().getCTime();
  if (nnCTime != dnCTime) {
   IncorrectVersionException ive = new IncorrectVersionException(
     messagePrefix + " and CTime of DN ('" + dnCTime +
     "') does not match CTime of NN ('" + nnCTime + "')");
   LOG.warn(ive.toString(), ive);
   throw ive;
  } else {
   LOG.info(messagePrefix +
     ". Note: This is normal during a rolling upgrade.");
  }
 }
}

private void checkNNVersion(NamespaceInfo nsInfo)
  throws IncorrectVersionException {
 // build and layout versions should match
 String nnVersion = nsInfo.getSoftwareVersion();
 String minimumNameNodeVersion = dnConf.getMinimumNameNodeVersion();
 if (VersionUtil.compareVersions(nnVersion, minimumNameNodeVersion) < 0) {
  IncorrectVersionException ive = new IncorrectVersionException(
    minimumNameNodeVersion, nnVersion, "NameNode", "DataNode");
  LOG.warn(ive.getMessage());
  throw ive;
 }
 String dnVersion = VersionInfo.getVersion();
 if (!nnVersion.equals(dnVersion)) {
  LOG.info("Reported NameNode version '" + nnVersion + "' does not match " +
    "DataNode version '" + dnVersion + "' but is within acceptable " +
    "limits. Note: This is normal during a rolling upgrade.");
 }
}

private void checkNNVersion(NamespaceInfo nsInfo)
  throws IncorrectVersionException {
 // build and layout versions should match
 String nnVersion = nsInfo.getSoftwareVersion();
 String minimumNameNodeVersion = dnConf.getMinimumNameNodeVersion();
 if (VersionUtil.compareVersions(nnVersion, minimumNameNodeVersion) < 0) {
  IncorrectVersionException ive = new IncorrectVersionException(
    minimumNameNodeVersion, nnVersion, "NameNode", "DataNode");
  LOG.warn(ive.getMessage());
  throw ive;
 }
 String dnVersion = VersionInfo.getVersion();
 if (!nnVersion.equals(dnVersion)) {
  LOG.info("Reported NameNode version '" + nnVersion + "' does not match " +
    "DataNode version '" + dnVersion + "' but is within acceptable " +
    "limits. Note: This is normal during a rolling upgrade.");
 }
}

/** Validate and set layout version from {@link Properties}*/
protected void setLayoutVersion(Properties props, StorageDirectory sd)
  throws IncorrectVersionException, InconsistentFSStateException {
 int lv = Integer.parseInt(getProperty(props, sd, "layoutVersion"));
 if (lv < getServiceLayoutVersion()) { // future version
  throw new IncorrectVersionException(getServiceLayoutVersion(), lv,
    "storage directory " + sd.root.getAbsolutePath());
 }
 layoutVersion = lv;
}

private void verifySoftwareVersion(DatanodeRegistration dnReg)
  throws IncorrectVersionException {
 String dnVersion = dnReg.getSoftwareVersion();
 if (VersionUtil.compareVersions(dnVersion, minimumDataNodeVersion) < 0) {
  IncorrectVersionException ive = new IncorrectVersionException(
    minimumDataNodeVersion, dnVersion, "DataNode", "NameNode");
  LOG.warn(ive.getMessage() + " DN: " + dnReg);
  throw ive;
 }
 String nnVersion = VersionInfo.getVersion();
 if (!dnVersion.equals(nnVersion)) {
  String messagePrefix = "Reported DataNode version '" + dnVersion +
    "' of DN " + dnReg + " does not match NameNode version '" +
    nnVersion + "'";
  long nnCTime = nn.getFSImage().getStorage().getCTime();
  long dnCTime = dnReg.getStorageInfo().getCTime();
  if (nnCTime != dnCTime) {
   IncorrectVersionException ive = new IncorrectVersionException(
     messagePrefix + " and CTime of DN ('" + dnCTime +
     "') does not match CTime of NN ('" + nnCTime + "')");
   LOG.warn(ive.toString(), ive);
   throw ive;
  } else {
   LOG.info(messagePrefix +
     ". Note: This is normal during a rolling upgrade.");
  }
 }
}

private void checkNNVersion(NamespaceInfo nsInfo)
  throws IncorrectVersionException {
 // build and layout versions should match
 String nnVersion = nsInfo.getSoftwareVersion();
 String minimumNameNodeVersion = dnConf.getMinimumNameNodeVersion();
 if (VersionUtil.compareVersions(nnVersion, minimumNameNodeVersion) < 0) {
  IncorrectVersionException ive = new IncorrectVersionException(
    minimumNameNodeVersion, nnVersion, "NameNode", "DataNode");
  LOG.warn(ive.getMessage());
  throw ive;
 }
 String dnVersion = VersionInfo.getVersion();
 if (!nnVersion.equals(dnVersion)) {
  LOG.info("Reported NameNode version '" + nnVersion + "' does not match " +
    "DataNode version '" + dnVersion + "' but is within acceptable " +
    "limits. Note: This is normal during a rolling upgrade.");
 }
}

void readProperties(StorageDirectory sd, StartupOption startupOption)
  throws IOException {
 Properties props = readPropertiesFile(sd.getVersionFile());
 if (props == null) {
  throw new IOException(
    "Properties not found  for storage directory " + sd);
 }
 if (HdfsServerConstants.RollingUpgradeStartupOption.ROLLBACK
   .matches(startupOption)) {
  int lv = Integer.parseInt(getProperty(props, sd, "layoutVersion"));
  if (lv > getServiceLayoutVersion()) {
   // we should not use a newer version for rollingUpgrade rollback
   throw new IncorrectVersionException(getServiceLayoutVersion(), lv,
     "storage directory " + sd.getRoot().getAbsolutePath());
  }
  props.setProperty("layoutVersion",
    Integer.toString(HdfsServerConstants.NAMENODE_LAYOUT_VERSION));
 }
 setFieldsFromProperties(props, sd);
}

private void verifySoftwareVersion(DatanodeRegistration dnReg)
  throws IncorrectVersionException {
 String dnVersion = dnReg.getSoftwareVersion();
 if (VersionUtil.compareVersions(dnVersion, minimumDataNodeVersion) < 0) {
  IncorrectVersionException ive = new IncorrectVersionException(
    minimumDataNodeVersion, dnVersion, "DataNode", "NameNode");
  LOG.warn(ive.getMessage() + " DN: " + dnReg);
  throw ive;
 }
 String nnVersion = VersionInfo.getVersion();
 if (!dnVersion.equals(nnVersion)) {
  String messagePrefix = "Reported DataNode version '" + dnVersion +
    "' of DN " + dnReg + " does not match NameNode version '" +
    nnVersion + "'";
  long nnCTime = nn.getFSImage().getStorage().getCTime();
  long dnCTime = dnReg.getStorageInfo().getCTime();
  if (nnCTime != dnCTime) {
   IncorrectVersionException ive = new IncorrectVersionException(
     messagePrefix + " and CTime of DN ('" + dnCTime +
     "') does not match CTime of NN ('" + nnCTime + "')");
   LOG.warn(ive.toString(), ive);
   throw ive;
  } else {
   LOG.info(messagePrefix +
     ". Note: This is normal during a rolling upgrade.");
  }
 }
}

/**
 * Verify version.
 * @param version layout version
 * @throws IOException on layout version mismatch
 */
void verifyLayoutVersion(int version) throws IOException {
 if (version != HdfsConstants.NAMENODE_LAYOUT_VERSION)
  throw new IncorrectVersionException(
    HdfsConstants.NAMENODE_LAYOUT_VERSION, version, "data node");
}

/**
 * Verify version.
 * @param version layout version
 * @throws IOException on layout version mismatch
 */
void verifyLayoutVersion(int version) throws IOException {
 if (version != HdfsConstants.NAMENODE_LAYOUT_VERSION)
  throw new IncorrectVersionException(
    HdfsConstants.NAMENODE_LAYOUT_VERSION, version, "data node");
}

/**
 * Verify version.
 * 
 * @param version
 * @throws IOException
 */
public void verifyVersion(int version) throws IOException {
 if (version != LAYOUT_VERSION)
  throw new IncorrectVersionException(version, "data node");
}

/**
 * Verify version.
 * 
 * @param reportedVersion version reported by datanode
 * @param expectedVersion version expected by namenode
 * @param annotation explanation of the given version
 * @throws IncorrectVersionException
 */
public void verifyVersion(int reportedVersion,
  int expectedVersion, String annotation) throws IOException {
 if (reportedVersion != expectedVersion)
  throw new IncorrectVersionException(
    reportedVersion, "data node " + annotation, expectedVersion);
}

/** Validate and set layout version from {@link Properties}*/
protected void setLayoutVersion(Properties props, StorageDirectory sd)
  throws IncorrectVersionException, InconsistentFSStateException {
 int lv = Integer.parseInt(getProperty(props, sd, LAYOUT_VERSION));
 if (lv < FSConstants.LAYOUT_VERSION) { // future version
  throw new IncorrectVersionException(lv, "storage directory "
    + sd.root.getAbsolutePath());
 }
 layoutVersion = lv;
}

/** Validate and set layout version from {@link Properties}*/
protected void setLayoutVersion(Properties props, StorageDirectory sd)
  throws IncorrectVersionException, InconsistentFSStateException {
 int lv = Integer.parseInt(getProperty(props, sd, "layoutVersion"));
 if (lv < getServiceLayoutVersion()) { // future version
  throw new IncorrectVersionException(getServiceLayoutVersion(), lv,
    "storage directory " + sd.root.getAbsolutePath());
 }
 layoutVersion = lv;
}

/** Validate and set layout version from {@link Properties}*/
protected void setLayoutVersion(Properties props, StorageDirectory sd)
  throws IncorrectVersionException, InconsistentFSStateException {
 int lv = Integer.parseInt(getProperty(props, sd, "layoutVersion"));
 if (lv < getServiceLayoutVersion()) { // future version
  throw new IncorrectVersionException(getServiceLayoutVersion(), lv,
    "storage directory " + sd.root.getAbsolutePath());
 }
 layoutVersion = lv;
}

                     "is incompatible with others.");
if (rv < FSConstants.LAYOUT_VERSION) // future version
 throw new IncorrectVersionException(rv, "storage directory " 
                   + sd.root.getCanonicalPath());
layoutVersion = rv;

                     " but rt is " + rt);
if (rv < FSConstants.LAYOUT_VERSION) // future version
 throw new IncorrectVersionException(rv, "storage directory " 
                   + sd.root.getCanonicalPath());
layoutVersion = rv;

void readProperties(StorageDirectory sd, StartupOption startupOption)
  throws IOException {
 Properties props = readPropertiesFile(sd.getVersionFile());
 if (HdfsServerConstants.RollingUpgradeStartupOption.ROLLBACK.matches
   (startupOption)) {
  int lv = Integer.parseInt(getProperty(props, sd, "layoutVersion"));
  if (lv > getServiceLayoutVersion()) {
   // we should not use a newer version for rollingUpgrade rollback
   throw new IncorrectVersionException(getServiceLayoutVersion(), lv,
     "storage directory " + sd.getRoot().getAbsolutePath());
  }
  props.setProperty("layoutVersion",
    Integer.toString(HdfsConstants.NAMENODE_LAYOUT_VERSION));
 }
 setFieldsFromProperties(props, sd);
}

void readProperties(StorageDirectory sd, StartupOption startupOption)
  throws IOException {
 Properties props = readPropertiesFile(sd.getVersionFile());
 if (HdfsServerConstants.RollingUpgradeStartupOption.ROLLBACK.matches
   (startupOption)) {
  int lv = Integer.parseInt(getProperty(props, sd, "layoutVersion"));
  if (lv > getServiceLayoutVersion()) {
   // we should not use a newer version for rollingUpgrade rollback
   throw new IncorrectVersionException(getServiceLayoutVersion(), lv,
     "storage directory " + sd.getRoot().getAbsolutePath());
  }
  props.setProperty("layoutVersion",
    Integer.toString(HdfsConstants.NAMENODE_LAYOUT_VERSION));
 }
 setFieldsFromProperties(props, sd);
}

Javadoc

The exception is thrown when external version does not match current version of the appication.

Most used methods

Popular in Java

Updating database using SQL prepared statement
getApplicationContext (Context)
getSharedPreferences (Context)
getSystemService (Context)
Charset (java.nio.charset)
A charset is a named mapping between Unicode characters and byte sequences. Every Charset can decode
Calendar (java.util)
Calendar is an abstract base class for converting between a Date object and a set of integer fields
TreeMap (java.util)
Walk the nodes of the tree left-to-right or right-to-left. Note that in descending iterations, next
ExecutorService (java.util.concurrent)
An Executor that provides methods to manage termination and methods that can produce a Future for tr
JFrame (javax.swing)
IsNull (org.hamcrest.core)
Is the value null?
Github Copilot alternatives

How to useIncorrectVersionException in org.apache.hadoop.hdfs.server.common

Best Java code snippets using org.apache.hadoop.hdfs.server.common.IncorrectVersionException (Showing top 20 results out of 315)

How to use
IncorrectVersionException
in
org.apache.hadoop.hdfs.server.common