Java Code Examples for java.io.RandomAccessFile#readInt()

public boolean isConversionNeeded(StorageDirectory sd) throws IOException {
  File oldImageDir = new File(sd.getRoot(), "image");
  if (!oldImageDir.exists()) {
    if(sd.getVersionFile().exists())
      throw new InconsistentFSStateException(sd.getRoot(),
          oldImageDir + " does not exist.");
    return false;
  }
  // check the layout version inside the image file
  File oldF = new File(oldImageDir, "fsimage");
  RandomAccessFile oldFile = new RandomAccessFile(oldF, "rws");
  try {
    oldFile.seek(0);
    int odlVersion = oldFile.readInt();
    if (odlVersion < LAST_PRE_UPGRADE_LAYOUT_VERSION)
      return false;
  } finally {
    oldFile.close();
  }
  return true;
}
 

/**
 * Checks that a file has a valid deltas header, adding the header if the
 * file is shorter than the header.
 */
private static void setOrCheckFileHeader(RandomAccessFile file) throws IOException {
  Preconditions.checkNotNull(file);
  file.seek(0);

  if (file.length() < FILE_HEADER_LENGTH) {
    // The file is new. Insert a header.
    file.write(FILE_MAGIC_BYTES);
    file.writeInt(FILE_PROTOCOL_VERSION);
  } else {
    byte[] magic = new byte[4];
    file.readFully(magic);
    if (!Arrays.equals(FILE_MAGIC_BYTES, magic)) {
      throw new IOException("Delta file magic bytes are incorrect");
    }

    int version = file.readInt();
    if (version != FILE_PROTOCOL_VERSION) {
      throw new IOException(String.format("File protocol version mismatch - expected %d got %d",
          FILE_PROTOCOL_VERSION, version));
    }
  }
}
 

/**
 * Reads the given file with specific pattern(|crc|timestamp|sizeOfKey|SizeOfValue|key|value|) then
 * returns an instance of {@link FileEntry}.
 */
private static FileEntry readInternal(RandomAccessFile file, long valuePosition, int valueLength) throws IOException {
  file.seek(valuePosition);
  long crc = file.readLong();
  long timestamp = file.readLong();
  int keySize = file.readInt();
  int valueSize = file.readInt();
  byte[] key = new byte[keySize];
  file.readFully(key, 0, keySize);
  byte[] value = new byte[valueSize];
  if (valueSize != valueLength) {
    throw new HoodieCorruptedDataException("unequal size of payload written to external file, data may be corrupted");
  }
  file.readFully(value, 0, valueSize);
  long crcOfReadValue = generateChecksum(value);
  if (crc != crcOfReadValue) {
    throw new HoodieCorruptedDataException(
        "checksum of payload written to external disk does not match, data may be corrupted");
  }
  return new FileEntry(crc, keySize, valueSize, key, value, timestamp);
}
 

@Override
public boolean isPreUpgradableLayout(StorageDirectory sd) throws IOException {
  File oldF = new File(sd.getRoot(), "storage");
  if (!oldF.exists())
    return false;
  // check the layout version inside the storage file
  // Lock and Read old storage file
  RandomAccessFile oldFile = new RandomAccessFile(oldF, "rws");
  FileLock oldLock = oldFile.getChannel().tryLock();
  try {
    oldFile.seek(0);
    int oldVersion = oldFile.readInt();
    if (oldVersion < LAST_PRE_UPGRADE_LAYOUT_VERSION)
      return false;
  } finally {
    oldLock.release();
    oldFile.close();
  }
  return true;
}
 

@Override
protected void loadLocationTable() throws IOException {
    RandomAccessFile raf = this.getRandomAccessFile();
    raf.seek(0);
    this.lastSector = 1;
    int[] data = new int[1024 * 2]; //1024 records * 2 times
    for (int i = 0; i < 1024 * 2; i++) {
        data[i] = raf.readInt();
    }
    for (int i = 0; i < 1024; ++i) {
        int index = data[i];
        this.locationTable.put(i, new Integer[]{index >> 8, index & 0xff, data[1024 + i]});
        int value = this.locationTable.get(i)[0] + this.locationTable.get(i)[1] - 1;
        if (value > this.lastSector) {
            this.lastSector = value;
        }
    }
}
 

