Java FSWriteError类代码示例

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
/**
 * Appends new component names to the TOC component.
 */
protected static void appendTOC(Descriptor descriptor, Collection<Component> components)
{
    String tocFile = descriptor.filenameFor(Component.TOC);

    try (BufferedWriter bufferedWriter = HadoopFileUtils.newBufferedWriter(descriptor.filenameFor(Component.TOC),
                                                                           Charsets.UTF_8,
                                                                           descriptor.getConfiguration()))
    {
        for (Component component : components)
            bufferedWriter.write(component.name + "\n");
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, tocFile);
    }
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
public void append(DecoratedKey key, RowIndexEntry indexEntry, long dataEnd, ByteBuffer indexInfo) throws IOException
{
    bf.add(key);
    long indexStart = indexFile.position();
    try
    {
        ByteBufferUtil.writeWithShortLength(key.getKey(), indexFile);
        rowIndexEntrySerializer.serialize(indexEntry, indexFile, indexInfo);
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, indexFile.getPath());
    }
    long indexEnd = indexFile.position();

    if (logger.isTraceEnabled())
        logger.trace("wrote index entry: {} at {}", indexEntry, indexStart);

    summary.maybeAddEntry(key, indexStart, indexEnd, dataEnd);
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
/**
 * Closes the index and bloomfilter, making the public state of this writer valid for consumption.
 */
void flushBf()
{
    if (components.contains(Component.FILTER))
    {
        String path = descriptor.filenameFor(Component.FILTER);

        try (HadoopFileUtils.HadoopFileChannel hos = HadoopFileUtils.newFilesystemChannel(path,
                                                                              descriptor.getConfiguration());
             DataOutputStreamPlus stream = new BufferedDataOutputStreamPlus(hos))
        {
            // bloom filter
            FilterFactory.serialize(bf, stream);
            stream.flush();
            //SyncUtil.sync(hos);
        }
        catch (IOException e)
        {
            logger.info(e.getMessage());
            throw new FSWriteError(e, path);
        }
    }
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
private void writeHeader(DataOutput out, long dataLength, int chunks)
{
    try
    {
        out.writeUTF(parameters.getSstableCompressor().getClass().getSimpleName());
        out.writeInt(parameters.getOtherOptions().size());
        for (Map.Entry<String, String> entry : parameters.getOtherOptions().entrySet())
        {
            out.writeUTF(entry.getKey());
            out.writeUTF(entry.getValue());
        }

        // store the length of the chunk
        out.writeInt(parameters.chunkLength());
        // store position and reserve a place for uncompressed data length and chunks count
        out.writeLong(dataLength);
        out.writeInt(chunks);
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, filePath);
    }
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
public static void createHardLink(File from, File to)
{
    if (to.exists())
        throw new RuntimeException("Tried to create duplicate hard link to " + to);
    if (!from.exists())
        throw new RuntimeException("Tried to hard link to file that does not exist " + from);

    try
    {
        Files.createLink(to.toPath(), from.toPath());
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, to);
    }
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
/**
 * Override this method instead of overriding flush()
 * @throws FSWriteError on any I/O error.
 */
protected void flushData()
{
    try
    {
        buffer.flip();
        channel.write(buffer);
        lastFlushOffset += buffer.position();
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, getPath());
    }
    if (runPostFlush != null)
        runPostFlush.run();
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
/**
 * Dump the inter arrival times for examination if necessary.
 */
public void dumpInterArrivalTimes()
{
    File file = FileUtils.createTempFile("failuredetector-", ".dat");

    OutputStream os = null;
    try
    {
        os = new BufferedOutputStream(new FileOutputStream(file, true));
        os.write(toString().getBytes());
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, file);
    }
    finally
    {
        FileUtils.closeQuietly(os);
    }
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
/**
 * Recycle processes an unneeded segment file for reuse.
 *
 * @return a new CommitLogSegment representing the newly reusable segment.
 */
CommitLogSegment recycle()
{
    try
    {
        sync();
    }
    catch (FSWriteError e)
    {
        logger.error("I/O error flushing {} {}", this, e.getMessage());
        throw e;
    }

    close();

    return new CommitLogSegment(getPath());
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
private void writeSnapshotManifest(final JSONArray filesJSONArr, final String snapshotName)
{
    final File manifestFile = directories.getSnapshotManifestFile(snapshotName);
    final JSONObject manifestJSON = new JSONObject();
    manifestJSON.put("files", filesJSONArr);

    try
    {
        if (!manifestFile.getParentFile().exists())
            manifestFile.getParentFile().mkdirs();
        PrintStream out = new PrintStream(manifestFile);
        out.println(manifestJSON.toJSONString());
        out.close();
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, manifestFile);
    }
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
/**
 * @param row
 * @return null if the row was compacted away entirely; otherwise, the PK index entry for this row
 */
public RowIndexEntry append(AbstractCompactedRow row)
{
    long startPosition = beforeAppend(row.key);
    RowIndexEntry entry;
    try
    {
        entry = row.write(startPosition, dataFile.stream);
        if (entry == null)
            return null;
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, dataFile.getPath());
    }
    long endPosition = dataFile.getFilePointer();
    sstableMetadataCollector.update(endPosition - startPosition, row.columnStats());
    afterAppend(row.key, endPosition, entry);
    return entry;
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
private static void writeMetadata(Descriptor desc, Map<MetadataType, MetadataComponent> components)
{
    SequentialWriter out = SequentialWriter.open(new File(desc.filenameFor(Component.STATS)));
    try
    {
        desc.getMetadataSerializer().serialize(components, out.stream);
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, out.getPath());
    }
    finally
    {
        out.close();
    }
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
/**
 * Appends new component names to the TOC component.
 */
protected static void appendTOC(Descriptor descriptor, Collection<Component> components)
{
    File tocFile = new File(descriptor.filenameFor(Component.TOC));
    PrintWriter w = null;
    try
    {
        w = new PrintWriter(new FileWriter(tocFile, true));
        for (Component component : components)
            w.println(component.name);
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, tocFile);
    }
    finally
    {
        FileUtils.closeQuietly(w);
    }
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
private void writeHeader(DataOutput out, long dataLength, int chunks)
{
    try
    {
        out.writeUTF(parameters.sstableCompressor.getClass().getSimpleName());
        out.writeInt(parameters.otherOptions.size());
        for (Map.Entry<String, String> entry : parameters.otherOptions.entrySet())
        {
            out.writeUTF(entry.getKey());
            out.writeUTF(entry.getValue());
        }

        // store the length of the chunk
        out.writeInt(parameters.chunkLength());
        // store position and reserve a place for uncompressed data length and chunks count
        out.writeLong(dataLength);
        out.writeInt(chunks);
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, filePath);
    }
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
@Override
public void close()
{
    if (buffer == null)
        return; // already closed

    super.close();
    sstableMetadataCollector.addCompressionRatio(compressedSize, originalSize);
    try
    {
        metadataWriter.close(current, chunkCount);
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, getPath());
    }
}
 

import org.apache.cassandra.io.FSWriteError; //导入依赖的package包/类
public void writeFullChecksum(Descriptor descriptor)
{
    File outFile = new File(descriptor.filenameFor(Component.DIGEST));
    BufferedWriter out = null;
    try
    {
        out = Files.newBufferedWriter(outFile.toPath(), Charsets.UTF_8);
        out.write(String.valueOf(fullChecksum.getValue()));
    }
    catch (IOException e)
    {
        throw new FSWriteError(e, outFile);
    }
    finally
    {
        FileUtils.closeQuietly(out);
    }
}