ChromaGaming/SimpleWarBackup
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Added three new classes, with some methods

Browse source 
classes: Backup, RegionChunkList, NameCollisionException.
This commit is contained in:
BuildTools 2018-08-06 00:50:47 -07:00
parent 0dfa339856
commit 67691336e2
14 changed files with 481 additions and 394 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
.classpath
View file

@ -1,11 +1,20 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
<classpathentry kind="lib" path="/Users/kevinmathewson/Local_Test_Server_1.12.2/spigot-1.12.2.jar">
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
<attributes>
<attribute name="javadoc_location" value="jar:file:/Users/kevinmathewson/Local_Test_Server_1.12.2/craftbukkit-1.12.2.jar!/"/>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="output" path="bin"/>
<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="src" output="target/classes" path="src">
<attributes>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="output" path="target/classes"/>
</classpath>

1
.gitignore vendored
View file

@ -1 +1,2 @@
/bin/
/target/

6
.project
View file

@ -10,8 +10,14 @@
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.m2e.core.maven2Builder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.m2e.core.maven2Nature</nature>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>

1
.settings/org.eclipse.jdt.core.prefs
View file

@ -8,4 +8,5 @@ org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
org.eclipse.jdt.core.compiler.source=1.8

4
.settings/org.eclipse.m2e.core.prefs Normal file
View file

@ -0,0 +1,4 @@
activeProfiles=
eclipse.preferences.version=1
resolveWorkspaceProjects=true
version=1

47
pom.xml Normal file
View file

@ -0,0 +1,47 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.github.TBMCPlugins</groupId>
<artifactId>SimpleWarBackup</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<sourceDirectory>src</sourceDirectory>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spigot</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
</repository>
<repository>
<id>jitpack</id>
<url>https://jitpack.io/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>org.spigotmc</groupId>
<artifactId>spigot</artifactId>
<version>1.12.2-R0.1-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.github.TBMCPlugins.ButtonCore</groupId>
<artifactId>Towny</artifactId>
<version>master-SNAPSHOT</version>
</dependency>
</dependencies>
</project>

54
src/simpleWarBackup/Backup.java Normal file
View file

@ -0,0 +1,54 @@
package simpleWarBackup;
import java.io.File;
import java.util.HashMap;
import org.bukkit.Bukkit;
import com.palmergames.bukkit.towny.Towny;
import com.palmergames.bukkit.towny.object.Town;
import com.palmergames.bukkit.towny.object.TownBlock;
import simpleWarBackup.exceptions.NameCollisionException;
public class Backup
{
private final HashMap<String, //town
HashMap<String, //world
HashMap<Long, //region
RegionChunkList>>> lists
= new HashMap<String,
HashMap<String,
HashMap<Long,
RegionChunkList>>>();
private final String name;
private final File directory;
/**
* TODO write javadoc (this is the default constructor)
*
* @param name
* @throws NameCollisionException
*/
Backup(String name) throws NameCollisionException
{
checkName(this.name = name); //throws NameCollisionException
//com.palmergames.bukkit.towny.object.TownyUniverse.getWorld(null).getTowns();
}
/**
* TODO write javadoc
*
* @param name
* @throws NameCollisionException
*/
private static void checkName(String name) throws NameCollisionException
{
for (String filename : Main.backupsDir.list()) if (filename == name)
{
throw new NameCollisionException();
}
}
}

130
src/simpleWarBackup/BackupIO.java
View file