public void read(final RandomAccessFile file) throws IOException, InvalidTagException {
    final int size = readHeader(file);
    if (size == 0) {
        throw new InvalidTagException("Empty Frame");
    }
    dataStart = file.readInt();
    dataLength = file.readInt();
    indexPoints = (int) file.readShort();
    bitsPerPoint = (int) file.readByte();
    fraction = new short[indexPoints];
    for (int i = 0; i < indexPoints; i++) {
        if (bitsPerPoint == 8) {
            fraction[i] = (short) file.readByte();
        } else if (bitsPerPoint == 16) {
            fraction[i] = file.readShort();
        } else {
            throw new InvalidTagException("ASPI bits per point wasn't 8 or 16");
        }
    }
}
 

private void pageIn() {
    if (!pagedIn) {
        RandomAccessFile file = spillFile.getPage(pageIndex);
        try {
        int numElements = file.readInt();
        for (int i = 0; i < numElements; i++) {
            int kvSize = file.readInt();
            byte[] data = new byte[kvSize];
            file.readFully(data);
            pageMap.put(SpillManager.getKey(data), data);
            totalResultSize += (data.length + Bytes.SIZEOF_INT);
        }
        } catch (IOException ioe) {
            // Error during key access on spilled resource
            // TODO rework error handling
            throw new RuntimeException(ioe);
        }
        pagedIn = true;
        dirtyPage = false;
    }
}
 

@Override
protected void loadLocationTable() throws IOException {
    RandomAccessFile raf = this.getRandomAccessFile();
    raf.seek(0);
    this.lastSector = 1;
    int[] data = new int[1024 * 2]; //1024 records * 2 times
    for (int i = 0; i < 1024 * 2; i++) {
        data[i] = raf.readInt();
    }
    for (int i = 0; i < 1024; ++i) {
        int index = data[i];
        this.locationTable.put(i, new Integer[]{index >> 8, index & 0xff, data[1024 + i]});
        int value = this.locationTable.get(i)[0] + this.locationTable.get(i)[1] - 1;
        if (value > this.lastSector) {
            this.lastSector = value;
        }
    }
}
 

/**
 * Returns {@code true} if the provided file contains a ZIP64 End of Central Directory
 * Locator.
 *
 * @param zipEndOfCentralDirectoryPosition offset of the ZIP End of Central Directory record
 *        in the file.
 *
 * @throws IOException if an I/O error occurs while reading the file.
 */
public static final boolean isZip64EndOfCentralDirectoryLocatorPresent(
        RandomAccessFile zip, long zipEndOfCentralDirectoryPosition) throws IOException {

    // ZIP64 End of Central Directory Locator immediately precedes the ZIP End of Central
    // Directory Record.
    long locatorPosition = zipEndOfCentralDirectoryPosition - ZIP64_EOCD_LOCATOR_SIZE;
    if (locatorPosition < 0) {
        return false;
    }

    zip.seek(locatorPosition);
    // RandomAccessFile.readInt assumes big-endian byte order, but ZIP format uses
    // little-endian.
    return zip.readInt() == ZIP64_EOCD_LOCATOR_SIG_REVERSE_BYTE_ORDER;
}
 

@Override // Storage
public boolean isPreUpgradableLayout(StorageDirectory sd) throws IOException {
  if (disablePreUpgradableLayoutCheck) {
    return false;
  }

  File oldImageDir = new File(sd.getRoot(), "image");
  if (!oldImageDir.exists()) {
    return false;
  }
  // check the layout version inside the image file
  File oldF = new File(oldImageDir, "fsimage");
  RandomAccessFile oldFile = new RandomAccessFile(oldF, "rws");
  try {
    oldFile.seek(0);
    int oldVersion = oldFile.readInt();
    oldFile.close();
    oldFile = null;
    if (oldVersion < LAST_PRE_UPGRADE_LAYOUT_VERSION)
      return false;
  } finally {
    IOUtils.cleanup(LOG, oldFile);
  }
  return true;
}
 

