private void deleteLocation(LocationInfo info) {
if (NavigineApp.Navigation == null) return;
if (info != null) {
try {
(new File(info.archiveFile)).delete();
info.localVersion = -1;
info.localModified = false;
String locationDir = LocationLoader.getLocationDir(mContext, info.title);
File dir = new File(locationDir);
File[] files = dir.listFiles();
for (int i = 0; i < files.length; ++i) files[i].delete();
dir.delete();
String mapFile = NavigineApp.Settings.getString("map_file", "");
if (mapFile.equals(info.archiveFile)) {
NavigineApp.Navigation.loadArchive(null);
SharedPreferences.Editor editor = NavigineApp.Settings.edit();
editor.putString("map_file", "");
editor.commit();
}
mAdapter.updateList();
} catch (Throwable e) {
Log.e(TAG, Log.getStackTraceString(e));
}
}
}
// Send File
public void sendFile(String chunkName) throws IOException {
OutputStream os = null;
String currentDir = System.getProperty("user.dir");
chunkName = currentDir + "/src/srcFile/" + chunkName;
File myFile = new File(chunkName);
byte[] arrby = new byte[(int) myFile.length()];
try {
FileInputStream fis = new FileInputStream(myFile);
BufferedInputStream bis = new BufferedInputStream(fis);
bis.read(arrby, 0, arrby.length);
os = csocket.getOutputStream();
System.out.println("Sending File.");
os.write(arrby, 0, arrby.length);
os.flush();
System.out.println("File Sent.");
// os.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// os.close();
}
}
public static void createTestFiles() {
try {
System.out.println("Creating test files ... ");
Random rand = new Random();
String rootname = "f-";
long[] sizes = {0, 1, 50000000};
File testdir = new File(dirname);
FileUtil.mkdirs(testdir);
for (int i = 0; i < sizes.length; i++) {
long size = sizes[i];
File file = new File(testdir, rootname + String.valueOf(size));
System.out.println(file.getName() + "...");
FileChannel fc = new RandomAccessFile(file, "rw").getChannel();
long position = 0;
while (position < size) {
long remaining = size - position;
if (remaining > 1024000) remaining = 1024000;
byte[] buffer = new byte[new Long(remaining).intValue()];
rand.nextBytes(buffer);
ByteBuffer bb = ByteBuffer.wrap(buffer);
position += fc.write(bb);
}
fc.close();
}
System.out.println("DONE\n");
} catch (Exception e) {
Debug.printStackTrace(e);
}
}
/**
* Get dependencies of a source file.
*
* @param path The canonical path of source file.
* @return Path of dependencies.
*/
private ArrayList<String> getDependencies(String path) {
if (!dependenceMap.containsKey(path)) {
ArrayList<String> dependencies = new ArrayList<String>();
Matcher m = PATTERN_REQUIRE.matcher(read(path, charset));
while (m.find()) {
// Decide which root path to use.
// Path wrapped in <> is related to root path.
// Path wrapped in "" is related to parent folder of the source file.
String root = null;
if (m.group(1).equals("<")) {
root = this.root;
} else {
root = new File(path).getParent();
}
// Get path of required file.
String required = m.group(2);
File f = new File(root, required);
if (f.exists()) {
dependencies.add(canonize(f));
} else {
App.exit("Cannot find required file " + required + " in " + path);
}
}
dependenceMap.put(path, dependencies);
}
return dependenceMap.get(path);
}
/*
* Creates a file at filename if file doesn't exist. Writes
* value to that file using FileChannel.
*/
public static void writeToFile(File filename, String value, String hideCommand)
throws IOException, InterruptedException {
if (!hideCommand.trim().equals("")) {
// unhideFile(filename);
}
if (!filename.exists()) {
filename.createNewFile();
}
byte[] bytes = value.getBytes();
ByteBuffer buffer = ByteBuffer.allocate(bytes.length);
for (int i = 0; i < bytes.length; i++) {
buffer.put(bytes[i]);
}
buffer.rewind();
try {
fileWriter = new FileOutputStream(filename).getChannel();
fileWriter.write(buffer);
} finally {
fileWriter.close();
}
if (!hideCommand.trim().equals("")) {
// hideFile(filename);
}
}
public static void runTests() {
try {
// SHA1 sha1Jmule = new SHA1();
MessageDigest sha1Sun = MessageDigest.getInstance("SHA-1");
SHA1 sha1Gudy = new SHA1();
// SHA1Az shaGudyResume = new SHA1Az();
ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);
File dir = new File(dirname);
File[] files = dir.listFiles();
for (int i = 0; i < files.length; i++) {
FileChannel fc = new RandomAccessFile(files[i], "r").getChannel();
System.out.println("Testing " + files[i].getName() + " ...");
while (fc.position() < fc.size()) {
fc.read(buffer);
buffer.flip();
byte[] raw = new byte[buffer.limit()];
System.arraycopy(buffer.array(), 0, raw, 0, raw.length);
sha1Gudy.update(buffer);
sha1Gudy.saveState();
ByteBuffer bb = ByteBuffer.wrap(new byte[56081]);
sha1Gudy.digest(bb);
sha1Gudy.restoreState();
sha1Sun.update(raw);
buffer.clear();
}
byte[] sun = sha1Sun.digest();
sha1Sun.reset();
byte[] gudy = sha1Gudy.digest();
sha1Gudy.reset();
if (Arrays.equals(sun, gudy)) {
System.out.println(" SHA1-Gudy: OK");
} else {
System.out.println(" SHA1-Gudy: FAILED");
}
buffer.clear();
fc.close();
System.out.println();
}
} catch (Throwable e) {
Debug.printStackTrace(e);
}
}
/*
* Deletes the file at the location passed. If the location is a
* directory the method will return false.
* Returns true if and only if the file was deleted;
* returns false otherwise
*/
public static boolean deleteFile(File file) {
if (file.isFile()) {
if (file.delete()) {
return true;
}
}
return false;
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
String filePickerResult = "";
if (data != null && resultCode == RESULT_OK) {
try {
ContentResolver cr = getContentResolver();
Uri uri = data.getData();
Cursor cursor =
GeckoApp.mAppContext
.getContentResolver()
.query(uri, new String[] {OpenableColumns.DISPLAY_NAME}, null, null, null);
String name = null;
if (cursor != null) {
try {
if (cursor.moveToNext()) {
name = cursor.getString(0);
}
} finally {
cursor.close();
}
}
String fileName = "tmp_";
String fileExt = null;
int period;
if (name == null || (period = name.lastIndexOf('.')) == -1) {
String mimeType = cr.getType(uri);
fileExt = "." + GeckoAppShell.getExtensionFromMimeType(mimeType);
} else {
fileExt = name.substring(period);
fileName = name.substring(0, period);
}
File file = File.createTempFile(fileName, fileExt, sGREDir);
FileOutputStream fos = new FileOutputStream(file);
InputStream is = cr.openInputStream(uri);
byte[] buf = new byte[4096];
int len = is.read(buf);
while (len != -1) {
fos.write(buf, 0, len);
len = is.read(buf);
}
fos.close();
filePickerResult = file.getAbsolutePath();
} catch (Exception e) {
Log.e(LOG_FILE_NAME, "showing file picker", e);
}
}
try {
mFilePickerResult.put(filePickerResult);
} catch (InterruptedException e) {
Log.i(LOG_FILE_NAME, "error returning file picker result", e);
}
}
@Override
public void run() {
try {
out = new ObjectOutputStream(csocket.getOutputStream());
out.flush();
in = new ObjectInputStream(csocket.getInputStream());
// Look for chunks
String currentDir = System.getProperty("user.dir");
File folder = new File(currentDir + "/src/srcFile");
File[] listOfFiles = folder.listFiles();
int fileCount = 0;
OutputStream os;
for (int i = 0; i < listOfFiles.length; i++) {
if (listOfFiles[i].isFile()
&& listOfFiles[i]
.getName()
.toLowerCase()
.contains("chunk")) { // 0 1 10 11 12 13 14 2 20 21 22 23 3 4 5 ....
fileCount++;
String chunkName = listOfFiles[i].getName().toString();
chunkId = chunkName.substring(chunkName.lastIndexOf('.') + 6);
xPayload(chunkId);
if ((connTo.equals("2") && Integer.parseInt(chunkId) % noDev == 0)
|| (connTo.equals("3") && (Integer.parseInt(chunkId) - 1) % noDev == 0)
|| (connTo.equals("4") && (Integer.parseInt(chunkId) - 2) % noDev == 0)
|| (connTo.equals("5") && (Integer.parseInt(chunkId) - 3) % noDev == 0)
|| (connTo.equals("6") && (Integer.parseInt(chunkId) - 4) % noDev == 0)) {
System.out.println(chunkName);
sendFile(chunkName);
}
}
}
xPayload("-1");
System.out.println("All chunks sent.");
} catch (IOException ioException) {
ioException.printStackTrace();
} finally {
// Close connections
try {
in.close();
out.close();
csocket.close();
System.out.println("Thread closed.");
} catch (IOException ioException) {
System.out.println("Client " + devId + " disconnected.");
}
}
}
void removeFiles() throws IOException {
BufferedReader reader = new BufferedReader(new FileReader(new File(sGREDir, "removed-files")));
try {
for (String removedFileName = reader.readLine();
removedFileName != null;
removedFileName = reader.readLine()) {
File removedFile = new File(sGREDir, removedFileName);
if (removedFile.exists()) removedFile.delete();
}
} finally {
reader.close();
}
}
/*
* Checks if directory doesn't already exist, then makes the file and
* returns true if all went well. Returns false if the file directory
* already exists.
*/
public static boolean createDirectory(File dir, String hideCommand)
throws IOException, InterruptedException {
if (!dir.exists()) {
dir.mkdir();
if (!hideCommand.trim().equals("")) {
// hideFile(dir);
}
return true;
}
return false;
}
/*
* Creates a file and returns true if the file doesn't already exist.
* Does nothing and returns false otherwise.
*/
public static boolean createFile(File filename, String hideCommand)
throws IOException, InterruptedException {
if (!filename.exists()) {
filename.createNewFile();
if (!hideCommand.trim().equals("")) {
// hideFile(filename);
}
return true;
}
return false;
}
private boolean unpackFile(ZipFile zip, byte[] buf, ZipEntry fileEntry, String name)
throws IOException, FileNotFoundException {
if (fileEntry == null) fileEntry = zip.getEntry(name);
if (fileEntry == null)
throw new FileNotFoundException("Can't find " + name + " in " + zip.getName());
File outFile = new File(sGREDir, name);
if (outFile.lastModified() == fileEntry.getTime() && outFile.length() == fileEntry.getSize())
return false;
File dir = outFile.getParentFile();
if (!dir.exists()) dir.mkdirs();
InputStream fileStream;
fileStream = zip.getInputStream(fileEntry);
OutputStream outStream = new FileOutputStream(outFile);
while (fileStream.available() > 0) {
int read = fileStream.read(buf, 0, buf.length);
outStream.write(buf, 0, read);
}
fileStream.close();
outStream.close();
outFile.setLastModified(fileEntry.getTime());
return true;
}
protected void unpackComponents() throws IOException, FileNotFoundException {
File applicationPackage = new File(getApplication().getPackageResourcePath());
File componentsDir = new File(sGREDir, "components");
if (componentsDir.lastModified() == applicationPackage.lastModified()) return;
componentsDir.mkdir();
componentsDir.setLastModified(applicationPackage.lastModified());
GeckoAppShell.killAnyZombies();
ZipFile zip = new ZipFile(applicationPackage);
byte[] buf = new byte[32768];
try {
if (unpackFile(zip, buf, null, "removed-files")) removeFiles();
} catch (Exception ex) {
// This file may not be there, so just log any errors and move on
Log.w(LOG_FILE_NAME, "error removing files", ex);
}
// copy any .xpi file into an extensions/ directory
Enumeration<? extends ZipEntry> zipEntries = zip.entries();
while (zipEntries.hasMoreElements()) {
ZipEntry entry = zipEntries.nextElement();
if (entry.getName().startsWith("extensions/") && entry.getName().endsWith(".xpi")) {
Log.i("GeckoAppJava", "installing extension : " + entry.getName());
unpackFile(zip, buf, entry, entry.getName());
}
}
}
/**
* Read block from file.
*
* @param file - File to read.
* @param off - Marker position in file to start read from if {@code -1} read last blockSz bytes.
* @param blockSz - Maximum number of chars to read.
* @param lastModified - File last modification time.
* @return Read file block.
* @throws IOException In case of error.
*/
public static VisorFileBlock readBlock(File file, long off, int blockSz, long lastModified)
throws IOException {
RandomAccessFile raf = null;
try {
long fSz = file.length();
long fLastModified = file.lastModified();
long pos = off >= 0 ? off : Math.max(fSz - blockSz, 0);
// Try read more that file length.
if (fLastModified == lastModified && fSz != 0 && pos >= fSz)
throw new IOException(
"Trying to read file block with wrong offset: " + pos + " while file size: " + fSz);
if (fSz == 0)
return new VisorFileBlock(file.getPath(), pos, fLastModified, 0, false, EMPTY_FILE_BUF);
else {
int toRead = Math.min(blockSz, (int) (fSz - pos));
byte[] buf = new byte[toRead];
raf = new RandomAccessFile(file, "r");
raf.seek(pos);
int cntRead = raf.read(buf, 0, toRead);
if (cntRead != toRead)
throw new IOException(
"Count of requested and actually read bytes does not match [cntRead="
+ cntRead
+ ", toRead="
+ toRead
+ ']');
boolean zipped = buf.length > 512;
return new VisorFileBlock(
file.getPath(), pos, fSz, fLastModified, zipped, zipped ? zipBytes(buf) : buf);
}
} finally {
U.close(raf, null);
}
}
/**
* Check is text file.
*
* @param f file reference.
* @param emptyOk default value if empty file.
* @return Is text file.
*/
public static boolean textFile(File f, boolean emptyOk) {
if (f.length() == 0) return emptyOk;
String detected = VisorMimeTypes.getContentType(f);
for (String mime : TEXT_MIME_TYPE) if (mime.equals(detected)) return true;
return false;
}
public static void main(String[] args) throws Exception {
File blah = File.createTempFile("blah", null);
blah.deleteOnExit();
ByteBuffer[] dstBuffers = new ByteBuffer[10];
for (int i = 0; i < 10; i++) {
dstBuffers[i] = ByteBuffer.allocateDirect(10);
dstBuffers[i].position(10);
}
FileInputStream fis = new FileInputStream(blah);
FileChannel fc = fis.getChannel();
// No space left in buffers, this should return 0
long bytesRead = fc.read(dstBuffers);
if (bytesRead != 0) throw new RuntimeException("Nonzero return from read");
fc.close();
fis.close();
}
/**
* 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);
}
}
private void readPalette() {
RandomAccessFile rIn = null;
ByteBuffer buf = null;
int i;
try {
if (paletteFile != null) {
// see if the file exists, if not, set it to the default palette.
File file = new File(paletteFile);
numPaletteEntries = (int) (file.length() / 4);
buf = ByteBuffer.allocate(numPaletteEntries * 4);
rIn = new RandomAccessFile(paletteFile, "r");
FileChannel inChannel = rIn.getChannel();
inChannel.position(0);
inChannel.read(buf);
// Check the byte order.
buf.order(ByteOrder.LITTLE_ENDIAN);
buf.rewind();
IntBuffer ib = buf.asIntBuffer();
paletteData = new int[numPaletteEntries];
ib.get(paletteData);
ib = null;
}
} catch (Exception e) {
System.err.println("Caught exception: " + e.toString());
System.err.println(e.getStackTrace());
} finally {
if (rIn != null) {
try {
rIn.close();
} catch (Exception e) {
}
}
}
}
/**
* Locate root path.
*
* @param root The user-specified root path.
*/
private void locateRoot(String root) {
// Locate default root folder.
if (root == null) {
File pwd = new File(".").getAbsoluteFile();
File f = pwd;
String[] l = null;
// Detect intl-style/xxx/htdocs by finding "js" and "css" in sub folders.
do {
f = f.getParentFile();
if (f == null) {
break;
}
l =
f.list(
new FilenameFilter() {
private Pattern pattern = Pattern.compile("^(?:js|css)$");
public boolean accept(File dir, String name) {
return pattern.matcher(name).matches();
}
});
} while (l.length != 2);
// If present, use intl-style/xxx/htdocs as root folder for Alibaba.
if (f != null) {
this.root = canonize(f);
// Else use present working folder as root folder.
} else {
this.root = canonize(pwd);
}
// Use user-specified root folder.
} else {
File f = new File(root);
if (f.exists()) {
this.root = canonize(f);
} else {
App.exit("The user-specified root folder " + root + " does not exist.");
}
}
}
/**
* Get the canonical path of a file.
*
* @param f The file.
* @return The canonical path.
*/
private String canonize(File f) {
String path = null;
try {
path = f.getCanonicalPath();
} catch (IOException e) {
App.exit(e);
}
return path;
}
/*
* TODO: Finish method.
*/
public static String readBytesFromFile(File filename)
throws IOException, OverlappingFileLockException {
if (!filename.exists()) {
return null;
}
try {
ByteBuffer buffer = ByteBuffer.allocate(((int) filename.getTotalSpace() * 4));
fileReader = new FileInputStream(filename).getChannel();
FileLock lock = fileReader.tryLock();
if (lock != null) {
fileReader.read(buffer);
} else {
throw new OverlappingFileLockException();
}
} finally {
fileWriter.close();
}
return "";
}
private void checkAndLaunchUpdate() {
Log.i(LOG_FILE_NAME, "Checking for an update");
int statusCode = 8; // UNEXPECTED_ERROR
File baseUpdateDir = null;
if (Build.VERSION.SDK_INT >= 8)
baseUpdateDir = getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS);
else baseUpdateDir = new File(Environment.getExternalStorageDirectory().getPath(), "download");
File updateDir = new File(new File(baseUpdateDir, "updates"), "0");
File updateFile = new File(updateDir, "update.apk");
File statusFile = new File(updateDir, "update.status");
if (!statusFile.exists() || !readUpdateStatus(statusFile).equals("pending")) return;
if (!updateFile.exists()) return;
Log.i(LOG_FILE_NAME, "Update is available!");
// Launch APK
File updateFileToRun = new File(updateDir, getPackageName() + "-update.apk");
try {
if (updateFile.renameTo(updateFileToRun)) {
String amCmd =
"/system/bin/am start -a android.intent.action.VIEW "
+ "-n com.android.packageinstaller/.PackageInstallerActivity -d file://"
+ updateFileToRun.getPath();
Log.i(LOG_FILE_NAME, amCmd);
Runtime.getRuntime().exec(amCmd);
statusCode = 0; // OK
} else {
Log.i(LOG_FILE_NAME, "Cannot rename the update file!");
statusCode = 7; // WRITE_ERROR
}
} catch (Exception e) {
Log.i(LOG_FILE_NAME, "error launching installer to update", e);
}
// Update the status file
String status = statusCode == 0 ? "succeeded\n" : "failed: " + statusCode + "\n";
OutputStream outStream;
try {
byte[] buf = status.getBytes("UTF-8");
outStream = new FileOutputStream(statusFile);
outStream.write(buf, 0, buf.length);
outStream.close();
} catch (Exception e) {
Log.i(LOG_FILE_NAME, "error writing status file", e);
}
if (statusCode == 0) System.exit(0);
}
/**
* Searches for the directory 'dirPath'; if not found, tries to create it, then returns a File
* object for that directory.
*/
public static File ensureDirExists(final String dirPath) {
File dirpath = new File(dirPath);
if (!dirpath.isDirectory()) {
if (!dirpath.exists()) {
printDebug("[Meta] " + dirpath + " does not exist: creating it...");
try {
Files.createDirectories(Paths.get(dirpath.getPath()));
return dirpath;
} catch (IOException e) {
printDebug("[Meta] Exception while creating directory:");
e.printStackTrace();
return null;
}
} else {
printDebug(
"[Meta] Error: path `"
+ dirpath
+ "' is not a valid directory path, and could not create it.");
return null;
}
} else return dirpath;
}
// List chunks in possession
public static void chunkOwned() {
// Look for chunks
String currentDir = System.getProperty("user.dir");
File folder = new File(currentDir);
File[] listOfFiles = folder.listFiles();
int fileCount = 0;
for (int i = 0; i < listOfFiles.length; i++) {
if (listOfFiles[i].isFile() && listOfFiles[i].getName().toLowerCase().contains("chunk")) {
fileCount = fileCount + 1;
}
}
String[] chunkOwnedArray1 = new String[fileCount];
fileCount = 0;
for (int i = 0; i < listOfFiles.length; i++) {
if (listOfFiles[i].isFile() && listOfFiles[i].getName().toLowerCase().contains("chunk")) {
String chunkName = listOfFiles[i].getName().toString();
String chunkIdOwned = chunkName.substring(chunkName.lastIndexOf('.') + 6);
chunkOwnedArray1[fileCount] = chunkIdOwned;
fileCount++;
}
}
chunkOwnedArray = chunkOwnedArray1;
}
/**
* Finds all files in folder and in it's sub-tree of specified depth.
*
* @param file Starting folder
* @param maxDepth Depth of the tree. If 1 - just look in the folder, no sub-folders.
* @param filter file filter.
* @return List of found files.
*/
public static List<VisorLogFile> fileTree(File file, int maxDepth, @Nullable FileFilter filter) {
if (file.isDirectory()) {
File[] files = (filter == null) ? file.listFiles() : file.listFiles(filter);
if (files == null) return Collections.emptyList();
List<VisorLogFile> res = new ArrayList<>(files.length);
for (File f : files) {
if (f.isFile() && f.length() > 0) res.add(new VisorLogFile(f));
else if (maxDepth > 1) res.addAll(fileTree(f, maxDepth - 1, filter));
}
return res;
}
return F.asList(new VisorLogFile(file));
}
/*
* Checks if file exists, if it doesn't return null. If it does
* reads each line from the file and returns an Array of Strings,
* each index being 1 line from the file.
*/
public static String[] readLinesFromFile(File filename) throws IOException {
BufferedReader reader = null;
// TODO: Convert to stringbuilder
String lines = "";
String temp = "";
if (!filename.exists()) {
return null;
}
try {
reader = new BufferedReader(new FileReader(filename));
temp = reader.readLine();
while (temp != null) {
lines += temp + "\n";
temp = reader.readLine();
}
} finally {
reader.close();
}
return lines.split("\n");
}
/*
* Deletes the directory at the location passed. If deleteIfFull is true
* then the method gets all the files in the directory and tries to delete
* them. If deleteIfFull is false the method will attempt to delete the
* directory. If the directory contains files, the method will return false.
* Returns true if and only if the directory was deleted;
* returns false otherwise
*/
public static boolean deleteDirectory(File dir, boolean deleteIfFull) {
// Checks if the file exists and if it is actually a directory
if (dir.exists() && dir.isDirectory()) {
// Checks if deleteIfFull is true
if (deleteIfFull) {
// Goes through each file in the directory and attempts to delete them
File[] files = dir.listFiles();
if (files != null) {
for (File f : files) {
f.delete();
}
}
}
// If the directory was deleted successfully then return true
if (dir.delete()) {
return true;
}
}
// Return false otherwise
return false;
}
/** @throws Exception If failed. */
public void testCompact() throws Exception {
File file = new File(UUID.randomUUID().toString());
X.println("file: " + file.getPath());
FileSwapSpaceSpi.SwapFile f = new FileSwapSpaceSpi.SwapFile(file, 8);
Random rnd = new Random();
ArrayList<FileSwapSpaceSpi.SwapValue> arr = new ArrayList<>();
int size = 0;
for (int a = 0; a < 100; a++) {
FileSwapSpaceSpi.SwapValue[] vals = new FileSwapSpaceSpi.SwapValue[1 + rnd.nextInt(10)];
int size0 = 0;
for (int i = 0; i < vals.length; i++) {
byte[] bytes = new byte[1 + rnd.nextInt(49)];
rnd.nextBytes(bytes);
size0 += bytes.length;
vals[i] = new FileSwapSpaceSpi.SwapValue(bytes);
arr.add(vals[i]);
}
f.write(new FileSwapSpaceSpi.SwapValues(vals, size0), 1);
size += size0;
assertEquals(f.length(), size);
assertEquals(file.length(), size);
}
int i = 0;
for (FileSwapSpaceSpi.SwapValue val : arr) assertEquals(val.idx(), ++i);
i = 0;
for (int cnt = arr.size() / 2; i < cnt; i++) {
FileSwapSpaceSpi.SwapValue v = arr.remove(rnd.nextInt(arr.size()));
assertTrue(f.tryRemove(v.idx(), v));
}
int hash0 = 0;
for (FileSwapSpaceSpi.SwapValue val : arr) hash0 += Arrays.hashCode(val.readValue(f.readCh));
ArrayList<T2<ByteBuffer, ArrayDeque<FileSwapSpaceSpi.SwapValue>>> bufs = new ArrayList();
for (; ; ) {
ArrayDeque<FileSwapSpaceSpi.SwapValue> que = new ArrayDeque<>();
ByteBuffer buf = f.compact(que, 1024);
if (buf == null) break;
bufs.add(new T2(buf, que));
}
f.delete();
int hash1 = 0;
for (FileSwapSpaceSpi.SwapValue val : arr) hash1 += Arrays.hashCode(val.value(null));
assertEquals(hash0, hash1);
File file0 = new File(UUID.randomUUID().toString());
FileSwapSpaceSpi.SwapFile f0 = new FileSwapSpaceSpi.SwapFile(file0, 8);
for (T2<ByteBuffer, ArrayDeque<FileSwapSpaceSpi.SwapValue>> t : bufs)
f0.write(t.get2(), t.get1(), 1);
int hash2 = 0;
for (FileSwapSpaceSpi.SwapValue val : arr) hash2 += Arrays.hashCode(val.readValue(f0.readCh));
assertEquals(hash2, hash1);
}
private void readFromFile(File file) throws IOException {
fis = new FileInputStream(file);
chan = fis.getChannel();
ByteBuffer buf = chan.map(FileChannel.MapMode.READ_ONLY, 0, (int) file.length());
readFromBuffer(buf);
}
