/**
* Creates and initializes an SPV block store. Will create the given file if it's missing. This
* operation will block on disk.
*/
public SPVBlockStore(NetworkParameters params, File file) throws BlockStoreException {
checkNotNull(file);
this.params = checkNotNull(params);
try {
this.numHeaders = DEFAULT_NUM_HEADERS;
boolean exists = file.exists();
// Set up the backing file.
randomAccessFile = new RandomAccessFile(file, "rw");
long fileSize = getFileSize();
if (!exists) {
log.info("Creating new SPV block chain file " + file);
randomAccessFile.setLength(fileSize);
} else if (randomAccessFile.length() != fileSize) {
throw new BlockStoreException(
"File size on disk does not match expected size: "
+ randomAccessFile.length()
+ " vs "
+ fileSize);
}
FileChannel channel = randomAccessFile.getChannel();
fileLock = channel.tryLock();
if (fileLock == null)
throw new BlockStoreException("Store file is already locked by another process");
// Map it into memory read/write. The kernel will take care of flushing writes to disk at the
// most
// efficient times, which may mean that until the map is deallocated the data on disk is
// randomly
// inconsistent. However the only process accessing it is us, via this mapping, so our own
// view will
// always be correct. Once we establish the mmap the underlying file and channel can go away.
// Note that
// the details of mmapping vary between platforms.
buffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, fileSize);
// Check or initialize the header bytes to ensure we don't try to open some random file.
byte[] header;
if (exists) {
header = new byte[4];
buffer.get(header);
if (!new String(header, "US-ASCII").equals(HEADER_MAGIC))
throw new BlockStoreException("Header bytes do not equal " + HEADER_MAGIC);
} else {
initNewStore(params);
}
} catch (Exception e) {
try {
if (randomAccessFile != null) randomAccessFile.close();
} catch (IOException e2) {
throw new BlockStoreException(e2);
}
throw new BlockStoreException(e);
}
}
/**
* reads the content of a group of existing files in a zipped block
*
* @param domain The namespace used to identify the application domain (1st level directory) to
* use
* @param paths The paths relative to the domain for the files to be read
* @param offset The offset in the file to start reading from
* @param len The length of the block in bytes in zipped form
* @return The contents of the file in zipped form together with the description of the files
*/
public MultiFileBlock readFromStreamZipped(String[] paths, long offset, int len) {
MultiFileBlock block = null;
try {
if (_isLocal) {
int startFileIndex =
Util.getStartFileIndex(
_rootFile.getCanonicalPath() + File.separatorChar, paths, offset);
long startFileOffset =
Util.getStartFileOffset(
_rootFile.getCanonicalPath() + File.separatorChar, paths, offset);
int i = startFileIndex;
long j = startFileOffset;
// int bufSize=0;
int totalBufSize = 0;
int readResult = 0;
ByteArrayOutputStream bOut = new ByteArrayOutputStream(len);
GZIPOutputStream zOut = new GZIPOutputStream(bOut, len);
block = new MultiFileBlock();
while (totalBufSize < len && i < paths.length) {
File tmpFile = new File(_rootFile.getCanonicalPath() + File.separatorChar + paths[i]);
if (tmpFile.isFile() && tmpFile.exists()) {
RandomAccessFile in = new RandomAccessFile(tmpFile, "r");
byte[] tmpBuf = new byte[len - totalBufSize];
in.seek(j);
while (totalBufSize < len && in.getFilePointer() < in.length()) {
readResult = in.read(tmpBuf);
if (readResult != -1) {
zOut.write(tmpBuf, 0, readResult);
// bufSize = bOut.size();
totalBufSize += readResult;
} else {
break;
}
}
BlockFileDescriptor des = new BlockFileDescriptor(_domain, paths[i], in.length());
block.addBlockFileDescriptor(des);
in.close();
i++;
j = 0;
} else {
return null;
}
}
zOut.close();
block.setBlockData(bOut.toByteArray());
} else {
block = _remote.readFromStreamZipped(_domain, paths, offset, len);
}
} catch (Exception ex) {
ex.printStackTrace();
}
return block;
}
/**
* Add the given text string to the end of a given file.
*
* @param inStr The string to be added.
* @param fileStr the name of the file to be added.
*/
public static void addStringToFile(String inStr, String fileStr) throws Exception {
RandomAccessFile raFile = new RandomAccessFile(fileStr, "rw");
raFile.seek(raFile.length());
raFile.writeBytes(inStr);
raFile.close();
}
public long length() {
try {
return image.length();
} catch (IOException e) {
return -1L;
}
}
/**
* reads the content of an existing file using the current domain
*
* @param domain The namespace used to identify the application domain (1st level directory) to
* use
* @param path The path relative to the domain for the file
* @param block The sequential block number for the data to be read starting with 1
* @param len The length of the block in bytes
* @return The contents of the file
*/
public byte[] readFromFile(String path, int block, int len) {
byte[] buffer = null;
try {
if (_isLocal) {
File tmpFile = new File(_rootFile.getCanonicalPath() + File.separatorChar + path);
if (tmpFile.isFile()) {
RandomAccessFile in = new RandomAccessFile(tmpFile, "r");
in.seek((block - 1) * len);
int result = -1;
buffer = new byte[len];
if (in.getFilePointer() < in.length()) {
result = in.read(buffer);
ByteArrayOutputStream out = new ByteArrayOutputStream(result);
out.write(buffer, 0, result);
in.close();
return out.toByteArray();
} else {
in.close();
}
}
} else {
buffer = _remote.readFromFile(_domain, path, block, len);
}
} catch (Exception ex) {
ex.printStackTrace();
}
return buffer;
}
// see DbFile.java for javadocs
public ArrayList<Page> insertTuple(TransactionId tid, Tuple t)
throws DbException, IOException, TransactionAbortedException {
// some code goes here
BufferPool bp = Database.getBufferPool();
int id = getId(), i, slots;
ArrayList<Page> retlist = new ArrayList<Page>();
PageId pid = null;
HeapPage p = null;
for (i = 0; i < numPages(); i++) {
pid = new HeapPageId(id, i);
p = (HeapPage) bp.getPage(tid, pid, Permissions.READ_WRITE);
slots = p.getNumEmptySlots();
if (slots > 0) {
p.insertTuple(t);
retlist.add(p);
return retlist;
}
}
// create new page and add tuple to it
pid = new HeapPageId(id, i);
raf.setLength(raf.length() + BufferPool.PAGE_SIZE);
p = (HeapPage) bp.getPage(tid, pid, Permissions.READ_WRITE);
p.insertTuple(t);
retlist.add(p);
return retlist;
}
/**
* Copy the given byte range of the given input to the given output.
*
* @param input The input to copy the given range to the given output for.
* @param output The output to copy the given range from the given input for.
* @param start Start of the byte range.
* @param length Length of the byte range.
* @throws IOException If something fails at I/O level.
*/
private static void copy(RandomAccessFile input, OutputStream output, long start, long length)
throws IOException {
byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
int read;
if (input.length() == length) {
// Write full range.
while ((read = input.read(buffer)) > 0) {
output.write(buffer, 0, read);
}
} else {
// Write partial range.
input.seek(start);
long toRead = length;
while ((read = input.read(buffer)) > 0) {
if ((toRead -= read) > 0) {
output.write(buffer, 0, read);
} else {
output.write(buffer, 0, (int) toRead + read);
break;
}
}
}
}
/**
* reads the content of an existing file using the current domain
*
* @param domain The namespace used to identify the application domain (1st level directory) to
* use
* @param path The path relative to the domain for the file
* @param offset the offset from the beginning of the file.
* @param len The length of the block in bytes
* @return The contents of the file
*/
public byte[] readByteFromFile(String path, long offset, int len)
throws EOFException, FileAccessException {
try {
if (_isLocal) {
File tmpFile = new File(_rootFile.getCanonicalPath() + File.separatorChar + path);
if (tmpFile.isFile()) {
RandomAccessFile raf = new RandomAccessFile(tmpFile, "r");
byte[] buffer = new byte[len];
raf.seek(offset);
int totalByteRead = 0;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int result = 0;
while (totalByteRead < len && raf.getFilePointer() < raf.length()) {
result = raf.read(buffer, 0, (len - totalByteRead));
if (result != -1) {
out.write(buffer, 0, result);
totalByteRead += result;
} else if (totalByteRead == 0) throw new EOFException("End of file reached!");
else break;
}
raf.close();
out.flush();
out.close();
return out.toByteArray();
} else throw new FileAccessException("Path is not a file");
} else return _remote.readByteFromFile(_domain, path, offset, len);
} catch (EOFException eofe) {
throw eofe;
} catch (FileAccessException fae) {
throw fae;
} catch (Exception e) {
throw new FileAccessException(e);
}
}
public double getProgress() {
try {
return 1.0 * filein.getFilePointer() / (1.0 * filein.length());
} catch (IOException e) {
return 1.0;
}
}
private void init(SharedFile sf, int size) throws IOException {
this.sf = sf;
this.in = sf.open();
this.start = 0;
this.datalen = in.length(); // XXX - file can't grow
this.bufsize = size;
buf = new byte[size];
}
private void append(SingleHit[] hits, String prefix, int chrom) throws IOException {
RandomAccessFile positionsRAF = new RandomAccessFile(getPositionsFname(prefix, chrom), "rw");
RandomAccessFile weightsRAF = new RandomAccessFile(getWeightsFname(prefix, chrom), "rw");
RandomAccessFile lasRAF = new RandomAccessFile(getLaSFname(prefix, chrom), "rw");
positionsRAF.seek(positionsRAF.length());
weightsRAF.seek(weightsRAF.length());
lasRAF.seek(lasRAF.length());
for (int i = 0; i < hits.length; i++) {
SingleHit h = hits[i];
positionsRAF.writeInt(h.pos);
weightsRAF.writeFloat(h.weight);
lasRAF.writeInt(makeLAS(h.length, h.strand));
}
positionsRAF.close();
weightsRAF.close();
lasRAF.close();
}
/** Returns the number of pages in this HeapFile. */
public int numPages() {
// some code goes here
try {
return (int) raf.length() / BufferPool.PAGE_SIZE;
} catch (IOException e) {
throw new RuntimeException("error accessing file length");
}
}
public static void main(String args[]) throws IOException {
if (args.length != 1) {
System.err.println("Usage: java LockingExample <input file>");
System.exit(0);
}
FileLock sharedLock = null;
FileLock exclusiveLock = null;
try {
RandomAccessFile raf = new RandomAccessFile(args[0], "rw");
// get the channel for the file
FileChannel channel = raf.getChannel();
System.out.println("trying to acquire lock ...");
// this locks the first half of the file - exclusive
exclusiveLock = channel.lock(0, raf.length() / 2, SHARED);
System.out.println("lock acquired ...");
/** Now modify the data . . . */
try {
// sleep for 10 seconds
Thread.sleep(10000);
} catch (InterruptedException ie) {
}
// release the lock
exclusiveLock.release();
System.out.println("lock released ...");
// this locks the second half of the file - shared
sharedLock = channel.lock(raf.length() / 2 + 1, raf.length(), SHARED);
/** Now read the data . . . */
// release the lock
sharedLock.release();
} catch (java.io.IOException ioe) {
System.err.println(ioe);
} finally {
if (exclusiveLock != null) exclusiveLock.release();
if (sharedLock != null) sharedLock.release();
}
}
public void read() throws Exception {
file.seek(0);
System.out.print("[ ");
while (file.getFilePointer() < file.length()) System.out.print(file.readInt() + " ");
System.out.println("]");
}
/**
* Appends a string to the file and returns the offset of the start of the string.
*
* @param str the string to be written.
* @return the offset of the start of the string that was written.
* @throws IOException if an I/O error occurs or the offset would be larger than 2^32-1.
*/
private long writeString(String str) throws IOException {
// Write the string at the end of the file.
long pos = stringFile.length();
if (pos > MASK32) throw new IOException("String file too large");
stringFile.seek(pos);
stringFile.writeUTF(str);
return pos;
}
public int luaCB_length(Lua l, LuaPlugin plugin) {
try {
l.pushNumber((double) object.length());
} catch (IOException e) {
l.pushNil();
l.pushString("IOException: " + e.getMessage());
return 2;
}
return 1;
}
public static byte[] loadFileIntoByteArray(String path) throws IOException {
RandomAccessFile f = new RandomAccessFile(path, "r");
try {
byte[] data = new byte[(int) f.length()];
f.readFully(data);
return data;
} finally {
f.close();
}
}
/**
* @param file the file to read the line numbers from
* @return Number of lines in file
* @throws IOException low level file error
*/
public static int numberOfLines(File file) throws IOException {
RandomAccessFile randFile = new RandomAccessFile(file, "r");
long lastRec = randFile.length();
randFile.close();
FileReader fileRead = new FileReader(file);
LineNumberReader lineRead = new LineNumberReader(fileRead);
lineRead.skip(lastRec);
int count = lineRead.getLineNumber() - 1;
fileRead.close();
lineRead.close();
return count;
}
private static void replacePackageForJavaFile(File path, String oldPackage, String newPackage) {
if (path != null && path.exists()) {
// 处理文件夹
if (path.isDirectory()) {
if ("target".equals(path.getName())) {
return;
}
String[] children = path.list();
for (int i = 0; i < children.length; i++) {
File child =
new File(path.getPath() + System.getProperty("file.separator") + children[i]);
// 递归处理
replacePackageForJavaFile(child, oldPackage, newPackage);
}
} else {
// 处理相关文件
if (path.getName().toLowerCase().endsWith(".java")
|| path.getName().toLowerCase().endsWith(".jsp")
|| path.getName().toLowerCase().endsWith(".ftl")
|| path.getName().toLowerCase().endsWith(".properties")
|| path.getName().toLowerCase().endsWith(".xml")) {
System.out.println(path.getAbsolutePath());
fileCount++;
try {
byte[] content;
try (RandomAccessFile f = new RandomAccessFile(path, "rw")) {
content = new byte[(int) f.length()];
f.readFully(content);
}
String text = new String(content, "utf-8");
// 替换package
text = text.replaceAll("package " + oldPackage, "package " + newPackage);
// 替换import
text = text.replaceAll("import " + oldPackage, "import " + newPackage);
// 替换/分割的路径
String _old = oldPackage.split("\\.")[0] + "/" + oldPackage.split("\\.")[1];
String _new = newPackage.split("\\.")[0] + "/" + newPackage.split("\\.")[1];
text = text.replaceAll(_old, _new);
// 除了本文件，其他文件要全文替换，这个替换要在最后
if (!path.getName().endsWith("ChangePackageName.java")) {
text = text.replaceAll(oldPackage, newPackage);
}
try (Writer writer = new OutputStreamWriter(new FileOutputStream(path), "utf-8")) {
writer.write(text);
}
} catch (Exception ex) {
failCount++;
}
}
}
}
}
public static void main(String[] args) throws IOException {
try ( // Create a random access file
RandomAccessFile inout = new RandomAccessFile("inout.dat", "rw"); ) {
// Clear the file to destroy the old contents if exists
inout.setLength(0);
// Write new integers to the file
for (int i = 0; i < 200; i++) inout.writeInt(i);
// Display the current length of the file
System.out.println("Current file length is " + inout.length());
// Retrieve the first number
inout.seek(0); // Move the file pointer to the beginning
System.out.println("The first number is " + inout.readInt());
// Retrieve the second number
inout.seek(1 * 4); // Move the file pointer to the second number
System.out.println("The second number is " + inout.readInt());
// Retrieve the tenth number
inout.seek(9 * 4); // Move the file pointer to the tenth number
System.out.println("The tenth number is " + inout.readInt());
// Modify the eleventh number
inout.writeInt(555);
// Append a new number
inout.seek(inout.length()); // Move the file pointer to the end
inout.writeInt(999);
// Display the new length
System.out.println("The new length is " + inout.length());
// Retrieve the new eleventh number
inout.seek(10 * 4); // Move the file pointer to the eleventh number
System.out.println("The eleventh number is " + inout.readInt());
}
}
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();
}
}
public long length() {
try {
if (!exists()) {
return 0;
}
RandomAccessFile raf = new RandomAccessFile(this, "r");
long len = raf.length();
raf.close();
return len;
} catch (IOException e) {
return 0;
}
}
/** constructs a frequency table from a file */
public static int[] constructTable(RandomAccessFile file) {
int[] ret = new int[TABLESIZE];
try {
file.seek(0L);
long l = file.length();
for (long i = 0; i < l; i++) {
int c = file.read();
ret[c]++;
}
return ret;
} catch (Exception ex) {
ExHandler.handle(ex);
return null;
}
}
/**
* Start recording
*
* @param stub
*/
public static void startRecorder(String stub) {
try {
stamp = new SimpleDateFormat("HH:mm:ss");
SimpleDateFormat dateformat = new SimpleDateFormat("yyMMdd");
Date d = new Date();
String s = dateformat.format(d);
String name = logdir + stub + s + ".txt";
R = new RandomAccessFile(name, "rw");
System.out.println("Log file: " + name);
long N = R.length();
R.seek(N);
recording = true;
} catch (Exception e) {
e.printStackTrace();
}
}
public SeatInfo() {
File file = new File(".", "data");
file.mkdir();
File f = new File(file, "SeatInfo.txt");
try {
raf = new RandomAccessFile(f, "rw");
if (raf.length() == 0) {
raf.setLength(31 * 4 * FLIGHT_PER_DAY);
for (int i = 0; i < 31 * FLIGHT_PER_DAY; i++) raf.writeInt(0);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Get the next rtp packet recorded in the rtpdump file.
*
* @param loopFile if true, when the end of the rtpdump file is reached, this
* <tt>RtpdumpFileReader</tt> will go back at the beginning of the file and get the first
* packet.
* @return a <tt>RawPacket</tt> containing all the information and data of the next rtp packet
* recorded in the rtpdump file
* @throws IOException if <tt>loopFile</tt> was false and the end of the file is reached.
*/
public RawPacket getNextPacket(boolean loopFile) throws IOException {
if (loopFile && (stream.getFilePointer() >= stream.length())) {
resetFile();
}
byte[] rtpdumpPacket;
int sizeInBytes;
stream.readShort(); // read away an useless short (2 bytes)
sizeInBytes = stream.readUnsignedShort();
rtpdumpPacket = new byte[sizeInBytes];
stream.readInt(); // read away the rtpdump timestamp
stream.read(rtpdumpPacket);
return new RawPacket(rtpdumpPacket, 0, rtpdumpPacket.length);
}
private static byte[] readFile(String sFile) {
byte[] emptybuf = null;
try {
RandomAccessFile file = new RandomAccessFile(new File(sFile), "r");
long iLen = file.length();
log(sFile + " length is " + iLen);
byte[] buf = new byte[(int) iLen];
// int[] buf = new int[(int)iLen];
file.readFully(buf);
file.close();
return buf;
} catch (IOException es) {
log("File not found.");
}
return emptybuf;
}
@Override
public int read() throws IOException {
bitOffset = 0;
if (streamPos >= raf.length()) {
int b = is.read();
if (b < 0) {
return -1;
}
raf.seek(streamPos++);
raf.write(b);
return b;
}
raf.seek(streamPos++);
return raf.read();
}
/**
* Create a new DBWriter according to the input file name.
*
* @param fileName the name of the file
* @exception FileNotFoundException from library call
* @exception IOException from library call or if file is corrupted
*/
public DBWriter(String fileName) throws IOException {
outStream = new RandomAccessFile(fileName, "rw");
lastPosition = outStream.length();
// case this is a new database
if (lastPosition == 0) {
wroteColumnNames = false;
headerSize = 0;
numRows = 0;
CRC = 0;
needReposition = false;
}
// case this might be an old database
else if (lastPosition > MIN_DATA_OFFSET) {
// check that we have a valid database here
checkID();
wroteColumnNames = true;
// read header data
outStream.seek(HEAD_SIZE_OFFSET);
headerSize = outStream.readLong();
numRows = outStream.readLong();
numColumns = outStream.readLong();
// read description
outStream.seek(headerSize - DESCRIPTION_SIZE - ID_SIZE - CRC_SIZE);
description = "";
for (int i = 0; i < DESCRIPTION_LENGTH; i++) description += outStream.readChar();
description = description.trim();
// read CRC
outStream.seek(headerSize - CRC_SIZE);
CRC = outStream.readInt();
// by default we append to an existing database
needReposition = true;
}
// case this is not a database
else throw new IOException("Attempting to load invalid database");
}
protected int read(byte[] buffer, long offset, int length) throws IOException {
AESemaphore sem;
synchronized (lock) {
if (raf.length() > offset) {
raf.seek(offset);
return (raf.read(buffer, 0, length));
}
if (stream_details == null) {
if (stream_got_eof) {
return (-1);
}
throw (new IOException("Premature end of stream (read)"));
}
sem = new AESemaphore("DMS:block");
waiters.add(sem);
}
try {
sem.reserve(1000);
} finally {
synchronized (lock) {
waiters.remove(sem);
}
}
return (0);
}