예제 #1
0
  public static long checksumRandomAccessFile(Path filename) throws IOException {
    try (RandomAccessFile file = new RandomAccessFile(filename.toFile(), "r")) {
      long length = file.length();
      CRC32 crc = new CRC32();

      for (long p = 0; p < length; p++) {
        file.seek(p);
        int c = file.readByte();
        crc.update(c);
      }
      return crc.getValue();
    }
  }
예제 #2
0
  public RegionFile(File path) {
    offsets = new int[SECTOR_INTS];
    chunkTimestamps = new int[SECTOR_INTS];

    fileName = path;
    debugln("REGION LOAD " + fileName);

    sizeDelta = 0;

    try {
      if (path.exists()) {
        lastModified = path.lastModified();
      }

      file = new RandomAccessFile(path, "rw");

      if (file.length() < SECTOR_BYTES) {
        /* we need to write the chunk offset table */
        for (int i = 0; i < SECTOR_INTS; ++i) {
          file.writeInt(0);
        }
        // write another sector for the timestamp info
        for (int i = 0; i < SECTOR_INTS; ++i) {
          file.writeInt(0);
        }

        sizeDelta += SECTOR_BYTES * 2;
      }

      if ((file.length() & 0xfff) != 0) {
        /* the file size is not a multiple of 4KB, grow it */
        for (int i = 0; i < (file.length() & 0xfff); ++i) {
          file.write((byte) 0);
        }
      }

      /* set up the available sector map */
      int nSectors = (int) file.length() / SECTOR_BYTES;
      sectorFree = new ArrayList<Boolean>(nSectors);

      for (int i = 0; i < nSectors; ++i) {
        sectorFree.add(true);
      }

      sectorFree.set(0, false); // chunk offset table
      sectorFree.set(1, false); // for the last modified info

      file.seek(0);
      for (int i = 0; i < SECTOR_INTS; ++i) {
        int offset = file.readInt();
        offsets[i] = offset;
        if (offset != 0 && (offset >> 8) + (offset & 0xFF) <= sectorFree.size()) {
          for (int sectorNum = 0; sectorNum < (offset & 0xFF); ++sectorNum) {
            sectorFree.set((offset >> 8) + sectorNum, false);
          }
        }
      }
      for (int i = 0; i < SECTOR_INTS; ++i) {
        int lastModValue = file.readInt();
        chunkTimestamps[i] = lastModValue;
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
예제 #3
0
  /* write a chunk at (x,z) with length bytes of data to disk */
  protected synchronized void write(int x, int z, byte[] data, int length) {
    try {
      int offset = getOffset(x, z);
      int sectorNumber = offset >> 8;
      int sectorsAllocated = offset & 0xFF;
      int sectorsNeeded = (length + CHUNK_HEADER_SIZE) / SECTOR_BYTES + 1;

      // maximum chunk size is 1MB
      if (sectorsNeeded >= 256) {
        return;
      }

      if (sectorNumber != 0 && sectorsAllocated == sectorsNeeded) {
        /* we can simply overwrite the old sectors */
        debug("SAVE", x, z, length, "rewrite");
        write(sectorNumber, data, length);
      } else {
        /* we need to allocate new sectors */

        /* mark the sectors previously used for this chunk as free */
        for (int i = 0; i < sectorsAllocated; ++i) {
          sectorFree.set(sectorNumber + i, true);
        }

        /* scan for a free space large enough to store this chunk */
        int runStart = sectorFree.indexOf(true);
        int runLength = 0;
        if (runStart != -1) {
          for (int i = runStart; i < sectorFree.size(); ++i) {
            if (runLength != 0) {
              if (sectorFree.get(i)) runLength++;
              else runLength = 0;
            } else if (sectorFree.get(i)) {
              runStart = i;
              runLength = 1;
            }
            if (runLength >= sectorsNeeded) {
              break;
            }
          }
        }

        if (runLength >= sectorsNeeded) {
          /* we found a free space large enough */
          debug("SAVE", x, z, length, "reuse");
          sectorNumber = runStart;
          setOffset(x, z, (sectorNumber << 8) | sectorsNeeded);
          for (int i = 0; i < sectorsNeeded; ++i) {
            sectorFree.set(sectorNumber + i, false);
          }
          write(sectorNumber, data, length);
        } else {
          /*
           * no free space large enough found -- we need to grow the
           * file
           */
          debug("SAVE", x, z, length, "grow");
          file.seek(file.length());
          sectorNumber = sectorFree.size();
          for (int i = 0; i < sectorsNeeded; ++i) {
            file.write(emptySector);
            sectorFree.add(false);
          }
          sizeDelta += SECTOR_BYTES * sectorsNeeded;

          write(sectorNumber, data, length);
          setOffset(x, z, (sectorNumber << 8) | sectorsNeeded);
        }
      }
      setTimestamp(x, z, (int) (System.currentTimeMillis() / 1000L));
    } catch (IOException e) {
      e.printStackTrace();
    }
  }