@ -20,22 +20,6 @@ import net.minecraft.server.v1_12_R1.World;
public class BackupIO
{
private static File pluginDir, backupsDir;
/**
* Defines two File variables: for the plugin's data folder, and for the "Backup Files"
* folder. Does not create either directory. The directories themselves are created
* as-needed, elsewhere in the plugin, during the process of saving a backup.
*
* @param plugin
*/
static void initialize(JavaPlugin plugin) //called from Main onEnable()
{
pluginDir = plugin.getDataFolder();
backupsDir = new File(pluginDir, "Backup Files");
}
/**
* Returns the parent directory containing the "region" destination directory, where
* the .mca files are stored. The path proceeds: backups > backup > town > world.
@ -49,13 +33,9 @@ public class BackupIO
* @param world
* @return
*/
private static File getDir(String backup, String town, CraftWorld world)
private static File getDir(String backup, String town, String worldUID)
{
return new File(
new File(
new File(backupsDir, backup )
, town )
, world.getName() );
return new File(new File (new File(Main.backupsDir, backup), town), worldUID);
}
@ -67,41 +47,31 @@ public class BackupIO
* @param chunks
* @throws IOException
*/
public static void backup(
String backup, String town, CraftWorld world, CraftChunk... chunks)
public static void backup(File worldDir, World world, Chunk... chunks)
throws IOException
{
final World worldNMS = world.getHandle();
Chunk chunkNMS;
NBTTagCompound chunkNBT; // to be serialized
NBTTagCompound chunkNBT; // to be serialized
DataOutputStream dataOutput; // serialized to here
final File worldDir = getDir(backup, town, world);
int x, z;
RegionFile regionFile;
DataOutputStream chunkPipe; // serialized to this
/* chunkPipe is a series of data outputs pointing to a ChunkBuffer.
* ChunkBuffer is an internal class defined within RegionFile that
* extends ByteArrayOutputStream. It holds a byte[] buffer and two
* int values representing the chunk's coordinates.
/* dataOutput is the first of a series of outputs, which proceed in
* the following order: DataOutputStream > BufferedOutputStream >
* DeflaterOutputStream > RegionFile.ChunkBuffer
*
* ChunkBuffer extends ByteArrayOutputStream. It holds a byte[] buffer,
* and two int values which represent the chunk's coordinates.
*/
for (CraftChunk chunk : chunks)
for (Chunk chunk : chunks)
{
chunkNMS = chunk.getHandle();
chunkNBT = ChunkNBTTools.save(chunkNMS, worldNMS);
chunkNBT = ChunkNBTTools.save(chunk, world);
dataOutput = RegionFile_Cache.get(worldDir, chunk.locX, chunk.locZ)
.b(chunk.locX & 31, chunk.locZ & 31);
x = chunk.getX();
z = chunk.getZ();
regionFile = RegionFileCache.get(worldDir, x, z);
chunkPipe = regionFile.b(x & 31, z & 31);
/* below serializes chunkNBT, and writes those bytes to chunkPipe,
* which then, on close(), writes the bytes into this RegionFile's
* internal RandomAccessFile, which points to the actual .mca file.
/* a(...) serializes the chunk, and writes the bytes to chunkPipe.
* dataOutput.close() writes the bytes to the actual .mca file.
*/
NBTCompressedStreamTools.a(chunkNBT, (DataOutput) chunkPipe);
chunkPipe.close();
NBTCompressedStreamTools.a(chunkNBT, (DataOutput) dataOutput);
dataOutput.close();
}
}
@ -115,45 +85,43 @@ public class BackupIO
*
* @throws IOException
*/
private static void restore(
String backup, String town, CraftWorld world, long... chunks)
private static void restore(File worldDir, World world, long[] chunks)
throws IOException
{
final File worldDir = getDir(backup, town, world);
int x, z, i = 0;
RegionFile source;
RegionFile target;
DataInputStream dataInput;
DataOutputStream dataOutput;
int length;
byte[] buf;
int x, z, i = 0;
RegionFile source;
RegionFile target;
DataInputStream dataInput;
DataOutputStream dataOutput;
int length;
byte[] buf;
/* dataInput is the end of a series of inputs, which proceed in
* the following order: ByteArrayInputStream > GZIPInputStream >
* BufferedInputStream > DataInputStream.
*
* dataOutput is a series of outputs pointing to a ChunkBuffer.
* ChunkBuffer is an internal class defined within RegionFile that
* extends ByteArrayOutputStream. It holds a byte[] buffer and two
* int values representing the chunk's coordinates.
* dataOutput is the first of a series of outputs, which proceed in
* the following order: DataOutputStream > BufferedOutputStream >
* DeflaterOutputStream > RegionFile.ChunkBuffer
*
* ChunkBuffer extends ByteArrayOutputStream. It holds a byte[] buffer,
* and two int values which represent the chunk's coordinates.
*/
for (long chunk : chunks)
{
x = (int) chunk;
z = (int) ( chunk >> 32 );
source = RegionFileCache.get(worldDir, x, z);
target = RegionFileCache.getFromMinecraft(world, x, z);
source = RegionFile_Cache.get(worldDir, x, z);
target = RegionFile_Cache.getFromMinecraft(world, x, z);
dataInput = source.a(x & 31, z & 31);
dataOutput = target.b(x & 31, z & 31);
length = RegionFileCache.getChunkLength(source, x, z);
length = ChunkAccess_Cache.getChunkLength(source, x, z);
/* getChunkLength(...) attempts to read from RegionFile source's
* private .mca file. It will return length 0 if there is an error
/* getChunkLength(...) will return length 0 if there is an error
* or there is no chunk data. Otherwise, it will return the length
* value recorded in the file.
*/
@ -169,11 +137,11 @@ public class BackupIO
* ((long) Integer.MAX_VALUE) | (((long) Integer.MAX_VALUE) << 32)
*
* coordinates in long[] 'chunks' are set to this value when they
* have been written successfully back into the game world. This
* value is outside the range of natural chunk coordinate pairs.
* have been written successfully back into the game world, because
* this value is outside the range of natural chunk coordinate pairs.
*/
}
dataOutput.close(); //writes to the target file
dataOutput.close(); //writes to target's .mca file
dataInput.close();
i++;
}
@ -193,17 +161,25 @@ public class BackupIO
public static boolean restoreTest(int x, int z) throws IOException
{
CraftWorld world = (CraftWorld) Bukkit.getWorld("world");
File worldDir = new File(backupsDir, "world");
File worldDir = new File(Main.backupsDir, "world");
File backupDir = new File(worldDir, "test");
File regionDir = new File(backupDir, "region");
File mcaFile = new File(regionDir, "r.1.1.mca");
RegionFile regionFileSource = RegionFileCache.get(backupDir, x, z);
RegionFile regionFileTarget = RegionFileCache.getFromMinecraft(world, x, z);
RegionFile regionFileSource = RegionFile_Cache.get(backupDir, x, z);
RegionFile regionFileTarget = RegionFile_Cache.getFromMinecraft(world, x, z);
DataInputStream dataInput = regionFileSource.a(x & 31, z & 31);
DataOutputStream dataOutput = regionFileTarget.b(x & 31, z & 31);

55
src/simpleWarBackup/ChunkAccessCache.java → src/simpleWarBackup/ChunkAccess_Cache.java
View file

@ -11,27 +11,19 @@ import java.util.Map;
import net.minecraft.server.v1_12_R1.RegionFile;
/**
* ---------------------------------------------------------------
* ---------------------------------------------------------------
* ---------------------------------------------------------------
* ---------------------------------------------------------------
* CURRENTLY A DUPLICATE OF THE SECONDARY CACHE IN RegionFileCache
* ---------------------------------------------------------------
* ---------------------------------------------------------------
* ---------------------------------------------------------------
* ---------------------------------------------------------------
* TODO write javadoc
*/
public class ChunkAccessCache
public class ChunkAccess_Cache
{
private static Map<RegionFile, Access> cache = new HashMap<RegionFile, Access>();
static Map<RegionFile, Access> cache = new HashMap<RegionFile, Access>();
/**
* TODO
* TODO write javadoc
*
* @param file
* @param regionFile
*/
static void cacheChunkAccess(File file, RegionFile regionFile)
static void createAndPut(File file, RegionFile regionFile)
{
try
{
@ -59,20 +51,19 @@ public class ChunkAccessCache
Access access = cache.get(regionFile);
/* "offset" refers to the location of the chunk's bytes
* within the .mca file - or how many bytes into the file
* to seek when reading - divided by 4096.
* within the .mca file (i.e. how many bytes into the file
* to seek when reading) divided by 4096.
*/
int offset;
/* The first four bytes at that location, the first four
* bytes of the chunk's data, are an int recording the
* chunk's length in bytes, not including those four.
/* The first four bytes at that location encode an int. This
* int is the chunk's remaining length in bytes, excluding the
* four bytes of the int.
*
* The next byte represents compression scheme. This byte,
* like the four previous bytes, is omitted when the game
* reads a chunk's data.
* The fifth byte represents compression scheme. The first five
* bytes are omitted when the game reads a chunk's data.
*
* This method returns the length of data actually read.
* The following method returns the length of data actually read.
*/
if (access != null && (offset = access.offset[x + z * 32]) > 0)
{
@ -88,16 +79,15 @@ public class ChunkAccessCache
/**
* Gives access to the private fields {@code int[] d}, and {@code RandomAccessFile c},
* Provides access to the private fields {@code int[] d}, and {@code RandomAccessFile c},
* within a RegionFile object. The names of these fields may change in new releases of
* Spigot. TODO explain what both of those fields are
*/
private static class Access
{
static final Field offsetField;
final int[] offset;
static final Field bytesField;
static final Field offsetField;
static final Field bytesField;
final int[] offset;
final RandomAccessFile bytes;
static
@ -106,18 +96,13 @@ public class ChunkAccessCache
Field tmp2 = null;
try
{
tmp1 = RegionFile.class.getDeclaredField("d");
tmp1.setAccessible(true);
tmp1 = RegionFile.class.getDeclaredField("d");
tmp2 = RegionFile.class.getDeclaredField("c");
tmp1.setAccessible(true);
tmp2.setAccessible(true);
}
catch (NoSuchFieldException | SecurityException e)
{
/* TODO take more drastic action? Either
* Field missing would mean that Minecraft
* has refactored, breaking the whole plugin
*/
e.printStackTrace();
}
offsetField = tmp1;
@ -140,7 +125,7 @@ public class ChunkAccessCache
IllegalAccessException,
IllegalArgumentException
{
offset = (int[]) offsetField.get(regionFile);
offset = (int[]) offsetField.get(regionFile);
bytes = (RandomAccessFile) bytesField .get(regionFile);
}
}

39
src/simpleWarBackup/Main.java
View file

@ -18,14 +18,49 @@ import org.bukkit.plugin.java.JavaPlugin;
public class Main extends JavaPlugin implements Listener
{
// --------------------- STATIC ---------------------
static File pluginDir;
static File backupsDir;
/**
* Defines two File variables: for the plugin's data folder, and for the "Backup Files"
* folder. Does not create either directory. The directories themselves are created
* as-needed, elsewhere in the plugin, during the process of saving a backup.
*
* @param plugin
*/
static void initialize(JavaPlugin plugin)
{
pluginDir = plugin.getDataFolder();
backupsDir = new File(pluginDir, "Backup Files");
}
// -------------------- INSTANCE --------------------
public void onEnable()
{
initialize(this);
//TEST
getCommand("testBackupChunk").setExecutor(this);
getCommand("testRestoreChunk").setExecutor(this);
BackupIO.initialize(this);
}
public boolean onCommand(CommandSender sender, Command command, String label, String[] args)
{
if (!(sender instanceof Player)) return false;

128
src/simpleWarBackup/RegionChunkList.java
View file

@ -4,53 +4,90 @@ import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.BitSet;
import java.util.HashMap;
/**
* TODO write javadoc
*/
public class RegionChunkList
{
private final File file;
/**
* TODO write javadoc
*/
private final RandomAccessFile readwrite;
private final BitSet chunks = new BitSet(1024);
private final HashMap<String, HashMap
<String, HashMap
<String, RegionChunkList>>> lists =
new HashMap<String, HashMap
<String, HashMap
<String, RegionChunkList>>>();
/**
* TODO write javadoc
*/
final BitSet chunks = new BitSet(1024);
/**
* TODO write javadoc
*/
final long regionCoordinates;
/**
* TODO
* TODO write javadoc
*
* @param file
* @throws IOException
*/
RegionChunkList(File file, String backup, String town, String world) throws IOException
RegionChunkList(File file) throws IOException
{
readwrite = new RandomAccessFile((this.file = file), "rw");
readwrite = new RandomAccessFile(file, "rw");
byte[] bytes = new byte[128];
if (readwrite.length() >= 128)
{
// Write chunk list to BitSet:
{
byte[] bytes = new byte[128];
readwrite.readFully(bytes);
/* Each bit represents one of the region's 1024 chunks (32x32). Chunks are
* listed in ascending x,z order: (0,0),(1,0)...(31,0),(0,1),(1,1)......(31,31).
*
* Bits in each byte are read from smallest to largest position: 1,2,4...128.
* The values are written to a BitSet, which represents the region in runtime.
*
* 1 = true, 0 = false.
*/
int i = 0, j, k;
for (byte b : bytes)
for (j = 0, k = 1; j < 8; i++, j++, k <<= 1)
if ((b & k) == k) chunks.set(i);
}
else readwrite.write(bytes);
lists.get(backup)
.get(town)
.put(world, this);
// Get region coordinate from filename:
{
String[] name = file.getName().split(".");
int x = Integer.parseInt(name[1]);
int z = Integer.parseInt(name[2]);
regionCoordinates = (long) x | ((long) z << 32);
}
}
/**
* TODO
* TODO write javadoc
*
* @param directory
* @param regionCoordinates
*/
RegionChunkList(File directory, long regionCoordinates) throws IOException
{
this.regionCoordinates = regionCoordinates;
int x = (int) regionCoordinates;
int z = (int) (regionCoordinates >>> 32);
String filename = "r." + x + "." + z + ".chunklist";
File file = new File(directory, filename);
readwrite = new RandomAccessFile(file, "rw");
}
/**
* TODO write javadoc (and add comment to explain numbers)
*
* @param x
* @param z
@ -65,7 +102,7 @@ public class RegionChunkList
/**
* TODO
* TODO write javadoc (and add comment to explain numbers)
*
* @param x
* @param z
@ -79,7 +116,7 @@ public class RegionChunkList
/**
* TODO
* TODO write javadoc (and add comment to explain numbers)
*
* @param x
* @param z
@ -90,4 +127,47 @@ public class RegionChunkList
z &= 31;
chunks.clear(x + z * 32);
}
/**
* TODO write javadoc
*
* @throws IOException
*/
void saveToFile() throws IOException
{
int i = 0;
byte bytes[] = new byte[128];
for (byte b : bytes)
{
if (chunks.get(i++)) b = (byte) (b | (byte) 1 );
if (chunks.get(i++)) b = (byte) (b | (byte) 2 );
if (chunks.get(i++)) b = (byte) (b | (byte) 4 );
if (chunks.get(i++)) b = (byte) (b | (byte) 8 );
if (chunks.get(i++)) b = (byte) (b | (byte) 16 );
if (chunks.get(i++)) b = (byte) (b | (byte) 32 );
if (chunks.get(i++)) b = (byte) (b | (byte) 64 );
if (chunks.get(i++)) b = (byte) (b | (byte) 128);
}
readwrite.seek(0);
readwrite.write(bytes);
}
/**
* Closes the RandomAccessFile associated with this RegionChunkList.<p>
*
* When you are done with this RegionChunkList, you should invoke this method.
*/
void close()
{
try
{
readwrite.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}

251
src/simpleWarBackup/RegionFileCache.java
View file

@ -1,251 +0,0 @@
package simpleWarBackup;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.bukkit.Bukkit;
import org.bukkit.craftbukkit.v1_12_R1.CraftWorld;
import net.minecraft.server.v1_12_R1.RegionFile;
import net.minecraft.server.v1_12_R1.World;
/**
* TODO write this
*/
public final class RegionFileCache
{
private static final int cap = 32; //capacity - how many regionFiles to keep cached
private static final Map<File, RegionFile> cache = new HashMap<File, RegionFile>();
/**
* Returns name of the region file that would contain the given chunk coordinates.
* Name follows the standard minecraft format: "r.[region x].[region z].mca".
* Region coordinate = chunk coordinate >> 5.
*
* @param x global chunk coordinate x
* @param z global chunk coordinate z
* @return
*/
public static String path(int x, int z)
{
return "r." + (x >> 5) + "." + (z >> 5) + ".mca";
}
/**
* Copied from net.minecraft.server.RefionFileCache.a(File, int, int).<p>
*
* Returns any cached RegionFile mapped to the given File. Not finding one, creates
* and caches, then returns, a new RegionFile. Before caching a new RegionFile, checks
* that the cache contains fewer than 16 RegionFiles, and, finding 16 or more, calls
* {@link #clearCache() RegionFileCache.clearCache()}.
*
* @param backupDir parent folder containing the "region" folder
* @param x global chunk coordinate x
* @param z global chunk coordinate z
* @return
*/
public static synchronized RegionFile get(File backupDir, int x, int z)
{
File regionDir = new File(backupDir, "region");
File mcaFile = new File(regionDir, path(x,z));
RegionFile regionFile = cache.get(mcaFile);
if (regionFile != null)
return regionFile;
if (!regionDir.exists())
regionDir.mkdirs();
if (cache.size() >= cap)
clearCache();
regionFile = new RegionFile(mcaFile);
RegionFileCache.cache.put(mcaFile, regionFile);
RegionFileCache.cacheChunkAccess(mcaFile, regionFile);
return regionFile;
}
/**
* Copied from net.minecraft.server.RegionFileCache.a(). Iterates through all cached
* RegionFiles, closing each one's private RandomAccessFile, then clears the cache.
*/
public static synchronized void clearCache()
{
Iterator<RegionFile> iterator = RegionFileCache.cache.values().iterator();
/* regionFile.c() closes the private RandomAccessFile
* inside the regionFile object, and that's all it does.
* The entire method: if (file != null) file.close().
*/
while (iterator.hasNext())
{
RegionFile regionFile = iterator.next();
try { if (regionFile != null) regionFile.c(); }
catch (IOException e) { e.printStackTrace(); }
}
RegionFileCache.cache.clear();
RegionFileCache.cacheChunkAccess.clear();
}
/**
* TODO
*
* @param world
* @param x
* @param z
* @return
*/
public static RegionFile getFromMinecraft(CraftWorld world, int x, int z)
{
/* root directory of the world, the directory
* sharing the world's name and holding its
* data. 'region' folder is found in here.
*/
File dir = world.getHandle().getDataManager().getDirectory();
return net.minecraft.server.v1_12_R1.RegionFileCache.a(dir, x, z);
}
/*=================================Chunk Access=================================*/
/* Secondary cache, for holding references to the private fields "c" and "d" in each
* RegionFile cached above. TODO write more
*/
private static Map<RegionFile,
ChunkAccess> cacheChunkAccess = new HashMap<RegionFile,
ChunkAccess>();
/**
* TODO
*
* @param file
* @param regionFile
*/
private static void cacheChunkAccess(File file, RegionFile regionFile)
{
try
{
cacheChunkAccess.put(regionFile, new ChunkAccess(regionFile));
}
catch (FileNotFoundException |
IllegalAccessException |
IllegalArgumentException e)
{
e.printStackTrace();//TODO
}
}
/**
* TODO
*
* @param regionFile
* @param x
* @param z
* @return
*/
public static int getChunkLength(RegionFile regionFile, int x, int z)
{
ChunkAccess access = cacheChunkAccess.get(regionFile);
/* "offset" refers to the location of the chunk's bytes
* within the .mca file - or how many bytes into the file
* to seek when reading - divided by 4096.
*/
int offset;
/* The first four bytes at that location, the first four
* bytes of the chunk's data, are an int recording the
* chunk's length in bytes, not including those four.
*
* The next byte represents compression scheme. This byte,
* like the four previous bytes, is omitted when the game
* reads a chunk's data.
*
* This method returns the length of data actually read.
*/
if (access != null && (offset = access.offset[x + z * 32]) > 0)
{
try
{
access.bytes.seek(offset * 4096);
return access.bytes.readInt() - 1;
}
catch (IOException e) { e.printStackTrace(); }
}
return 0;
}
/**
* Gives access to the private fields {@code int[] d}, and {@code RandomAccessFile c},
* within a RegionFile object. The names of these fields may change in new releases of
* Spigot. TODO explain what both of those fields are
*/
private static class ChunkAccess
{
static final Field offsetField;
final int[] offset;
static final Field bytesField;
final RandomAccessFile bytes;
static
{
Field tmp1 = null;
Field tmp2 = null;
try
{
tmp1 = RegionFile.class.getDeclaredField("d");
tmp1.setAccessible(true);
tmp2 = RegionFile.class.getDeclaredField("c");
tmp2.setAccessible(true);
}
catch (NoSuchFieldException | SecurityException e)
{
/* TODO take more drastic action? Either
* Field missing would mean that Minecraft
* has refactored, breaking the whole plugin
*/
e.printStackTrace();
}
offsetField = tmp1;
bytesField = tmp2;
}
/**
* Creates a new DataAccess object, which holds references to the private variables
* {@code int[] d} and {@code RandomAccessFile c} within the given RegionFile. Variables
* are accessed by reflection. TODO write more
*
* @param regionFile the RegionFile whose chunks are to be accessed
*
* @throws FileNotFoundException
* @throws IllegalAccessException
* @throws IllegalArgumentException
*/
ChunkAccess(RegionFile regionFile)
throws FileNotFoundException,
IllegalAccessException,
IllegalArgumentException
{
this.offset = (int[]) offsetField.get(regionFile);
this.bytes = (RandomAccessFile) bytesField .get(regionFile);
}
}
}

132
src/simpleWarBackup/RegionFile_Cache.java Normal file
View file

@ -0,0 +1,132 @@
package simpleWarBackup;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.bukkit.craftbukkit.v1_12_R1.CraftWorld;
import net.minecraft.server.v1_12_R1.RegionFile;
import net.minecraft.server.v1_12_R1.World;
/**
* TODO write this
*/
public final class RegionFile_Cache
{
private static final int cap = 32; //capacity - how many regionFiles to keep cached
private static final Map<File, RegionFile> cache = new HashMap<File, RegionFile>();
/**
* Returns name of the region file that would contain the given chunk coordinates.
* Name follows the standard minecraft format: "r.[region x].[region z].mca".
* Region coordinate = chunk coordinate >> 5.
*
* @param x global chunk coordinate x
* @param z global chunk coordinate z
* @return
*/
public static String path(int x, int z)
{
return "r." + (x >> 5) + "." + (z >> 5) + ".mca";
}
/**
* Method copied from net.minecraft.server.RefionFileCache.a(File, int, int).<p>
*
* If there is a cached RegionFile for the given file and coordinates, returns this.
* Otherwise, creates, caches, then returns a new RegionFile for the given file and
* coordinates.
*
* @param backupDir parent folder containing the "region" folder
* @param x global chunk coordinate x
* @param z global chunk coordinate z
* @return
*/
public static synchronized RegionFile get(File backupDir, int x, int z)
{
File regionDir = new File(backupDir, "region");
File mcaFile = new File(regionDir, path(x,z));
RegionFile regionFile = cache.get(mcaFile);
if (regionFile != null)
return regionFile;
if (!regionDir.exists())
regionDir.mkdirs();
if (cache.size() >= cap)
clearCache();
regionFile = new RegionFile(mcaFile);
RegionFile_Cache.cache.put(mcaFile, regionFile);
ChunkAccess_Cache.createAndPut(mcaFile, regionFile);
return regionFile;
}
/**
* Method Copied from net.minecraft.server.RegionFileCache.a().<p>
*
* Called by {@link #get(File, int, int) RegionFile_Cache.get(File, int, int)}.<p>
*
* Removes all entries from the cache.
*/
private static synchronized void clearCache()
{
Iterator<RegionFile> iterator = RegionFile_Cache.cache.values().iterator();
/* regionFile.c() closes the private RandomAccessFile
* inside the regionFile object, and that's all it does.
* The entire method: if (file != null) file.close().
*/
while (iterator.hasNext())
{
RegionFile regionFile = iterator.next();
try { if (regionFile != null) regionFile.c(); }
catch (IOException e) { e.printStackTrace(); }
}
RegionFile_Cache.cache.clear();
ChunkAccess_Cache.cache.clear();
}
/**
* TODO
*
* @param world
* @param x
* @param z
* @return
*/
public static RegionFile getFromMinecraft(CraftWorld world, int x, int z)
{
/* root directory of the world, the directory
* sharing the world's name and holding its
* data. 'region' folder is found in here.
*/
File dir = world.getHandle().getDataManager().getDirectory();
return net.minecraft.server.v1_12_R1.RegionFileCache.a(dir, x, z);
}
/**
* TODO
*
* @param world
* @param x
* @param z
* @return
*/
public static RegionFile getFromMinecraft(World world, int x, int z)
{
/* root directory of the world, the directory
* sharing the world's name and holding its
* data. 'region' folder is found in here.
*/
File dir = world.getDataManager().getDirectory();
return net.minecraft.server.v1_12_R1.RegionFileCache.a(dir, x, z);
}
}

8
src/simpleWarBackup/exceptions/NameCollisionException.java Normal file
View file

@ -0,0 +1,8 @@
package simpleWarBackup.exceptions;
public class NameCollisionException extends Throwable
{
//TODO serialVersionUID?
//TODO write the damn class
}