/** Returns the cache entry with the specified key if it exists, null otherwise. */
  @Override
  public synchronized Entry get(String key) {
    CacheHeader entry = mEntries.get(key); // 获取摘要
    // if the entry does not exist, return.
    if (entry == null) {
      return null;
    }

    File file = getFileForKey(key); // 获取文件
    CountingInputStream cis = null;
    try {
      cis = new CountingInputStream(new FileInputStream(file));
      CacheHeader.readHeader(cis); // eat header文件的具体内容在摘要之后,所有先读取摘要,将当前读取位置移动到摘要之后
      byte[] data = streamToBytes(cis, (int) (file.length() - cis.bytesRead)); // 当前位置移动到摘要之后,读取缓存内容
      return entry.toCacheEntry(data); // 根据读取的缓存内容,结合缓存摘要,生成Cache.Entry对象
    } catch (IOException e) {
      VolleyLog.d("%s: %s", file.getAbsolutePath(), e.toString());
      remove(key); // 发生异常则删除异常缓存
      return null;
    } finally {
      if (cis != null) {
        try {
          cis.close();
        } catch (IOException ioe) {
          return null;
        }
      }
    }
  }
Beispiel #2
0
  /** Returns the cache entry with the specified key if it exists, null otherwise. */
  @Override
  public synchronized Entry get(String key) {
    CacheHeader entry = mEntries.get(key);
    // if the entry does not exist, return.
    if (entry == null) {
      return null;
    }

    File file = getFileForKey(key);
    CountingInputStream cis = null;
    try {
      cis = new CountingInputStream(new BufferedInputStream(new FileInputStream(file)));
      CacheHeader.readHeader(cis); // eat header
      byte[] data = streamToBytes(cis, (int) (file.length() - cis.bytesRead));
      return entry.toCacheEntry(data);
    } catch (IOException e) {
      VolleyLog.d("%s: %s", file.getAbsolutePath(), e.toString());
      remove(key);
      return null;
    } finally {
      if (cis != null) {
        try {
          cis.close();
        } catch (IOException ioe) {
          return null;
        }
      }
    }
  }
 /** Test that constructor offsets work */
 @Test
 public void testConstructor() throws Exception {
   CountingInputStream cis;
   cis = new CountingInputStream(NULL_INPUTSTREAM, 5l);
   assertEquals(5l, cis.getPos());
   cis.close();
   cis = new CountingInputStream(NULL_INPUTSTREAM, 500000000000l);
   assertEquals(500000000000l, cis.getPos());
   cis.close();
 }