public static void main(String[] args)  throws IOException {
	RandomAccessFile f = new RandomAccessFile("/tmp/junk.data", "rw");
	f.writeInt(34);
	f.writeDouble(3.14159);
	f.seek(0);  // rewind and read again
	int i = f.readInt();
	double d = f.readDouble();
	f.close();
	System.out.printf("read %d and %1.5f\n", i, d);
}
 

/**
 * read
 *
 * @param ins
 * @throws IOException
 */
public void read(RandomAccessFile ins) throws IOException {
    int length = ins.readInt();
    if (length == 0)
        proteinId = null;
    else {
        proteinId = new byte[length];
        if (ins.read(proteinId, 0, length) != length)
            throw new IOException("read failed");
    }
    for (int i = 0; i < creator.numberOfClassifications(); i++) {
        ids[i] = ins.readInt();
    }
    reverse = (ins.read() == 1);
}
 

static private int updateElement(RandomAccessFile raf, ArrayList counts, int index)
        throws IOException {
  skipString(raf);
  int skipCount = raf.readInt();
  // Debug.p("Skip count: " + skipCount);
  for (int i = 0; i < skipCount; i++) {
    skipString(raf);
    skipString(raf);
  }
  int childCount = ((StackEntry) counts.get(index)).childCount;
  index++;
  raf.writeInt(childCount);
  // Debug.p("Wrote: " + childCount);
  for (int i = 0; i < childCount; i++) {
    int marker = raf.read();
    switch ((byte) marker) {
      case XTalkTransporter.ELEMENT_MARKER:
        index = updateElement(raf, counts, index);
        break;
      case XTalkTransporter.STRING_MARKER:
        skipString(raf);
        break;
      default:
        throw new IOException("Unexepcted marker: " + marker);
    }
  }
  return index;
}
 

/**
 * Read sub header
 *
 * @param br The randomAccessFile
 * @param isSequential If if sequential
 * @return The sub header
 * @throws IOException
 */
public SubHeader readSubHeader(RandomAccessFile br, boolean isSequential) throws IOException {
    SubHeader sh = new SubHeader();
    byte[] bytes = new byte[4];
    int i;
    if (isSequential) {
        br.skipBytes(4);
    }

    sh.ndim = br.readInt();
    for (i = 0; i < 4; i++) {
        sh.start_index[i] = br.readInt();
    }
    for (i = 0; i < 4; i++) {
        sh.end_index[i] = br.readInt();
    }
    sh.xtime = br.readFloat();
    br.read(bytes);
    sh.staggering = new String(bytes).trim();
    br.read(bytes);
    sh.ordering = new String(bytes).trim();
    bytes = new byte[24];
    br.read(bytes);
    sh.current_date = new String(bytes).trim();
    bytes = new byte[9];
    br.read(bytes);
    sh.name = new String(bytes).trim();
    bytes = new byte[25];
    br.read(bytes);
    sh.unit = new String(bytes).trim();
    bytes = new byte[46];
    br.read(bytes);
    sh.description = new String(bytes).trim();

    if (isSequential) {
        br.skipBytes(4);
    }

    return sh;
}
 

