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

Running tasks concurrently on multiple threads
getExternalFilesDir (Context)
startActivity (Activity)
scheduleAtFixedRate (ScheduledExecutorService)
BufferedImage (java.awt.image)
The BufferedImage subclass describes an java.awt.Image with an accessible buffer of image data. All
MalformedURLException (java.net)
This exception is thrown when a program attempts to create an URL from an incorrect specification.
URI (java.net)
A Uniform Resource Identifier that identifies an abstract or physical resource, as specified by RFC
Collections (java.util)
This class consists exclusively of static methods that operate on or return collections. It contains
ExecutorService (java.util.concurrent)
An Executor that provides methods to manage termination and methods that can produce a Future for tr
Scheduler (org.quartz)
This is the main interface of a Quartz Scheduler. A Scheduler maintains a registry of org.quartz.Job
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