Beispiel #4
0
  public static void compareMapFiles(MapLoader expectedSavegame, MapLoader actualSavegame)
      throws IOException, MapLoadException, ClassNotFoundException {
    System.out.println(
        "Comparing expected '"
            + expectedSavegame
            + "' with actual '"
            + actualSavegame
            + "' (uncompressed!)");

    try (InputStream expectedStream =
            RemakeMapLoader.getMapInputStream(expectedSavegame.getListedMap());
        CountingInputStream actualStream =
            new CountingInputStream(
                RemakeMapLoader.getMapInputStream(actualSavegame.getListedMap()))) {
      MapFileHeader expectedHeader = MapFileHeader.readFromStream(expectedStream);
      MatchConstants.init(new NetworkTimer(true), 0L);
      MatchConstants.deserialize(new ObjectInputStream(expectedStream));
      int expectedTime = MatchConstants.clock().getTime();
      ExtendedRandom expectedRandom = MatchConstants.random();
      MatchConstants.clearState();

      MapFileHeader actualHeader = MapFileHeader.readFromStream(actualStream);
      MatchConstants.init(new NetworkTimer(true), 1L);
      MatchConstants.deserialize(new ObjectInputStream(actualStream));
      int actualTime = MatchConstants.clock().getTime();
      ExtendedRandom actualRandom = MatchConstants.random();
      MatchConstants.clearState();

      assertEquals(expectedHeader.getBaseMapId(), actualHeader.getBaseMapId());
      assertEquals(expectedTime, actualTime);
      // Test the random behavior a bit to have a high probability of equality. An equals method
      // does not exist for Random.
      assertEquals(expectedRandom.nextInt(), actualRandom.nextInt());
      assertEquals(expectedRandom.nextInt(), actualRandom.nextInt());
      assertEquals(expectedRandom.nextInt(), actualRandom.nextInt());

      int e, a;
      while (((e = expectedStream.read()) != -1) & ((a = actualStream.read()) != -1)) {
        assertEquals("difference at (uncompressed) byte " + actualStream.getByteCounter(), e, a);
      }
      assertEquals("files have different lengths (uncompressed)", e, a);
    }
  }
 /** Test that single byte reads have the desired effect on counting */
 @Test
 public void testSingleByteReads() throws Exception {
   ByteArrayInputStream bais = new ByteArrayInputStream(TEST_ARRAY);
   CountingInputStream cis = new CountingInputStream(bais);
   assertEquals((long) 0, cis.getPos());
   for (long i = 0; i < TEST_ARRAY.length; i++) {
     assertEquals(i, cis.getPos());
     int b = cis.read();
     assertEquals((byte) b, TEST_ARRAY[(int) i]);
     assertEquals(i + 1, cis.getPos());
   }
   assertEquals(TEST_ARRAY.length, cis.getPos());
   assertEquals(-1, cis.read());
   assertEquals(TEST_ARRAY.length, cis.getPos());
 }
 /** Test that two byte reads have the desired effect on counting */
 @Test
 public void testTwoByteReads() throws Exception {
   ByteArrayInputStream bais = new ByteArrayInputStream(TEST_ARRAY);
   CountingInputStream cis = new CountingInputStream(bais);
   assertEquals((long) 0, cis.getPos());
   for (long i = 0; i < TEST_ARRAY.length / 2; i++) {
     assertEquals(i * 2, cis.getPos());
     final byte[] read = new byte[2];
     final int rtr = cis.read(read);
     assertEquals(rtr, read.length);
     assertEquals(read[0], TEST_ARRAY[(int) i * 2]);
     assertEquals(read[1], TEST_ARRAY[(int) (i * 2) + 1]);
     assertEquals("offset after read i=" + i + "; ", (i * 2) + read.length, cis.getPos());
   }
   assertEquals(TEST_ARRAY.length, cis.getPos());
   assertEquals(-1, cis.read());
   assertEquals(TEST_ARRAY.length, cis.getPos());
 }
Beispiel #7
0
  private void validate() throws IOException {
    long compressedSize = inCounted.getSize();

    // Validate Compressed Size and Uncompressed Size if they were
    // present in Block Header.
    if ((compressedSizeInHeader != -1 && compressedSizeInHeader != compressedSize)
        || (uncompressedSizeInHeader != -1 && uncompressedSizeInHeader != uncompressedSize))
      throw new CorruptedInputException();

    // Block Padding bytes must be zeros.
    while ((compressedSize++ & 3) != 0)
      if (inData.readUnsignedByte() != 0x00) throw new CorruptedInputException();

    // Validate the integrity check.
    byte[] storedCheck = new byte[check.getSize()];
    inData.readFully(storedCheck);
    if (!Arrays.equals(check.finish(), storedCheck))
      throw new CorruptedInputException("Integrity check (" + check.getName() + ") does not match");
  }
Beispiel #8
0
  @Override
  public int read(byte[] buf, int off, int len) throws IOException {
    if (endReached) return -1;

    int ret = filterChain.read(buf, off, len);

    if (ret > 0) {
      check.update(buf, off, ret);
      uncompressedSize += ret;

      // Catch invalid values.
      long compressedSize = inCounted.getSize();
      if (compressedSize < 0
          || compressedSize > compressedSizeLimit
          || uncompressedSize < 0
          || (uncompressedSizeInHeader != -1 && uncompressedSize > uncompressedSizeInHeader))
        throw new CorruptedInputException();

      // Check the Block integrity as soon as possible:
      //   - The filter chain shouldn't return less than requested
      //     unless it hit the end of the input.
      //   - If the uncompressed size is known, we know when there
      //     shouldn't be more data coming. We still need to read
      //     one byte to let the filter chain catch errors and to
      //     let it read end of payload marker(s).
      if (ret < len || uncompressedSize == uncompressedSizeInHeader) {
        if (filterChain.read() != -1) throw new CorruptedInputException();

        validate();
        endReached = true;
      }
    } else if (ret == -1) {
      validate();
      endReached = true;
    }

    return ret;
  }
 public int getProgress() {
   return in.getByteCount();
 }
Beispiel #10
0
 public long getUnpaddedSize() {
   return headerSize + inCounted.getSize() + check.getSize();
 }