static CentralDirectory findCentralDirectory(RandomAccessFile raf) throws IOException,
        ZipException {
    long scanOffset = raf.length() - ENDHDR;
    if (scanOffset < 0) {
        throw new ZipException("File too short to be a zip file: " + raf.length());
    }

    long stopOffset = scanOffset - 0x10000 /* ".ZIP file comment"'s max length */;
    if (stopOffset < 0) {
        stopOffset = 0;
    }

    int endSig = Integer.reverseBytes(ENDSIG);
    while (true) {
        raf.seek(scanOffset);
        if (raf.readInt() == endSig) {
            break;
        }

        scanOffset--;
        if (scanOffset < stopOffset) {
            throw new ZipException("End Of Central Directory signature not found");
        }
    }
    // Read the End Of Central Directory. ENDHDR includes the signature
    // bytes,
    // which we've already read.

    // Pull out the information we need.
    raf.skipBytes(2); // diskNumber
    raf.skipBytes(2); // diskWithCentralDir
    raf.skipBytes(2); // numEntries
    raf.skipBytes(2); // totalNumEntries
    CentralDirectory dir = new CentralDirectory();
    dir.size = Integer.reverseBytes(raf.readInt()) & 0xFFFFFFFFL;
    dir.offset = Integer.reverseBytes(raf.readInt()) & 0xFFFFFFFFL;
    return dir;
}
 

private void readHeader() throws IOException {
	final RandomAccessFile baseFile = mFiles.get(0);

	// Get file sizes
	for (final RandomAccessFile file : mFiles) {
		mFileSizes.add(file.length());
	}

	// Version
	final int version = baseFile.readInt();
	if (version != VERSION) {
		throw new IOException("Bad file version: " + version);
	}

	// Tile Size
	final int tile_size = baseFile.readInt();
	if (tile_size != TILE_SIZE) {
		throw new IOException("Bad tile size: " + tile_size);
	}

	// Read Source List
	final int sourceCount = baseFile.readInt();

	for (int i=0;i<sourceCount;i++) {
		final int sourceIndex = baseFile.readInt();
		final int sourceNameLength = baseFile.readInt();
		final byte[] nameData = new byte[sourceNameLength];
		baseFile.read(nameData, 0, sourceNameLength);

		final String sourceName = new String(nameData);
		mSources.put(new Integer(sourceIndex), sourceName);
	}

	// Read Ranges
	final int num_ranges = baseFile.readInt();
	for (int i=0;i<num_ranges;i++) {
		final GEMFRange rs = new GEMFRange();
		rs.zoom = baseFile.readInt();
		rs.xMin = baseFile.readInt();
		rs.xMax = baseFile.readInt();
		rs.yMin = baseFile.readInt();
		rs.yMax = baseFile.readInt();
		rs.sourceIndex = baseFile.readInt();
		rs.offset = baseFile.readLong();
		mRangeData.add(rs);
	}
}
 

/**
    * <strong>CAUTION: This constructor should not be used in circumstances in
    * which the {@link HALogWriter} is active since this constructor can not
    * differentiate atomically between the live HALog and a historical HALog
    * and will always provide a read-only view, even if the live HALog file is
    * opened.</strong>
    * 
    * @param file
    *            The HALog file.
    *            
    * @throws IOException
    */
public HALogReader(final File file) throws IOException {

	m_file = file;

	m_raf = new RandomAccessFile(file, "r");

	m_channel = m_raf.getChannel();

	try {
		/**
		 * Must determine whether the file has consistent open and committed
		 * rootBlocks, using the commitCounter to determine which rootBlock
		 * is which.
		 * 
		 * Note: Both root block should exist (they are both written on
		 * startup). If they are identical, then the log is empty (the
		 * closing root block has not been written and the data in the log
		 * is useless).
		 * 
		 * We figure out which root block is the opening root block based on
		 * standard logic.
		 */
		/*
		 * Read the MAGIC and VERSION.
		 */
		m_raf.seek(0L);
		try {
			/*
			 * Note: this next line will throw IOException if there is a
			 * file lock contention.
			 */
			magic = m_raf.readInt();
		} catch (IOException ex) {
               throw new RuntimeException(
                       "Can not read magic. Is file locked by another process? file="
                               + file, ex);
		}
           if (magic != HALogWriter.MAGIC)
               throw new RuntimeException("Bad HALog magic: file=" + file
                       + ", expected=" + HALogWriter.MAGIC + ", actual="
                       + magic);
		version = m_raf.readInt();
		if (version != HALogWriter.VERSION1)
               throw new RuntimeException("Bad HALog version: file=" + file
                       + ", expected=" + HALogWriter.VERSION1 + ", actual="
                       + version);

		final RootBlockUtility tmp = new RootBlockUtility(reopener, file,
				true/* validateChecksum */, false/* alternateRootBlock */,
				false/* ignoreBadRootBlock */);

		m_closeRootBlock = tmp.chooseRootBlock();

		m_openRootBlock = tmp.rootBlock0 == m_closeRootBlock ? tmp.rootBlock1
				: tmp.rootBlock0;

		final long cc0 = m_openRootBlock.getCommitCounter();

		final long cc1 = m_closeRootBlock.getCommitCounter();

		if ((cc0 + 1) != cc1 && (cc0 != cc1)) {
			/*
			 * Counters are inconsistent with either an empty log file or a
			 * single transaction scope.
			 */
               throw new IllegalStateException(
                       "Incompatible rootblocks: file=" + file + ", cc0="
                               + cc0 + ", cc1=" + cc1);
		}

		m_channel.position(HALogWriter.headerSize0);

		m_storeType = m_openRootBlock.getStoreType();

	} catch (Throwable t) {

		close();

		throw new RuntimeException(t);

	}

}
 

protected static void skipRecord(RandomAccessFile fileHandle,
  int offset) throws IOException {
  fileHandle.seek(offset);
  int length = fileHandle.readInt();
  fileHandle.skipBytes(length);
}
 

@Test
public void testEditChecksum() throws Exception {
  // start a cluster 
  Configuration conf = new HdfsConfiguration();
  MiniDFSCluster cluster = null;
  FileSystem fileSys = null;
  cluster = new MiniDFSCluster.Builder(conf).numDataNodes(NUM_DATA_NODES).build();
  cluster.waitActive();
  fileSys = cluster.getFileSystem();
  final FSNamesystem namesystem = cluster.getNamesystem();

  FSImage fsimage = namesystem.getFSImage();
  final FSEditLog editLog = fsimage.getEditLog();
  fileSys.mkdirs(new Path("/tmp"));

  Iterator<StorageDirectory> iter = fsimage.getStorage().
    dirIterator(NameNodeDirType.EDITS);
  LinkedList<StorageDirectory> sds = new LinkedList<StorageDirectory>();
  while (iter.hasNext()) {
    sds.add(iter.next());
  }
  editLog.close();
  cluster.shutdown();

  for (StorageDirectory sd : sds) {
    File editFile = NNStorage.getFinalizedEditsFile(sd, 1, 3);
    assertTrue(editFile.exists());

    long fileLen = editFile.length();
    LOG.debug("Corrupting Log File: " + editFile + " len: " + fileLen);
    RandomAccessFile rwf = new RandomAccessFile(editFile, "rw");
    rwf.seek(fileLen-4); // seek to checksum bytes
    int b = rwf.readInt();
    rwf.seek(fileLen-4);
    rwf.writeInt(b+1);
    rwf.close();
  }
  
  try {
    cluster = new MiniDFSCluster.Builder(conf).numDataNodes(NUM_DATA_NODES).format(false).build();
    fail("should not be able to start");
  } catch (IOException e) {
    // expected
    assertNotNull("Cause of exception should be ChecksumException", e.getCause());
    assertEquals("Cause of exception should be ChecksumException",
        ChecksumException.class, e.getCause().getClass());
  }
}
 

/**
 * Reads a MIDI track without doing anything to the data
 */
private void skipATrack( RandomAccessFile dos) throws IOException{
               if(VERBOSE) System.out.println("Skipping the tempo track . . .");
	dos.readInt();
	dos.skipBytes(dos.readInt());
}