commit cd4f99df3dec637da6ab4de96fb78c0a24628826 Author: akwizgran Date: Tue Jun 21 18:01:28 2011 +0100 Initial commit with new directory structure. diff --git a/.classpath b/.classpath new file mode 100644 index 000000000..18ed19663 --- /dev/null +++ b/.classpath @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..10f676900 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +/windows-jre +/Briar +/bin diff --git a/.project b/.project new file mode 100644 index 000000000..6c3dba207 --- /dev/null +++ b/.project @@ -0,0 +1,17 @@ + + + briar-prototype + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000..1cf045675 --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,12 @@ +#Wed Apr 13 15:01:36 BST 2011 +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.5 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +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.source=1.5 diff --git a/api/.gitignore b/api/.gitignore new file mode 100644 index 000000000..796b96d1c --- /dev/null +++ b/api/.gitignore @@ -0,0 +1 @@ +/build diff --git a/api/build.xml b/api/build.xml new file mode 100644 index 000000000..48ffec3d9 --- /dev/null +++ b/api/build.xml @@ -0,0 +1,3 @@ + + + diff --git a/api/net/sf/briar/api/crypto/Password.java b/api/net/sf/briar/api/crypto/Password.java new file mode 100644 index 000000000..be576f328 --- /dev/null +++ b/api/net/sf/briar/api/crypto/Password.java @@ -0,0 +1,6 @@ +package net.sf.briar.api.crypto; + +public interface Password { + + char[] getPassword(); +} diff --git a/api/net/sf/briar/api/db/DatabaseComponent.java b/api/net/sf/briar/api/db/DatabaseComponent.java new file mode 100644 index 000000000..8f5cd228e --- /dev/null +++ b/api/net/sf/briar/api/db/DatabaseComponent.java @@ -0,0 +1,43 @@ +package net.sf.briar.api.db; + +import java.util.Set; + +import net.sf.briar.api.protocol.AuthorId; +import net.sf.briar.api.protocol.Bundle; +import net.sf.briar.api.protocol.GroupId; +import net.sf.briar.api.protocol.Message; + +public interface DatabaseComponent { + + static final long MEGABYTES = 1024L * 1024L; + static final long GIGABYTES = 1024L * MEGABYTES; + + static final long MAX_DB_SIZE = 2L * GIGABYTES; + static final long MIN_FREE_SPACE = 300L * MEGABYTES; + static final long CRITICAL_FREE_SPACE = 100L * MEGABYTES; + static final long MAX_BYTES_BETWEEN_SPACE_CHECKS = 5L * MEGABYTES; + static final long MAX_MS_BETWEEN_SPACE_CHECKS = 60L * 1000L; // 1 min + static final long BYTES_PER_SWEEP = 5L * MEGABYTES; + static final int CLEANER_SLEEP_MS = 1000; // 1 sec + static final int RETRANSMIT_THRESHOLD = 3; + + void close() throws DbException; + + void addLocallyGeneratedMessage(Message m) throws DbException; + + void addNeighbour(NeighbourId n) throws DbException; + + void generateBundle(NeighbourId n, Bundle b) throws DbException; + + Rating getRating(AuthorId a) throws DbException; + + Set getSubscriptions() throws DbException; + + void receiveBundle(NeighbourId n, Bundle b) throws DbException; + + void setRating(AuthorId a, Rating r) throws DbException; + + void subscribe(GroupId g) throws DbException; + + void unsubscribe(GroupId g) throws DbException; +} diff --git a/api/net/sf/briar/api/db/DatabasePassword.java b/api/net/sf/briar/api/db/DatabasePassword.java new file mode 100644 index 000000000..06f5e4fb2 --- /dev/null +++ b/api/net/sf/briar/api/db/DatabasePassword.java @@ -0,0 +1,14 @@ +package net.sf.briar.api.db; + +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import com.google.inject.BindingAnnotation; + +@BindingAnnotation +@Target({ PARAMETER }) +@Retention(RUNTIME) +public @interface DatabasePassword {} diff --git a/api/net/sf/briar/api/db/DbException.java b/api/net/sf/briar/api/db/DbException.java new file mode 100644 index 000000000..1061f76e4 --- /dev/null +++ b/api/net/sf/briar/api/db/DbException.java @@ -0,0 +1,10 @@ +package net.sf.briar.api.db; + +public class DbException extends Exception { + + private static final long serialVersionUID = 3706581789209939441L; + + public DbException(Throwable t) { + super(t); + } +} diff --git a/api/net/sf/briar/api/db/NeighbourId.java b/api/net/sf/briar/api/db/NeighbourId.java new file mode 100644 index 000000000..b35a92680 --- /dev/null +++ b/api/net/sf/briar/api/db/NeighbourId.java @@ -0,0 +1,30 @@ +package net.sf.briar.api.db; + +public class NeighbourId { + + private final int id; + + public NeighbourId(int id) { + this.id = id; + } + + public int getInt() { + return id; + } + + @Override + public boolean equals(Object o) { + if(o instanceof NeighbourId) return id == ((NeighbourId) o).id; + return false; + } + + @Override + public int hashCode() { + return id; + } + + @Override + public String toString() { + return String.valueOf(id); + } +} diff --git a/api/net/sf/briar/api/db/Rating.java b/api/net/sf/briar/api/db/Rating.java new file mode 100644 index 000000000..b8b4a07f8 --- /dev/null +++ b/api/net/sf/briar/api/db/Rating.java @@ -0,0 +1,5 @@ +package net.sf.briar.api.db; + +public enum Rating { + BAD, UNRATED, GOOD +} diff --git a/api/net/sf/briar/api/db/Status.java b/api/net/sf/briar/api/db/Status.java new file mode 100644 index 000000000..ed5bba15f --- /dev/null +++ b/api/net/sf/briar/api/db/Status.java @@ -0,0 +1,5 @@ +package net.sf.briar.api.db; + +public enum Status { + NEW, SENT, SEEN +} diff --git a/api/net/sf/briar/api/i18n/FontManager.java b/api/net/sf/briar/api/i18n/FontManager.java new file mode 100644 index 000000000..87053fa5b --- /dev/null +++ b/api/net/sf/briar/api/i18n/FontManager.java @@ -0,0 +1,18 @@ +package net.sf.briar.api.i18n; + +import java.awt.Font; +import java.io.IOException; +import java.util.Locale; + +public interface FontManager { + + void initialize(Locale locale) throws IOException; + + String[] getBundledFontFilenames(); + + Font getFontForLanguage(String language); + + Font getUiFont(); + + void setUiFontForLanguage(String language); +} \ No newline at end of file diff --git a/api/net/sf/briar/api/i18n/I18n.java b/api/net/sf/briar/api/i18n/I18n.java new file mode 100644 index 000000000..2e93804ef --- /dev/null +++ b/api/net/sf/briar/api/i18n/I18n.java @@ -0,0 +1,33 @@ +package net.sf.briar.api.i18n; + +import java.awt.ComponentOrientation; +import java.awt.Font; +import java.io.File; +import java.io.IOException; +import java.util.Locale; + +public interface I18n { + + String tr(String name); + + Locale getLocale(); + + void setLocale(Locale locale); + + void loadLocale() throws IOException; + + void saveLocale() throws IOException; + + void saveLocale(File dir) throws IOException; + + ComponentOrientation getComponentOrientation(); + + void addListener(Listener l); + + void removeListener(Listener l); + + public interface Listener { + + void localeChanged(Font uiFont); + } +} \ No newline at end of file diff --git a/api/net/sf/briar/api/i18n/Stri18ng.java b/api/net/sf/briar/api/i18n/Stri18ng.java new file mode 100644 index 000000000..250752b0e --- /dev/null +++ b/api/net/sf/briar/api/i18n/Stri18ng.java @@ -0,0 +1,41 @@ +package net.sf.briar.api.i18n; + +public class Stri18ng { + + private static final String HTML_OPEN_LEFT = ""; + private static final String HTML_OPEN_RIGHT = ""; + private static final String HTML_CLOSE = ""; + private static final String PARAGRAPH = "

"; // Yes, two of them + + private final String name; + private final I18n i18n; + + public Stri18ng(String name, I18n i18n) { + this.name = name; + this.i18n = i18n; + } + + public String tr() { + return i18n.tr(name); + } + + public String html() { + if(i18n.getComponentOrientation().isLeftToRight()) + return HTML_OPEN_LEFT + i18n.tr(name) + HTML_CLOSE; + else return HTML_OPEN_RIGHT + i18n.tr(name) + HTML_CLOSE; + } + + public String html(String... paras) { + StringBuilder s = new StringBuilder(); + if(i18n.getComponentOrientation().isLeftToRight()) + s.append(HTML_OPEN_LEFT); + else s.append(HTML_OPEN_RIGHT); + s.append(tr()); + for(String para : paras) { + s.append(PARAGRAPH); + s.append(para); + } + s.append(HTML_CLOSE); + return s.toString(); + } +} diff --git a/api/net/sf/briar/api/invitation/InvitationCallback.java b/api/net/sf/briar/api/invitation/InvitationCallback.java new file mode 100644 index 000000000..01d9fc3a6 --- /dev/null +++ b/api/net/sf/briar/api/invitation/InvitationCallback.java @@ -0,0 +1,23 @@ +package net.sf.briar.api.invitation; + +import java.io.File; +import java.util.List; + +public interface InvitationCallback { + + boolean isCancelled(); + + void copyingFile(File f); + + void encryptingFile(File f); + + void created(List files); + + void error(String message); + + void notFound(File f); + + void notDirectory(File f); + + void notAllowed(File f); +} diff --git a/api/net/sf/briar/api/invitation/InvitationParameters.java b/api/net/sf/briar/api/invitation/InvitationParameters.java new file mode 100644 index 000000000..550e78fda --- /dev/null +++ b/api/net/sf/briar/api/invitation/InvitationParameters.java @@ -0,0 +1,16 @@ +package net.sf.briar.api.invitation; + +import java.io.File; + +public interface InvitationParameters { + + boolean shouldCreateExe(); + + boolean shouldCreateJar(); + + char[] getPassword(); + + File getChosenLocation(); + + String[] getBundledFontFilenames(); +} diff --git a/api/net/sf/briar/api/invitation/InvitationWorkerFactory.java b/api/net/sf/briar/api/invitation/InvitationWorkerFactory.java new file mode 100644 index 000000000..a178f1ec6 --- /dev/null +++ b/api/net/sf/briar/api/invitation/InvitationWorkerFactory.java @@ -0,0 +1,7 @@ +package net.sf.briar.api.invitation; + +public interface InvitationWorkerFactory { + + Runnable createWorker(InvitationCallback callback, + InvitationParameters parameters); +} diff --git a/api/net/sf/briar/api/protocol/AuthorId.java b/api/net/sf/briar/api/protocol/AuthorId.java new file mode 100644 index 000000000..08b9f6976 --- /dev/null +++ b/api/net/sf/briar/api/protocol/AuthorId.java @@ -0,0 +1,36 @@ +package net.sf.briar.api.protocol; + +import java.util.Arrays; + +public class AuthorId { + + public static final int LENGTH = 32; + + public static final AuthorId SELF = new AuthorId(new byte[] { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 + }); + + private final byte[] id; + + public AuthorId(byte[] id) { + assert id.length == LENGTH; + this.id = id; + } + + public byte[] getBytes() { + return id; + } + + @Override + public boolean equals(Object o) { + if(o instanceof AuthorId) + return Arrays.equals(id, ((AuthorId) o).id); + return false; + } + + @Override + public int hashCode() { + return Arrays.hashCode(id); + } +} diff --git a/api/net/sf/briar/api/protocol/Batch.java b/api/net/sf/briar/api/protocol/Batch.java new file mode 100644 index 000000000..b7503e772 --- /dev/null +++ b/api/net/sf/briar/api/protocol/Batch.java @@ -0,0 +1,13 @@ +package net.sf.briar.api.protocol; + + +public interface Batch { + + public static final long CAPACITY = 1024L * 1024L; + + public void seal(); + BatchId getId(); + long getSize(); + Iterable getMessages(); + void addMessage(Message m); +} \ No newline at end of file diff --git a/api/net/sf/briar/api/protocol/BatchId.java b/api/net/sf/briar/api/protocol/BatchId.java new file mode 100644 index 000000000..1125c47af --- /dev/null +++ b/api/net/sf/briar/api/protocol/BatchId.java @@ -0,0 +1,31 @@ +package net.sf.briar.api.protocol; + +import java.util.Arrays; + +public class BatchId { + + public static final int LENGTH = 32; + + private final byte[] id; + + public BatchId(byte[] id) { + assert id.length == LENGTH; + this.id = id; + } + + public byte[] getBytes() { + return id; + } + + @Override + public boolean equals(Object o) { + if(o instanceof BatchId) + return Arrays.equals(id, ((BatchId) o).id); + return false; + } + + @Override + public int hashCode() { + return Arrays.hashCode(id); + } +} diff --git a/api/net/sf/briar/api/protocol/Bundle.java b/api/net/sf/briar/api/protocol/Bundle.java new file mode 100644 index 000000000..5bb55e455 --- /dev/null +++ b/api/net/sf/briar/api/protocol/Bundle.java @@ -0,0 +1,16 @@ +package net.sf.briar.api.protocol; + + +public interface Bundle { + + public void seal(); + BundleId getId(); + long getCapacity(); + long getSize(); + Iterable getAcks(); + void addAck(BatchId b); + Iterable getSubscriptions(); + void addSubscription(GroupId g); + Iterable getBatches(); + void addBatch(Batch b); +} diff --git a/api/net/sf/briar/api/protocol/BundleId.java b/api/net/sf/briar/api/protocol/BundleId.java new file mode 100644 index 000000000..9dba86d20 --- /dev/null +++ b/api/net/sf/briar/api/protocol/BundleId.java @@ -0,0 +1,36 @@ +package net.sf.briar.api.protocol; + +import java.util.Arrays; + +public class BundleId { + + public static final BundleId NONE = new BundleId(new byte[] { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }); + + public static final int LENGTH = 32; + + private final byte[] id; + + public BundleId(byte[] id) { + assert id.length == LENGTH; + this.id = id; + } + + public byte[] getBytes() { + return id; + } + + @Override + public boolean equals(Object o) { + if(o instanceof BundleId) + return Arrays.equals(id, ((BundleId) o).id); + return false; + } + + @Override + public int hashCode() { + return Arrays.hashCode(id); + } +} diff --git a/api/net/sf/briar/api/protocol/GroupId.java b/api/net/sf/briar/api/protocol/GroupId.java new file mode 100644 index 000000000..1ac038bbf --- /dev/null +++ b/api/net/sf/briar/api/protocol/GroupId.java @@ -0,0 +1,31 @@ +package net.sf.briar.api.protocol; + +import java.util.Arrays; + +public class GroupId { + + public static final int LENGTH = 32; + + private final byte[] id; + + public GroupId(byte[] id) { + assert id.length == LENGTH; + this.id = id; + } + + public byte[] getBytes() { + return id; + } + + @Override + public boolean equals(Object o) { + if(o instanceof GroupId) + return Arrays.equals(id, ((GroupId) o).id); + return false; + } + + @Override + public int hashCode() { + return Arrays.hashCode(id); + } +} diff --git a/api/net/sf/briar/api/protocol/Message.java b/api/net/sf/briar/api/protocol/Message.java new file mode 100644 index 000000000..31458e492 --- /dev/null +++ b/api/net/sf/briar/api/protocol/Message.java @@ -0,0 +1,13 @@ +package net.sf.briar.api.protocol; + + +public interface Message { + + MessageId getId(); + MessageId getParent(); + GroupId getGroup(); + AuthorId getAuthor(); + long getTimestamp(); + int getSize(); + byte[] getBody(); +} \ No newline at end of file diff --git a/api/net/sf/briar/api/protocol/MessageFactory.java b/api/net/sf/briar/api/protocol/MessageFactory.java new file mode 100644 index 000000000..33f0fdc43 --- /dev/null +++ b/api/net/sf/briar/api/protocol/MessageFactory.java @@ -0,0 +1,7 @@ +package net.sf.briar.api.protocol; + +public interface MessageFactory { + + Message createMessage(MessageId id, MessageId parent, GroupId group, + AuthorId author, long timestamp, byte[] body); +} diff --git a/api/net/sf/briar/api/protocol/MessageId.java b/api/net/sf/briar/api/protocol/MessageId.java new file mode 100644 index 000000000..7fb042a29 --- /dev/null +++ b/api/net/sf/briar/api/protocol/MessageId.java @@ -0,0 +1,36 @@ +package net.sf.briar.api.protocol; + +import java.util.Arrays; + +public class MessageId { + + public static final MessageId NONE = new MessageId(new byte[] { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }); + + public static final int LENGTH = 32; + + private final byte[] id; + + public MessageId(byte[] id) { + assert id.length == LENGTH; + this.id = id; + } + + public byte[] getBytes() { + return id; + } + + @Override + public boolean equals(Object o) { + if(o instanceof MessageId) + return Arrays.equals(id, ((MessageId) o).id); + return false; + } + + @Override + public int hashCode() { + return Arrays.hashCode(id); + } +} diff --git a/api/net/sf/briar/api/setup/SetupCallback.java b/api/net/sf/briar/api/setup/SetupCallback.java new file mode 100644 index 000000000..1c3767c00 --- /dev/null +++ b/api/net/sf/briar/api/setup/SetupCallback.java @@ -0,0 +1,22 @@ +package net.sf.briar.api.setup; + +import java.io.File; + +public interface SetupCallback { + + boolean isCancelled(); + + void extractingFile(File f); + + void copyingFile(File f); + + void installed(File f); + + void error(String message); + + void notFound(File f); + + void notDirectory(File f); + + void notAllowed(File f); +} diff --git a/api/net/sf/briar/api/setup/SetupParameters.java b/api/net/sf/briar/api/setup/SetupParameters.java new file mode 100644 index 000000000..9408e9b82 --- /dev/null +++ b/api/net/sf/briar/api/setup/SetupParameters.java @@ -0,0 +1,10 @@ +package net.sf.briar.api.setup; + +import java.io.File; + +public interface SetupParameters { + + File getChosenLocation(); + + String[] getBundledFontFilenames(); +} diff --git a/api/net/sf/briar/api/setup/SetupWorkerFactory.java b/api/net/sf/briar/api/setup/SetupWorkerFactory.java new file mode 100644 index 000000000..65b60580c --- /dev/null +++ b/api/net/sf/briar/api/setup/SetupWorkerFactory.java @@ -0,0 +1,6 @@ +package net.sf.briar.api.setup; + +public interface SetupWorkerFactory { + + Runnable createWorker(SetupCallback callback, SetupParameters parameters); +} diff --git a/build-common.xml b/build-common.xml new file mode 100644 index 000000000..dd1a59c5a --- /dev/null +++ b/build-common.xml @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/build.xml b/build.xml new file mode 100644 index 000000000..e1daec61b --- /dev/null +++ b/build.xml @@ -0,0 +1,3 @@ + + + diff --git a/components/.gitignore b/components/.gitignore new file mode 100644 index 000000000..796b96d1c --- /dev/null +++ b/components/.gitignore @@ -0,0 +1 @@ +/build diff --git a/components/build.xml b/components/build.xml new file mode 100644 index 000000000..88fdea5bf --- /dev/null +++ b/components/build.xml @@ -0,0 +1,3 @@ + + + diff --git a/components/net/sf/briar/db/Database.java b/components/net/sf/briar/db/Database.java new file mode 100644 index 000000000..29b048fd8 --- /dev/null +++ b/components/net/sf/briar/db/Database.java @@ -0,0 +1,114 @@ +package net.sf.briar.db; + +import java.util.Set; + +import net.sf.briar.api.db.DbException; +import net.sf.briar.api.db.NeighbourId; +import net.sf.briar.api.db.Rating; +import net.sf.briar.api.db.Status; +import net.sf.briar.api.protocol.AuthorId; +import net.sf.briar.api.protocol.BatchId; +import net.sf.briar.api.protocol.BundleId; +import net.sf.briar.api.protocol.GroupId; +import net.sf.briar.api.protocol.Message; +import net.sf.briar.api.protocol.MessageId; + +interface Database { + + void open(boolean resume) throws DbException; + + void close() throws DbException; + + T startTransaction(String name) throws DbException; + + void abortTransaction(T txn); + + void commitTransaction(T txn) throws DbException; + + // Locking: neighbours write + void addBatchToAck(T txn, NeighbourId n, BatchId b) throws DbException; + + // Locking: neighbours write + void addNeighbour(T txn, NeighbourId n) throws DbException; + + // Locking: neighbours write, messages read + void addOutstandingBatch(T txn, NeighbourId n, BatchId b, Set sent) throws DbException; + + // Locking: neighbours write, messages read + Set addReceivedBundle(T txn, NeighbourId n, BundleId b) throws DbException; + + // Locking: subscriptions write + void addSubscription(T txn, GroupId g) throws DbException; + + // Locking: neighbours write + void addSubscription(T txn, NeighbourId n, GroupId g) throws DbException; + + // Locking: neighbours write + void clearSubscriptions(T txn, NeighbourId n) throws DbException; + + // Locking: messages read + boolean containsMessage(T txn, MessageId m) throws DbException; + + // Locking: subscriptions read + boolean containsSubscription(T txn, GroupId g) throws DbException; + + // Locking: messages read + long getFreeSpace() throws DbException; + + // Locking: messages read + Message getMessage(T txn, MessageId m) throws DbException; + + // Locking: messages read + Iterable getMessagesByAuthor(T txn, AuthorId a) throws DbException; + + // Locking: messages read + Iterable getMessagesByParent(T txn, MessageId m) throws DbException; + + // Locking: neighbours read + Set getNeighbours(T txn) throws DbException; + + // Locking: messages read + Iterable getOldMessages(T txn, long size) throws DbException; + + // Locking: messages read + MessageId getParent(T txn, MessageId m) throws DbException; + + // Locking: ratings read + Rating getRating(T txn, AuthorId a) throws DbException; + + // Locking: messages read + int getSendability(T txn, MessageId m) throws DbException; + + // Locking: neighbours read, messages read + Iterable getSendableMessages(T txn, NeighbourId n, long capacity) throws DbException; + + // Locking: subscriptions read + Set getSubscriptions(T txn) throws DbException; + + // Locking: messages write + boolean addMessage(T txn, Message m) throws DbException; + + // Locking: ratings write + Rating setRating(T txn, AuthorId a, Rating r) throws DbException; + + // Locking: messages write + void setSendability(T txn, MessageId m, int sendability) throws DbException; + + // Locking: neighbours read, n write + Set removeBatchesToAck(T txn, NeighbourId n) throws DbException; + + // Locking: neighbours write, messages read + void removeLostBatch(T txn, NeighbourId n, BatchId b) throws DbException; + + // Locking: neighbours write, messages write + void removeMessage(T txn, MessageId m) throws DbException; + + // Locking: neighbours write + Set removeOutstandingBatch(T txn, NeighbourId n, BatchId b) throws DbException; + + // Locking: subscriptions write, neighbours write, messages write + void removeSubscription(T txn, GroupId g) throws DbException; + + // Locking: neighbours write, messages read + void setStatus(T txn, NeighbourId n, MessageId m, Status s) throws DbException; +} diff --git a/components/net/sf/briar/db/DatabaseComponentImpl.java b/components/net/sf/briar/db/DatabaseComponentImpl.java new file mode 100644 index 000000000..e0f447cdb --- /dev/null +++ b/components/net/sf/briar/db/DatabaseComponentImpl.java @@ -0,0 +1,209 @@ +package net.sf.briar.db; + +import net.sf.briar.api.db.DatabaseComponent; +import net.sf.briar.api.db.DbException; +import net.sf.briar.api.db.NeighbourId; +import net.sf.briar.api.db.Rating; +import net.sf.briar.api.db.Status; +import net.sf.briar.api.protocol.AuthorId; +import net.sf.briar.api.protocol.Batch; +import net.sf.briar.api.protocol.Message; +import net.sf.briar.api.protocol.MessageId; + +import com.google.inject.Provider; + +abstract class DatabaseComponentImpl implements DatabaseComponent { + + protected final Database db; + protected final Provider batchProvider; + + private final Object spaceLock = new Object(); + private final Object writeLock = new Object(); + private long bytesStoredSinceLastCheck = 0L; // Locking: spaceLock + private long timeOfLastCheck = 0L; // Locking: spaceLock + private volatile boolean writesAllowed = true; + + DatabaseComponentImpl(Database db, Provider batchProvider) { + this.db = db; + this.batchProvider = batchProvider; + startCleaner(); + } + + protected abstract void expireMessages(long size) throws DbException; + + // Locking: messages write + private int calculateSendability(Txn txn, Message m) throws DbException { + int sendability = 0; + // One point for a good rating + if(getRating(m.getAuthor()) == Rating.GOOD) sendability++; + // One point per sendable child (backward inclusion) + for(MessageId kid : db.getMessagesByParent(txn, m.getId())) { + Integer kidSendability = db.getSendability(txn, kid); + assert kidSendability != null; + if(kidSendability > 0) sendability++; + } + return sendability; + } + + private void checkFreeSpaceAndClean() throws DbException { + long freeSpace = db.getFreeSpace(); + while(freeSpace < MIN_FREE_SPACE) { + // If disk space is critical, disable the storage of new messages + if(freeSpace < CRITICAL_FREE_SPACE) { + System.out.println("Critical cleanup"); + writesAllowed = false; + } else { + System.out.println("Normal cleanup"); + } + expireMessages(BYTES_PER_SWEEP); + Thread.yield(); + freeSpace = db.getFreeSpace(); + // If disk space is no longer critical, re-enable writes + if(freeSpace >= CRITICAL_FREE_SPACE && !writesAllowed) { + writesAllowed = true; + synchronized(writeLock) { + writeLock.notifyAll(); + } + } + } + } + + // Locking: messages write, neighbours write + protected void removeMessage(Txn txn, MessageId id) throws DbException { + Integer sendability = db.getSendability(txn, id); + assert sendability != null; + if(sendability > 0) updateAncestorSendability(txn, id, false); + db.removeMessage(txn, id); + } + + private boolean shouldCheckFreeSpace() { + synchronized(spaceLock) { + long now = System.currentTimeMillis(); + if(bytesStoredSinceLastCheck > MAX_BYTES_BETWEEN_SPACE_CHECKS) { + System.out.println(bytesStoredSinceLastCheck + + " bytes stored since last check"); + bytesStoredSinceLastCheck = 0L; + timeOfLastCheck = now; + return true; + } + if(now - timeOfLastCheck > MAX_MS_BETWEEN_SPACE_CHECKS) { + System.out.println((now - timeOfLastCheck) + + " ms since last check"); + bytesStoredSinceLastCheck = 0L; + timeOfLastCheck = now; + return true; + } + } + return false; + } + + private void startCleaner() { + Runnable cleaner = new Runnable() { + public void run() { + try { + while(true) { + if(shouldCheckFreeSpace()) { + checkFreeSpaceAndClean(); + } else { + try { + Thread.sleep(CLEANER_SLEEP_MS); + } catch(InterruptedException ignored) {} + } + } + } catch(Throwable t) { + // FIXME: Work out what to do here + t.printStackTrace(); + System.exit(1); + } + } + }; + new Thread(cleaner).start(); + } + + // Locking: messages write, neighbours write + protected boolean storeMessage(Txn txn, Message m, NeighbourId sender) + throws DbException { + boolean added = db.addMessage(txn, m); + // Mark the message as seen by the sender + MessageId id = m.getId(); + if(sender != null) db.setStatus(txn, sender, id, Status.SEEN); + if(added) { + // Mark the message as unseen by other neighbours + for(NeighbourId n : db.getNeighbours(txn)) { + if(!n.equals(sender)) db.setStatus(txn, n, id, Status.NEW); + } + // Calculate and store the message's sendability + int sendability = calculateSendability(txn, m); + db.setSendability(txn, id, sendability); + if(sendability > 0) updateAncestorSendability(txn, id, true); + // Count the bytes stored + synchronized(spaceLock) { + bytesStoredSinceLastCheck += m.getSize(); + } + } + return added; + } + + // Locking: messages write + private int updateAncestorSendability(Txn txn, MessageId m, + boolean increment) throws DbException { + int affected = 0; + boolean changed = true; + while(changed) { + MessageId parent = db.getParent(txn, m); + if(parent.equals(MessageId.NONE)) break; + if(!db.containsMessage(txn, parent)) break; + Integer parentSendability = db.getSendability(txn, parent); + assert parentSendability != null; + if(increment) { + parentSendability++; + changed = parentSendability == 1; + if(changed) affected++; + } else { + assert parentSendability > 0; + parentSendability--; + changed = parentSendability == 0; + if(changed) affected++; + } + db.setSendability(txn, parent, parentSendability); + m = parent; + } + return affected; + } + + // Locking: messages write + protected void updateAuthorSendability(Txn txn, AuthorId a, + boolean increment) throws DbException { + int direct = 0, indirect = 0; + for(MessageId id : db.getMessagesByAuthor(txn, a)) { + int sendability = db.getSendability(txn, id); + if(increment) { + db.setSendability(txn, id, sendability + 1); + if(sendability == 0) { + direct++; + indirect += updateAncestorSendability(txn, id, true); + } + } else { + assert sendability > 0; + db.setSendability(txn, id, sendability - 1); + if(sendability == 1) { + direct++; + indirect += updateAncestorSendability(txn, id, false); + } + } + } + System.out.println(direct + " messages affected directly, " + + indirect + " indirectly"); + } + + protected void waitForPermissionToWrite() { + synchronized(writeLock) { + while(!writesAllowed) { + System.out.println("Waiting for permission to write"); + try { + writeLock.wait(); + } catch(InterruptedException ignored) {} + } + } + } +} diff --git a/components/net/sf/briar/db/DatabaseModule.java b/components/net/sf/briar/db/DatabaseModule.java new file mode 100644 index 000000000..1150323be --- /dev/null +++ b/components/net/sf/briar/db/DatabaseModule.java @@ -0,0 +1,22 @@ +package net.sf.briar.db; + +import net.sf.briar.api.crypto.Password; +import net.sf.briar.api.db.DatabaseComponent; +import net.sf.briar.api.db.DatabasePassword; + +import com.google.inject.AbstractModule; +import com.google.inject.Singleton; + +public class DatabaseModule extends AbstractModule { + + @Override + protected void configure() { + bind(Database.class).to(H2Database.class); + bind(DatabaseComponent.class).to(ReadWriteLockDatabaseComponent.class).in(Singleton.class); + bind(Password.class).annotatedWith(DatabasePassword.class).toInstance(new Password() { + public char[] getPassword() { + return "fixme fixme".toCharArray(); + } + }); + } +} diff --git a/components/net/sf/briar/db/H2Database.java b/components/net/sf/briar/db/H2Database.java new file mode 100644 index 000000000..4714b4ba0 --- /dev/null +++ b/components/net/sf/briar/db/H2Database.java @@ -0,0 +1,70 @@ +package net.sf.briar.db; + +import java.io.File; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.Arrays; +import java.util.Properties; + +import net.sf.briar.api.crypto.Password; +import net.sf.briar.api.db.DatabaseComponent; +import net.sf.briar.api.db.DatabasePassword; +import net.sf.briar.api.db.DbException; +import net.sf.briar.api.protocol.MessageFactory; +import net.sf.briar.util.FileUtils; + +import com.google.inject.Inject; + +class H2Database extends JdbcDatabase { + + private final Password password; + private final File home; + private final String url; + + @Inject + H2Database(MessageFactory messageFactory, + @DatabasePassword Password password) { + super(messageFactory, "BINARY(32)"); + this.password = password; + home = new File(FileUtils.getBriarDirectory(), "Data/db/db"); + url = "jdbc:h2:split:" + home.getPath() + + ";CIPHER=AES;DB_CLOSE_ON_EXIT=false"; + } + + public void open(boolean resume) throws DbException { + super.open(resume, home.getParentFile(), "org.h2.Driver"); + } + + public void close() throws DbException { + System.out.println("Closing database"); + try { + super.closeAllConnections(); + } catch(SQLException e) { + throw new DbException(e); + } + } + + public long getFreeSpace() throws DbException { + File dir = home.getParentFile(); + long free = dir.getFreeSpace(); + long used = getDiskSpace(dir); + long quota = DatabaseComponent.MAX_DB_SIZE - used; + long min = Math.min(free, quota); + System.out.println("Free space: " + min); + return min; + } + + @Override + protected Connection createConnection() throws SQLException { + Properties props = new Properties(); + props.setProperty("user", "b"); + char[] passwordArray = password.getPassword(); + props.put("password", passwordArray); + try { + return DriverManager.getConnection(url, props); + } finally { + Arrays.fill(passwordArray, (char) 0); + } + } +} diff --git a/components/net/sf/briar/db/JdbcDatabase.java b/components/net/sf/briar/db/JdbcDatabase.java new file mode 100644 index 000000000..79ac79f52 --- /dev/null +++ b/components/net/sf/briar/db/JdbcDatabase.java @@ -0,0 +1,1204 @@ +package net.sf.briar.db; + +import java.io.ByteArrayInputStream; +import java.io.File; +import java.sql.Blob; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Set; + +import net.sf.briar.api.db.DatabaseComponent; +import net.sf.briar.api.db.DbException; +import net.sf.briar.api.db.NeighbourId; +import net.sf.briar.api.db.Rating; +import net.sf.briar.api.db.Status; +import net.sf.briar.api.protocol.AuthorId; +import net.sf.briar.api.protocol.BatchId; +import net.sf.briar.api.protocol.BundleId; +import net.sf.briar.api.protocol.GroupId; +import net.sf.briar.api.protocol.Message; +import net.sf.briar.api.protocol.MessageFactory; +import net.sf.briar.api.protocol.MessageId; + +abstract class JdbcDatabase implements Database { + + private static final String CREATE_LOCAL_SUBSCRIPTIONS = + "CREATE TABLE localSubscriptions" + + " (groupId XXXX NOT NULL," + + " PRIMARY KEY (groupId))"; + + private static final String CREATE_MESSAGES = + "CREATE TABLE messages" + + " (messageId XXXX NOT NULL," + + " parentId XXXX NOT NULL," + + " groupId XXXX NOT NULL," + + " authorId XXXX NOT NULL," + + " timestamp BIGINT NOT NULL," + + " size INT NOT NULL," + + " body BLOB NOT NULL," + + " sendability INT NOT NULL," + + " PRIMARY KEY (messageId)," + + " FOREIGN KEY (groupId) REFERENCES localSubscriptions (groupId)" + + " ON DELETE CASCADE)"; + + private static final String INDEX_MESSAGES_BY_PARENT = + "CREATE INDEX messagesByParent ON messages (parentId)"; + + private static final String INDEX_MESSAGES_BY_AUTHOR = + "CREATE INDEX messagesByAuthor ON messages (authorId)"; + + private static final String INDEX_MESSAGES_BY_TIMESTAMP = + "CREATE INDEX messagesByTimestamp ON messages (timestamp)"; + + private static final String INDEX_MESSAGES_BY_SENDABILITY = + "CREATE INDEX messagesBySendability ON messages (sendability)"; + + private static final String CREATE_NEIGHBOURS = + "CREATE TABLE neighbours" + + " (neighbourId INT NOT NULL," + + " lastBundleReceived XXXX NOT NULL," + + " PRIMARY KEY (neighbourId))"; + + private static final String CREATE_BATCHES_TO_ACK = + "CREATE TABLE batchesToAck" + + " (batchId XXXX NOT NULL," + + " neighbourId INT NOT NULL," + + " PRIMARY KEY (batchId)," + + " FOREIGN KEY (neighbourId) REFERENCES neighbours (neighbourId)" + + " ON DELETE CASCADE)"; + + private static final String CREATE_NEIGHBOUR_SUBSCRIPTIONS = + "CREATE TABLE neighbourSubscriptions" + + " (neighbourId INT NOT NULL," + + " groupId XXXX NOT NULL," + + " PRIMARY KEY (neighbourId, groupId)," + + " FOREIGN KEY (neighbourId) REFERENCES neighbours (neighbourId)" + + " ON DELETE CASCADE)"; + + private static final String CREATE_OUTSTANDING_BATCHES = + "CREATE TABLE outstandingBatches" + + " (batchId XXXX NOT NULL," + + " neighbourId INT NOT NULL," + + " lastBundleReceived XXXX NOT NULL," + + " PRIMARY KEY (batchId)," + + " FOREIGN KEY (neighbourId) REFERENCES neighbours (neighbourId)" + + " ON DELETE CASCADE)"; + + private static final String CREATE_OUTSTANDING_MESSAGES = + "CREATE TABLE outstandingMessages" + + " (batchId XXXX NOT NULL," + + " neighbourId INT NOT NULL," + + " messageId XXXX NOT NULL," + + " PRIMARY KEY (batchId, messageId)," + + " FOREIGN KEY (batchId) REFERENCES outstandingBatches (batchId)" + + " ON DELETE CASCADE," + + " FOREIGN KEY (neighbourId) REFERENCES neighbours (neighbourId)" + + " ON DELETE CASCADE," + + " FOREIGN KEY (messageId) REFERENCES messages (messageId)" + + " ON DELETE CASCADE)"; + + private static final String INDEX_OUTSTANDING_MESSAGES_BY_BATCH = + "CREATE INDEX outstandingMessagesByBatch" + + " ON outstandingMessages (batchId)"; + + private static final String CREATE_RATINGS = + "CREATE TABLE ratings" + + " (authorId XXXX NOT NULL," + + " rating SMALLINT NOT NULL," + + " PRIMARY KEY (authorId))"; + + private static final String CREATE_RECEIVED_BUNDLES = + "CREATE TABLE receivedBundles" + + " (bundleId XXXX NOT NULL," + + " neighbourId INT NOT NULL," + + " timestamp BIGINT NOT NULL," + + " PRIMARY KEY (bundleId)," + + " FOREIGN KEY (neighbourId) REFERENCES neighbours (neighbourId)" + + " ON DELETE CASCADE)"; + + private static final String CREATE_STATUSES = + "CREATE TABLE statuses" + + " (messageId XXXX NOT NULL," + + " neighbourId INT NOT NULL," + + " status SMALLINT NOT NULL," + + " PRIMARY KEY (messageId, neighbourId)," + + " FOREIGN KEY (messageId) REFERENCES messages (messageId)" + + " ON DELETE CASCADE," + + " FOREIGN KEY (neighbourId) REFERENCES neighbours (neighbourId)" + + " ON DELETE CASCADE)"; + + private static final String INDEX_STATUSES_BY_MESSAGE = + "CREATE INDEX statusesByMessage ON statuses (messageId)"; + + private static final String INDEX_STATUSES_BY_NEIGHBOUR = + "CREATE INDEX statusesByNeighbour ON statuses (neighbourId)"; + + private final MessageFactory messageFactory; + private final String hashType; + private final LinkedList connections = + new LinkedList(); // Locking: self + + private volatile int openConnections = 0; // Locking: connections + private volatile boolean closed = false; // Locking: connections + + protected abstract Connection createConnection() throws SQLException; + + JdbcDatabase(MessageFactory messageFactory, String hashType) { + this.messageFactory = messageFactory; + this.hashType = hashType; + } + + protected void open(boolean resume, File dir, String driverClass) + throws DbException { + if(resume) { + assert dir.exists(); + assert dir.isDirectory(); + System.out.println("Resuming from " + dir.getPath()); + } else { + if(dir.exists()) delete(dir); + } + try { + Class.forName(driverClass); + } catch(ClassNotFoundException e) { + throw new DbException(e); + } + Connection txn = startTransaction("initialize"); + try { + // If not resuming, create the tables + if(resume) + System.out.println(getNumberOfMessages(txn) + " messages"); + else createTables(txn); + commitTransaction(txn); + } catch(DbException e) { + abortTransaction(txn); + throw e; + } + } + + private void delete(File f) { + if(f.isDirectory()) for(File child : f.listFiles()) delete(child); + System.out.println("Deleting " + f.getPath()); + f.delete(); + } + + private void createTables(Connection txn) throws DbException { + Statement s = null; + try { + s = txn.createStatement(); + System.out.println("Creating localSubscriptions table"); + s.executeUpdate(insertHashType(CREATE_LOCAL_SUBSCRIPTIONS)); + System.out.println("Creating messages table"); + s.executeUpdate(insertHashType(CREATE_MESSAGES)); + s.executeUpdate(INDEX_MESSAGES_BY_PARENT); + s.executeUpdate(INDEX_MESSAGES_BY_AUTHOR); + s.executeUpdate(INDEX_MESSAGES_BY_TIMESTAMP); + s.executeUpdate(INDEX_MESSAGES_BY_SENDABILITY); + System.out.println("Creating neighbours table"); + s.executeUpdate(insertHashType(CREATE_NEIGHBOURS)); + System.out.println("Creating batchesToAck table"); + s.executeUpdate(insertHashType(CREATE_BATCHES_TO_ACK)); + System.out.println("Creating neighbourSubscriptions table"); + s.executeUpdate(insertHashType(CREATE_NEIGHBOUR_SUBSCRIPTIONS)); + System.out.println("Creating outstandingBatches table"); + s.executeUpdate(insertHashType(CREATE_OUTSTANDING_BATCHES)); + System.out.println("Creating outstandingMessages table"); + s.executeUpdate(insertHashType(CREATE_OUTSTANDING_MESSAGES)); + s.executeUpdate(INDEX_OUTSTANDING_MESSAGES_BY_BATCH); + System.out.println("Creating ratings table"); + s.executeUpdate(insertHashType(CREATE_RATINGS)); + System.out.println("Creating receivedBundles table"); + s.executeUpdate(insertHashType(CREATE_RECEIVED_BUNDLES)); + System.out.println("Creating statuses table"); + s.executeUpdate(insertHashType(CREATE_STATUSES)); + s.executeUpdate(INDEX_STATUSES_BY_MESSAGE); + s.executeUpdate(INDEX_STATUSES_BY_NEIGHBOUR); + s.close(); + } catch(SQLException e) { + tryToClose(s); + tryToClose(txn); + throw new DbException(e); + } + } + + // FIXME: Get rid of this if we're definitely not using Derby + private String insertHashType(String s) { + return s.replaceAll("XXXX", hashType); + } + + private void tryToClose(Connection c) { + if(c != null) try { + c.close(); + } catch(SQLException ignored) {} + } + + private void tryToClose(Statement s) { + if(s != null) try { + s.close(); + } catch(SQLException ignored) {} + } + + private void tryToClose(ResultSet rs) { + if(rs != null) try { + rs.close(); + } catch(SQLException ignored) {} + } + + public Connection startTransaction(String name) throws DbException { + Connection txn = null; + try { + synchronized(connections) { + // If the database has been closed, don't return + while(closed) { + try { + connections.wait(); + } catch(InterruptedException ignored) {} + } + txn = connections.poll(); + } + if(txn == null) { + txn = createConnection(); + assert txn != null; + synchronized(connections) { + openConnections++; + System.out.println(openConnections + " open connections"); + } + } + txn.setAutoCommit(false); + return txn; + } catch(SQLException e) { + tryToClose(txn); + throw new DbException(e); + } + } + + public void abortTransaction(Connection txn) { + try { + txn.rollback(); + txn.setAutoCommit(true); + synchronized(connections) { + connections.add(txn); + connections.notifyAll(); + } + } catch(SQLException e) { + tryToClose(txn); + } + } + + public void commitTransaction(Connection txn) throws DbException { + try { + txn.commit(); + txn.setAutoCommit(true); + synchronized(connections) { + connections.add(txn); + connections.notifyAll(); + } + } catch(SQLException e) { + tryToClose(txn); + throw new DbException(e); + } + } + + protected void closeAllConnections() throws SQLException { + synchronized(connections) { + closed = true; + for(Connection c : connections) c.close(); + openConnections -= connections.size(); + connections.clear(); + while(openConnections > 0) { + System.out.println("Waiting for " + openConnections + + " open connections"); + try { + connections.wait(); + } catch(InterruptedException ignored) {} + for(Connection c : connections) c.close(); + openConnections -= connections.size(); + connections.clear(); + } + } + } + + public void addBatchToAck(Connection txn, NeighbourId n, BatchId b) + throws DbException { + PreparedStatement ps = null; + try { + String sql = "INSERT INTO batchesToAck" + + " (batchId, neighbourId)" + + " VALUES (?, ?)"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, b.getBytes()); + ps.setInt(2, n.getInt()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } catch(SQLException e) { + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public boolean addMessage(Connection txn, Message m) throws DbException { + if(containsMessage(txn, m.getId())) return false; + PreparedStatement ps = null; + try { + String sql = "INSERT INTO messages" + + " (messageId, parentId, groupId, authorId, timestamp, size," + + " body, sendability)" + + " VALUES (?, ?, ?, ?, ?, ?, ?, ?)"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, m.getId().getBytes()); + ps.setBytes(2, m.getParent().getBytes()); + ps.setBytes(3, m.getGroup().getBytes()); + ps.setBytes(4, m.getAuthor().getBytes()); + ps.setLong(5, m.getTimestamp()); + ps.setInt(6, m.getSize()); + ps.setBlob(7, new ByteArrayInputStream(m.getBody())); + ps.setInt(8, 0); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + return true; + } catch(SQLException e) { + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public void addNeighbour(Connection txn, NeighbourId n) throws DbException { + PreparedStatement ps = null; + try { + String sql = "INSERT INTO neighbours" + + " (neighbourId, lastBundleReceived)" + + " VALUES (?, ?)"; + ps = txn.prepareStatement(sql); + ps.setInt(1, n.getInt()); + ps.setBytes(2, BundleId.NONE.getBytes()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } catch(SQLException e) { + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public void addOutstandingBatch(Connection txn, NeighbourId n, BatchId b, + Set sent) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + // Find the ID of the last bundle received from n + String sql = "SELECT lastBundleReceived FROM neighbours" + + " WHERE neighbourId = ?"; + ps = txn.prepareStatement(sql); + ps.setInt(1, n.getInt()); + rs = ps.executeQuery(); + boolean found = rs.next(); + assert found; + byte[] lastBundleReceived = rs.getBytes(1); + boolean more = rs.next(); + assert !more; + rs.close(); + ps.close(); + // Create an outstanding batch row + sql = "INSERT INTO outstandingBatches" + + " (batchId, neighbourId, lastBundleReceived)" + + " VALUES (?, ?, ?)"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, b.getBytes()); + ps.setInt(2, n.getInt()); + ps.setBytes(3, lastBundleReceived); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + // Create an outstanding message row for each message in the batch + sql = "INSERT INTO outstandingMessages" + + " (batchId, neighbourId, messageId)" + + " VALUES (?, ?, ?)"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, b.getBytes()); + ps.setInt(2, n.getInt()); + for(MessageId m : sent) { + ps.setBytes(3, m.getBytes()); + ps.addBatch(); + } + int[] rowsAffected1 = ps.executeBatch(); + assert rowsAffected1.length == sent.size(); + for(int i = 0; i < rowsAffected1.length; i++) { + assert rowsAffected1[i] == 1; + } + ps.close(); + // Set the status of each message in the batch to SENT + sql = "UPDATE statuses SET status = ?" + + " WHERE messageId = ? AND neighbourId = ? AND status = ?"; + ps = txn.prepareStatement(sql); + ps.setShort(1, (short) Status.SENT.ordinal()); + ps.setInt(3, n.getInt()); + ps.setShort(4, (short) Status.NEW.ordinal()); + for(MessageId m : sent) { + ps.setBytes(2, m.getBytes()); + ps.addBatch(); + } + rowsAffected1 = ps.executeBatch(); + assert rowsAffected1.length == sent.size(); + for(int i = 0; i < rowsAffected1.length; i++) { + assert rowsAffected1[i] <= 1; + } + ps.close(); + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public Set addReceivedBundle(Connection txn, NeighbourId n, + BundleId b) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + // Update the ID of the last bundle received from n + String sql = "UPDATE neighbours SET lastBundleReceived = ?" + + " WHERE neighbourId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, b.getBytes()); + ps.setInt(2, n.getInt()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + // Count the received bundle records for n and find the oldest + sql = "SELECT bundleId, timestamp FROM receivedBundles" + + " WHERE neighbourId = ?"; + ps = txn.prepareStatement(sql); + ps.setInt(1, n.getInt()); + rs = ps.executeQuery(); + int received = 0; + long oldestTimestamp = Long.MAX_VALUE; + byte[] oldestBundle = null; + while(rs.next()) { + received++; + byte[] bundle = rs.getBytes(1); + long timestamp = rs.getLong(2); + if(timestamp < oldestTimestamp) { + oldestTimestamp = timestamp; + oldestBundle = bundle; + } + } + rs.close(); + ps.close(); + Set lost; + if(received == DatabaseComponent.RETRANSMIT_THRESHOLD) { + // Expire batches related to the oldest received bundle + assert oldestBundle != null; + lost = findLostBatches(txn, n, oldestBundle); + sql = "DELETE FROM receivedBundles WHERE bundleId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, oldestBundle); + rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } else { + lost = Collections.emptySet(); + } + // Record the new received bundle + sql = "INSERT INTO receivedBundles" + + " (bundleId, neighbourId, timestamp)" + + " VALUES (?, ?, ?)"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, b.getBytes()); + ps.setInt(2, n.getInt()); + ps.setLong(3, System.currentTimeMillis()); + rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + return lost; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + private Set findLostBatches(Connection txn, NeighbourId n, + byte[] lastBundleReceived) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT batchId FROM outstandingBatches" + + " WHERE neighbourId = ? AND lastBundleReceived = ?"; + ps = txn.prepareStatement(sql); + ps.setInt(1, n.getInt()); + ps.setBytes(2, lastBundleReceived); + rs = ps.executeQuery(); + Set lost = new HashSet(); + while(rs.next()) lost.add(new BatchId(rs.getBytes(1))); + rs.close(); + ps.close(); + return lost; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public void addSubscription(Connection txn, GroupId g) throws DbException { + PreparedStatement ps = null; + try { + String sql = "INSERT INTO localSubscriptions (groupId) VALUES (?)"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, g.getBytes()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } catch(SQLException e) { + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public void addSubscription(Connection txn, NeighbourId n, GroupId g) + throws DbException { + PreparedStatement ps = null; + try { + String sql = "INSERT INTO neighbourSubscriptions" + + " (neighbourId, groupId)" + + " VALUES (?, ?)"; + ps = txn.prepareStatement(sql); + ps.setInt(1, n.getInt()); + ps.setBytes(2, g.getBytes()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } catch(SQLException e) { + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public void clearSubscriptions(Connection txn, NeighbourId n) + throws DbException { + PreparedStatement ps = null; + try { + String sql = "DELETE FROM neighbourSubscriptions" + + " WHERE neighbourId = ?"; + ps = txn.prepareStatement(sql); + ps.setInt(1, n.getInt()); + ps.executeUpdate(); + ps.close(); + } catch(SQLException e) { + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public boolean containsMessage(Connection txn, MessageId m) + throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT COUNT(messageId) FROM messages" + + " WHERE messageId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, m.getBytes()); + rs = ps.executeQuery(); + boolean found = rs.next(); + assert found; + int count = rs.getInt(1); + assert count <= 1; + boolean more = rs.next(); + assert !more; + rs.close(); + ps.close(); + return count > 0; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public boolean containsSubscription(Connection txn, GroupId g) + throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT COUNT(groupId) FROM localSubscriptions" + + " WHERE groupId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, g.getBytes()); + rs = ps.executeQuery(); + boolean found = rs.next(); + assert found; + int count = rs.getInt(1); + assert count <= 1; + boolean more = rs.next(); + assert !more; + rs.close(); + ps.close(); + return count > 0; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + protected long getDiskSpace(File f) { + long total = 0L; + if(f.isDirectory()) { + for(File child : f.listFiles()) total += getDiskSpace(child); + return total; + } else return f.length(); + } + + public Message getMessage(Connection txn, MessageId m) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = + "SELECT parentId, groupId, authorId, timestamp, size, body" + + " FROM messages WHERE messageId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, m.getBytes()); + rs = ps.executeQuery(); + boolean found = rs.next(); + assert found; + MessageId parent = new MessageId(rs.getBytes(1)); + GroupId group = new GroupId(rs.getBytes(2)); + AuthorId author = new AuthorId(rs.getBytes(3)); + long timestamp = rs.getLong(4); + int size = rs.getInt(5); + Blob b = rs.getBlob(6); + byte[] body = b.getBytes(1, size); + assert body.length == size; + boolean more = rs.next(); + assert !more; + rs.close(); + ps.close(); + return messageFactory.createMessage(m, parent, group, author, + timestamp, body); + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public Iterable getMessagesByAuthor(Connection txn, AuthorId a) + throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT messageId FROM messages WHERE authorId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, a.getBytes()); + rs = ps.executeQuery(); + List ids = new ArrayList(); + while(rs.next()) ids.add(new MessageId(rs.getBytes(1))); + rs.close(); + ps.close(); + return ids; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public Iterable getMessagesByParent(Connection txn, MessageId m) + throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT messageId FROM messages WHERE parentId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, m.getBytes()); + rs = ps.executeQuery(); + List ids = new ArrayList(); + while(rs.next()) ids.add(new MessageId(rs.getBytes(1))); + rs.close(); + ps.close(); + return ids; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public Set getNeighbours(Connection txn) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT neighbourId FROM neighbours"; + ps = txn.prepareStatement(sql); + rs = ps.executeQuery(); + Set ids = new HashSet(); + while(rs.next()) ids.add(new NeighbourId(rs.getInt(1))); + rs.close(); + ps.close(); + return ids; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public int getNumberOfMessages(Connection txn) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT COUNT(messageId) FROM messages"; + ps = txn.prepareStatement(sql); + rs = ps.executeQuery(); + boolean found = rs.next(); + assert found; + int count = rs.getInt(1); + boolean more = rs.next(); + assert !more; + rs.close(); + ps.close(); + return count; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public Iterable getOldMessages(Connection txn, long capacity) + throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT size, messageId FROM messages" + + " ORDER BY timestamp"; + ps = txn.prepareStatement(sql); + rs = ps.executeQuery(); + List ids = new ArrayList(); + long total = 0L; + while(rs.next()) { + int size = rs.getInt(1); + if(total + size > capacity) break; + ids.add(new MessageId(rs.getBytes(2))); + total += size; + } + rs.close(); + ps.close(); + System.out.println(ids.size() + " old messages, " + total + + " bytes"); + return ids; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public MessageId getParent(Connection txn, MessageId m) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT parentId FROM messages WHERE messageId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, m.getBytes()); + rs = ps.executeQuery(); + boolean found = rs.next(); + assert found; + byte[] parent = rs.getBytes(1); + boolean more = rs.next(); + assert !more; + rs.close(); + ps.close(); + return new MessageId(parent); + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public Rating getRating(Connection txn, AuthorId a) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT rating FROM ratings WHERE authorId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, a.getBytes()); + rs = ps.executeQuery(); + Rating r; + if(rs.next()) r = Rating.values()[rs.getByte(1)]; + else r = Rating.UNRATED; + boolean more = rs.next(); + assert !more; + rs.close(); + ps.close(); + return r; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public int getSendability(Connection txn, MessageId m) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT sendability FROM messages WHERE messageId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, m.getBytes()); + rs = ps.executeQuery(); + boolean found = rs.next(); + assert found; + int sendability = rs.getInt(1); + boolean more = rs.next(); + assert !more; + rs.close(); + ps.close(); + return sendability; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public Iterable getSendableMessages(Connection txn, + NeighbourId n, long capacity) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT size, messages.messageId FROM messages" + + " JOIN neighbourSubscriptions" + + " ON messages.groupId = neighbourSubscriptions.groupId" + + " JOIN statuses ON messages.messageId = statuses.messageId" + + " WHERE neighbourSubscriptions.neighbourId = ?" + + " AND statuses.neighbourId = ? AND status = ?"; + ps = txn.prepareStatement(sql); + ps.setInt(1, n.getInt()); + ps.setInt(2, n.getInt()); + ps.setShort(3, (short) Status.NEW.ordinal()); + rs = ps.executeQuery(); + List ids = new ArrayList(); + long total = 0; + while(rs.next()) { + int size = rs.getInt(1); + if(total + size > capacity) break; + ids.add(new MessageId(rs.getBytes(2))); + total += size; + } + rs.close(); + ps.close(); + if(!ids.isEmpty()) { + System.out.println(ids.size() + " sendable messages, " + total + + " bytes"); + } + return ids; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public Set getSubscriptions(Connection txn) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT groupId FROM localSubscriptions"; + ps = txn.prepareStatement(sql); + rs = ps.executeQuery(); + Set ids = new HashSet(); + while(rs.next()) ids.add(new GroupId(rs.getBytes(1))); + rs.close(); + ps.close(); + return ids; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public Set removeBatchesToAck(Connection txn, NeighbourId n) + throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT batchId FROM batchesToAck" + + " WHERE neighbourId = ?"; + ps = txn.prepareStatement(sql); + ps.setInt(1, n.getInt()); + rs = ps.executeQuery(); + Set ids = new HashSet(); + while(rs.next()) ids.add(new BatchId(rs.getBytes(1))); + rs.close(); + ps.close(); + sql = "DELETE FROM batchesToAck WHERE neighbourId = ?"; + ps = txn.prepareStatement(sql); + ps.setInt(1, n.getInt()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == ids.size(); + ps.close(); + return ids; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public void removeLostBatch(Connection txn, NeighbourId n, BatchId b) + throws DbException { + PreparedStatement ps = null, ps1 = null; + ResultSet rs = null; + try { + String sql = "SELECT messageId FROM outstandingMessages" + + " WHERE neighbourId = ? AND batchId = ?"; + ps = txn.prepareStatement(sql); + ps.setInt(1, n.getInt()); + ps.setBytes(2, b.getBytes()); + rs = ps.executeQuery(); + sql = "UPDATE statuses SET status = ?" + + " WHERE messageId = ? AND neighbourId = ? AND status = ?"; + ps1 = txn.prepareStatement(sql); + ps1.setShort(1, (short) Status.NEW.ordinal()); + ps1.setInt(3, n.getInt()); + ps1.setShort(4, (short) Status.SENT.ordinal()); + int messages = 0; + while(rs.next()) { + messages++; + ps1.setBytes(2, rs.getBytes(1)); + ps1.addBatch(); + } + rs.close(); + ps.close(); + int[] rowsAffected = ps1.executeBatch(); + assert rowsAffected.length == messages; + for(int i = 0; i < rowsAffected.length; i++) { + assert rowsAffected[i] <= 1; + } + ps1.close(); + sql = "DELETE FROM outstandingBatches WHERE batchId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, b.getBytes()); + int rowsAffected1 = ps.executeUpdate(); + assert rowsAffected1 <= 1; + ps.close(); + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(ps1); + tryToClose(txn); + throw new DbException(e); + } + } + + public void removeMessage(Connection txn, MessageId m) throws DbException { + PreparedStatement ps = null; + try { + String sql = "DELETE FROM messages WHERE messageId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, m.getBytes()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } catch(SQLException e) { + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public Set removeOutstandingBatch(Connection txn, NeighbourId n, + BatchId b) throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT messageId FROM outstandingMessages" + + " WHERE neighbourId = ? AND batchId = ?"; + ps = txn.prepareStatement(sql); + ps.setInt(1, n.getInt()); + ps.setBytes(2, b.getBytes()); + rs = ps.executeQuery(); + Set messages = new HashSet(); + while(rs.next()) messages.add(new MessageId(rs.getBytes(1))); + rs.close(); + ps.close(); + sql = "DELETE FROM outstandingBatches WHERE batchId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, b.getBytes()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected <= 1; + ps.close(); + return messages.isEmpty() ? null : messages; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public void removeSubscription(Connection txn, GroupId g) + throws DbException { + PreparedStatement ps = null; + try { + String sql = "DELETE FROM localSubscriptions WHERE groupId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, g.getBytes()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } catch(SQLException e) { + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public Rating setRating(Connection txn, AuthorId a, Rating r) + throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT rating FROM ratings WHERE authorId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, a.getBytes()); + rs = ps.executeQuery(); + Rating old; + if(rs.next()) { + old = Rating.values()[rs.getByte(1)]; + boolean more = rs.next(); + assert !more; + rs.close(); + ps.close(); + sql = "UPDATE ratings SET rating = ? WHERE authorId = ?"; + ps = txn.prepareStatement(sql); + ps.setShort(1, (short) r.ordinal()); + ps.setBytes(2, a.getBytes()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } else { + rs.close(); + ps.close(); + old = Rating.UNRATED; + sql = "INSERT INTO ratings (authorId, rating) VALUES (?, ?)"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, a.getBytes()); + ps.setShort(2, (short) r.ordinal()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } + return old; + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public void setSendability(Connection txn, MessageId m, int sendability) + throws DbException { + PreparedStatement ps = null; + try { + String sql = "UPDATE messages SET sendability = ?" + + " WHERE messageId = ?"; + ps = txn.prepareStatement(sql); + ps.setInt(1, sendability); + ps.setBytes(2, m.getBytes()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } catch(SQLException e) { + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } + + public void setStatus(Connection txn, NeighbourId n, MessageId m, Status s) + throws DbException { + PreparedStatement ps = null; + ResultSet rs = null; + try { + String sql = "SELECT status FROM statuses" + + " WHERE messageId = ? AND neighbourId = ?"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, m.getBytes()); + ps.setInt(2, n.getInt()); + rs = ps.executeQuery(); + if(rs.next()) { + Status old = Status.values()[rs.getByte(1)]; + boolean more = rs.next(); + assert !more; + rs.close(); + ps.close(); + if(!old.equals(Status.SEEN) && !old.equals(s)) { + sql = "UPDATE statuses SET status = ?" + + " WHERE messageId = ? AND neighbourId = ?"; + ps = txn.prepareStatement(sql); + ps.setShort(1, (short) s.ordinal()); + ps.setBytes(2, m.getBytes()); + ps.setInt(3, n.getInt()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } + } else { + rs.close(); + ps.close(); + sql = "INSERT INTO statuses (messageId, neighbourId, status)" + + " VALUES (?, ?, ?)"; + ps = txn.prepareStatement(sql); + ps.setBytes(1, m.getBytes()); + ps.setInt(2, n.getInt()); + ps.setShort(3, (short) s.ordinal()); + int rowsAffected = ps.executeUpdate(); + assert rowsAffected == 1; + ps.close(); + } + } catch(SQLException e) { + tryToClose(rs); + tryToClose(ps); + tryToClose(txn); + throw new DbException(e); + } + } +} diff --git a/components/net/sf/briar/db/ReadWriteLockDatabaseComponent.java b/components/net/sf/briar/db/ReadWriteLockDatabaseComponent.java new file mode 100644 index 000000000..1b5f7b100 --- /dev/null +++ b/components/net/sf/briar/db/ReadWriteLockDatabaseComponent.java @@ -0,0 +1,497 @@ +package net.sf.briar.db; + +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; +import java.util.concurrent.locks.ReentrantReadWriteLock; + +import net.sf.briar.api.db.DbException; +import net.sf.briar.api.db.NeighbourId; +import net.sf.briar.api.db.Rating; +import net.sf.briar.api.db.Status; +import net.sf.briar.api.protocol.AuthorId; +import net.sf.briar.api.protocol.Batch; +import net.sf.briar.api.protocol.BatchId; +import net.sf.briar.api.protocol.Bundle; +import net.sf.briar.api.protocol.GroupId; +import net.sf.briar.api.protocol.Message; +import net.sf.briar.api.protocol.MessageId; + +import com.google.inject.Inject; +import com.google.inject.Provider; + +class ReadWriteLockDatabaseComponent extends DatabaseComponentImpl { + + /* + * Locks must always be acquired in alphabetical order. See the Database + * interface to find out which calls require which locks. Note: this + * implementation can allow writers to starve. + */ + + private final ReentrantReadWriteLock messageLock = + new ReentrantReadWriteLock(true); + private final ReentrantReadWriteLock neighbourLock = + new ReentrantReadWriteLock(true); + private final ReentrantReadWriteLock ratingLock = + new ReentrantReadWriteLock(true); + private final ReentrantReadWriteLock subscriptionLock = + new ReentrantReadWriteLock(true); + + @Inject + ReadWriteLockDatabaseComponent(Database db, + Provider batchProvider) { + super(db, batchProvider); + } + + protected void expireMessages(long size) throws DbException { + messageLock.writeLock().lock(); + try { + neighbourLock.writeLock().lock(); + try { + Txn txn = db.startTransaction("cleaner"); + try { + for(MessageId m : db.getOldMessages(txn, size)) { + removeMessage(txn, m); + } + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + neighbourLock.writeLock().unlock(); + } + } finally { + messageLock.writeLock().unlock(); + } + } + + public void close() throws DbException { + messageLock.writeLock().lock(); + try { + neighbourLock.writeLock().lock(); + try { + ratingLock.writeLock().lock(); + try { + subscriptionLock.writeLock().lock(); + try { + db.close(); + } finally { + subscriptionLock.writeLock().unlock(); + } + } finally { + ratingLock.writeLock().unlock(); + } + } finally { + neighbourLock.writeLock().unlock(); + } + } finally { + messageLock.writeLock().unlock(); + } + } + + public void addNeighbour(NeighbourId n) throws DbException { + System.out.println("Adding neighbour " + n); + neighbourLock.writeLock().lock(); + try { + Txn txn = db.startTransaction("addNeighbour"); + try { + db.addNeighbour(txn, n); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + neighbourLock.writeLock().unlock(); + } + } + + public void addLocallyGeneratedMessage(Message m) throws DbException { + waitForPermissionToWrite(); + messageLock.writeLock().lock(); + try { + neighbourLock.writeLock().lock(); + try { + subscriptionLock.readLock().lock(); + try { + Txn txn = db.startTransaction("addLocallyGeneratedMessage"); + try { + if(db.containsSubscription(txn, m.getGroup())) { + boolean added = storeMessage(txn, m, null); + assert added; + } else { + System.out.println("Not subscribed"); + } + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + subscriptionLock.readLock().unlock(); + } + } finally { + neighbourLock.writeLock().unlock(); + } + } finally { + messageLock.writeLock().unlock(); + } + } + + public Rating getRating(AuthorId a) throws DbException { + ratingLock.readLock().lock(); + try { + Txn txn = db.startTransaction("getRating"); + try { + Rating r = db.getRating(txn, a); + db.commitTransaction(txn); + return r; + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + ratingLock.readLock().unlock(); + } + } + + public void setRating(AuthorId a, Rating r) throws DbException { + messageLock.writeLock().lock(); + try { + ratingLock.writeLock().lock(); + try { + Txn txn = db.startTransaction("setRating"); + try { + Rating old = db.setRating(txn, a, r); + // Update the sendability of the author's messages + if(r == Rating.GOOD && old != Rating.GOOD) + updateAuthorSendability(txn, a, true); + else if(r != Rating.GOOD && old == Rating.GOOD) + updateAuthorSendability(txn, a, false); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + ratingLock.writeLock().unlock(); + } + } finally { + messageLock.writeLock().unlock(); + } + } + + public Set getSubscriptions() throws DbException { + subscriptionLock.readLock().lock(); + try { + Txn txn = db.startTransaction("getSubscriptions"); + try { + HashSet subs = new HashSet(); + for(GroupId g : db.getSubscriptions(txn)) subs.add(g); + db.commitTransaction(txn); + return subs; + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + subscriptionLock.readLock().unlock(); + } + } + + public void subscribe(GroupId g) throws DbException { + System.out.println("Subscribing to " + g); + subscriptionLock.writeLock().lock(); + try { + Txn txn = db.startTransaction("subscribe"); + try { + db.addSubscription(txn, g); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + subscriptionLock.writeLock().unlock(); + } + } + + public void unsubscribe(GroupId g) throws DbException { + System.out.println("Unsubscribing from " + g); + messageLock.writeLock().lock(); + try { + neighbourLock.writeLock().lock(); + try { + subscriptionLock.writeLock().lock(); + try { + Txn txn = db.startTransaction("unsubscribe"); + try { + db.removeSubscription(txn, g); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + subscriptionLock.writeLock().unlock(); + } + } finally { + neighbourLock.writeLock().unlock(); + } + } finally { + messageLock.writeLock().unlock(); + } + } + + public void generateBundle(NeighbourId n, Bundle b) throws DbException { + System.out.println("Generating bundle for " + n); + // Ack all batches received from the neighbour + neighbourLock.writeLock().lock(); + try { + Txn txn = db.startTransaction("generateBundle:acks"); + try { + int numAcks = 0; + for(BatchId ack : db.removeBatchesToAck(txn, n)) { + b.addAck(ack); + numAcks++; + } + System.out.println("Added " + numAcks + " acks"); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + neighbourLock.writeLock().unlock(); + } + // Add a list of subscriptions + subscriptionLock.readLock().lock(); + try { + Txn txn = db.startTransaction("generateBundle:subscriptions"); + try { + int numSubs = 0; + for(GroupId g : db.getSubscriptions(txn)) { + b.addSubscription(g); + numSubs++; + } + System.out.println("Added " + numSubs + " subscriptions"); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + subscriptionLock.readLock().unlock(); + } + // Add as many messages as possible to the bundle + long capacity = b.getCapacity(); + while(true) { + Batch batch = fillBatch(n, capacity); + if(batch == null) break; // No more messages to send + b.addBatch(batch); + capacity -= batch.getSize(); + // If the batch is less than half full, stop trying - there may be + // more messages trickling in but we can't wait forever + if(batch.getSize() * 2 < Batch.CAPACITY) break; + } + b.seal(); + System.out.println("Bundle sent, " + b.getSize() + " bytes"); + System.gc(); + } + + private Batch fillBatch(NeighbourId n, long capacity) throws DbException { + messageLock.readLock().lock(); + try { + Set sent; + Batch b; + neighbourLock.readLock().lock(); + try { + Txn txn = db.startTransaction("fillBatch:read"); + try { + capacity = Math.min(capacity, Batch.CAPACITY); + Iterator it = + db.getSendableMessages(txn, n, capacity).iterator(); + if(!it.hasNext()) { + db.commitTransaction(txn); + return null; // No more messages to send + } + sent = new HashSet(); + b = batchProvider.get(); + while(it.hasNext()) { + MessageId m = it.next(); + b.addMessage(db.getMessage(txn, m)); + sent.add(m); + } + b.seal(); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + neighbourLock.readLock().unlock(); + } + // Record the contents of the batch + neighbourLock.writeLock().lock(); + try { + Txn txn = db.startTransaction("fillBatch:write"); + try { + assert !sent.isEmpty(); + db.addOutstandingBatch(txn, n, b.getId(), sent); + db.commitTransaction(txn); + return b; + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + neighbourLock.writeLock().unlock(); + } + } finally { + messageLock.readLock().unlock(); + } + } + + public void receiveBundle(NeighbourId n, Bundle b) throws DbException { + System.out.println("Received bundle from " + n + ", " + + b.getSize() + " bytes"); + // Mark all messages in acked batches as seen + messageLock.readLock().lock(); + try { + neighbourLock.writeLock().lock(); + try { + int acks = 0, expired = 0; + for(BatchId ack : b.getAcks()) { + acks++; + Txn txn = db.startTransaction("receiveBundle:acks"); + try { + Iterable batch = + db.removeOutstandingBatch(txn, n, ack); + // May be null if the batch was empty or has expired + if(batch == null) { + expired++; + } else { + for(MessageId m : batch) { + // Don't re-create statuses for expired messages + if(db.containsMessage(txn, m)) + db.setStatus(txn, n, m, Status.SEEN); + } + } + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + System.out.println("Received " + acks + " acks, " + expired + + " expired"); + } finally { + neighbourLock.writeLock().unlock(); + } + } finally { + messageLock.readLock().unlock(); + } + // Update the neighbour's subscriptions + neighbourLock.writeLock().lock(); + try { + Txn txn = db.startTransaction("receiveBundle:subscriptions"); + try { + db.clearSubscriptions(txn, n); + int subs = 0; + for(GroupId g : b.getSubscriptions()) { + subs++; + db.addSubscription(txn, n, g); + } + System.out.println("Received " + subs + " subscriptions"); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + neighbourLock.writeLock().unlock(); + } + // Store the messages + int batches = 0; + for(Batch batch : b.getBatches()) { + batches++; + waitForPermissionToWrite(); + messageLock.writeLock().lock(); + try { + neighbourLock.writeLock().lock(); + try { + subscriptionLock.readLock().lock(); + try { + Txn txn = db.startTransaction("receiveBundle:batch"); + try { + int received = 0, stored = 0; + for(Message m : batch.getMessages()) { + received++; + if(db.containsSubscription(txn, m.getGroup())) { + if(storeMessage(txn, m, n)) stored++; + } + } + System.out.println("Received " + received + + " messages, stored " + stored); + db.addBatchToAck(txn, n, batch.getId()); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + subscriptionLock.readLock().unlock(); + } + } finally { + neighbourLock.writeLock().unlock(); + } + } finally { + messageLock.writeLock().unlock(); + } + } + System.out.println("Received " + batches + " batches"); + // Find any lost batches that need to be retransmitted + Set lost; + messageLock.readLock().lock(); + try { + neighbourLock.writeLock().lock(); + try { + Txn txn = db.startTransaction("receiveBundle:findLost"); + try { + lost = db.addReceivedBundle(txn, n, b.getId()); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + neighbourLock.writeLock().unlock(); + } + } finally { + messageLock.readLock().unlock(); + } + for(BatchId batch : lost) { + messageLock.readLock().lock(); + try { + neighbourLock.writeLock().lock(); + try { + Txn txn = db.startTransaction("receiveBundle:removeLost"); + try { + System.out.println("Removing lost batch"); + db.removeLostBatch(txn, n, batch); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } finally { + neighbourLock.writeLock().unlock(); + } + } finally { + messageLock.readLock().unlock(); + } + } + System.gc(); + } +} \ No newline at end of file diff --git a/components/net/sf/briar/db/SynchronizedDatabaseComponent.java b/components/net/sf/briar/db/SynchronizedDatabaseComponent.java new file mode 100644 index 000000000..b73af7a1a --- /dev/null +++ b/components/net/sf/briar/db/SynchronizedDatabaseComponent.java @@ -0,0 +1,381 @@ +package net.sf.briar.db; + +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; + +import com.google.inject.Inject; +import com.google.inject.Provider; + +import net.sf.briar.api.db.DbException; +import net.sf.briar.api.db.NeighbourId; +import net.sf.briar.api.db.Rating; +import net.sf.briar.api.db.Status; +import net.sf.briar.api.protocol.AuthorId; +import net.sf.briar.api.protocol.Batch; +import net.sf.briar.api.protocol.BatchId; +import net.sf.briar.api.protocol.Bundle; +import net.sf.briar.api.protocol.GroupId; +import net.sf.briar.api.protocol.Message; +import net.sf.briar.api.protocol.MessageId; + +class SynchronizedDatabaseComponent extends DatabaseComponentImpl { + + /* + * Locks must always be acquired in alphabetical order. See the Database + * interface to find out which calls require which locks. + */ + + private final Object messageLock = new Object(); + private final Object neighbourLock = new Object(); + private final Object ratingLock = new Object(); + private final Object subscriptionLock = new Object(); + + @Inject + SynchronizedDatabaseComponent(Database db, + Provider batchProvider) { + super(db, batchProvider); + } + + protected void expireMessages(long size) throws DbException { + synchronized(messageLock) { + synchronized(neighbourLock) { + Txn txn = db.startTransaction("cleaner"); + try { + for(MessageId m : db.getOldMessages(txn, size)) { + removeMessage(txn, m); + } + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + } + + public void close() throws DbException { + synchronized(messageLock) { + synchronized(neighbourLock) { + synchronized(ratingLock) { + synchronized(subscriptionLock) { + db.close(); + } + } + } + } + } + + public void addNeighbour(NeighbourId n) throws DbException { + System.out.println("Adding neighbour " + n); + synchronized(neighbourLock) { + Txn txn = db.startTransaction("addNeighbour"); + try { + db.addNeighbour(txn, n); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + + public void addLocallyGeneratedMessage(Message m) throws DbException { + waitForPermissionToWrite(); + synchronized(messageLock) { + synchronized(neighbourLock) { + synchronized(subscriptionLock) { + Txn txn = db.startTransaction("addLocallyGeneratedMessage"); + try { + if(db.containsSubscription(txn, m.getGroup())) { + boolean added = storeMessage(txn, m, null); + assert added; + } else { + System.out.println("Not subscribed"); + } + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + } + } + + public Rating getRating(AuthorId a) throws DbException { + synchronized(ratingLock) { + Txn txn = db.startTransaction("getRating"); + try { + Rating r = db.getRating(txn, a); + db.commitTransaction(txn); + return r; + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + + public void setRating(AuthorId a, Rating r) throws DbException { + synchronized(messageLock) { + synchronized(ratingLock) { + Txn txn = db.startTransaction("setRating"); + try { + Rating old = db.setRating(txn, a, r); + // Update the sendability of the author's messages + if(r == Rating.GOOD && old != Rating.GOOD) + updateAuthorSendability(txn, a, true); + else if(r != Rating.GOOD && old == Rating.GOOD) + updateAuthorSendability(txn, a, false); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + } + + public Set getSubscriptions() throws DbException { + synchronized(subscriptionLock) { + Txn txn = db.startTransaction("getSubscriptions"); + try { + HashSet subs = new HashSet(); + for(GroupId g : db.getSubscriptions(txn)) subs.add(g); + db.commitTransaction(txn); + return subs; + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + + public void subscribe(GroupId g) throws DbException { + System.out.println("Subscribing to " + g); + synchronized(subscriptionLock) { + Txn txn = db.startTransaction("subscribe"); + try { + db.addSubscription(txn, g); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + + public void unsubscribe(GroupId g) throws DbException { + System.out.println("Unsubscribing from " + g); + synchronized(messageLock) { + synchronized(neighbourLock) { + synchronized(subscriptionLock) { + Txn txn = db.startTransaction("unsubscribe"); + try { + db.removeSubscription(txn, g); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + } + } + + public void generateBundle(NeighbourId n, Bundle b) throws DbException { + System.out.println("Generating bundle for " + n); + // Ack all batches received from the neighbour + synchronized(neighbourLock) { + Txn txn = db.startTransaction("generateBundle:acks"); + try { + int numAcks = 0; + for(BatchId ack : db.removeBatchesToAck(txn, n)) { + b.addAck(ack); + numAcks++; + } + System.out.println("Added " + numAcks + " acks"); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + // Add a list of subscriptions + synchronized(subscriptionLock) { + Txn txn = db.startTransaction("generateBundle:subscriptions"); + try { + int numSubs = 0; + for(GroupId g : db.getSubscriptions(txn)) { + b.addSubscription(g); + numSubs++; + } + System.out.println("Added " + numSubs + " subscriptions"); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + // Add as many messages as possible to the bundle + long capacity = b.getCapacity(); + while(true) { + Batch batch = fillBatch(n, capacity); + if(batch == null) break; // No more messages to send + b.addBatch(batch); + capacity -= batch.getSize(); + // If the batch is less than half full, stop trying - there may be + // more messages trickling in but we can't wait forever + if(batch.getSize() * 2 < Batch.CAPACITY) break; + } + b.seal(); + System.out.println("Bundle sent, " + b.getSize() + " bytes"); + System.gc(); + } + + private Batch fillBatch(NeighbourId n, long capacity) throws DbException { + synchronized(messageLock) { + synchronized(neighbourLock) { + Txn txn = db.startTransaction("fillBatch"); + try { + capacity = Math.min(capacity, Batch.CAPACITY); + Iterator it = + db.getSendableMessages(txn, n, capacity).iterator(); + if(!it.hasNext()) { + db.commitTransaction(txn); + return null; // No more messages to send + } + Batch b = batchProvider.get(); + Set sent = new HashSet(); + while(it.hasNext()) { + MessageId m = it.next(); + b.addMessage(db.getMessage(txn, m)); + sent.add(m); + } + b.seal(); + // Record the contents of the batch + assert !sent.isEmpty(); + db.addOutstandingBatch(txn, n, b.getId(), sent); + db.commitTransaction(txn); + return b; + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + } + + public void receiveBundle(NeighbourId n, Bundle b) throws DbException { + System.out.println("Received bundle from " + n + ", " + + b.getSize() + " bytes"); + // Mark all messages in acked batches as seen + synchronized(messageLock) { + synchronized(neighbourLock) { + int acks = 0, expired = 0; + for(BatchId ack : b.getAcks()) { + acks++; + Txn txn = db.startTransaction("receiveBundle:acks"); + try { + Iterable batch = + db.removeOutstandingBatch(txn, n, ack); + // May be null if the batch was empty or has expired + if(batch == null) { + expired++; + } else { + for(MessageId m : batch) { + // Don't re-create statuses for expired messages + if(db.containsMessage(txn, m)) + db.setStatus(txn, n, m, Status.SEEN); + } + } + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + System.out.println("Received " + acks + " acks, " + expired + + " expired"); + } + } + // Update the neighbour's subscriptions + synchronized(neighbourLock) { + Txn txn = db.startTransaction("receiveBundle:subscriptions"); + try { + db.clearSubscriptions(txn, n); + int subs = 0; + for(GroupId g : b.getSubscriptions()) { + subs++; + db.addSubscription(txn, n, g); + } + System.out.println("Received " + subs + " subscriptions"); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + // Store the messages + int batches = 0; + for(Batch batch : b.getBatches()) { + batches++; + waitForPermissionToWrite(); + synchronized(messageLock) { + synchronized(neighbourLock) { + synchronized(subscriptionLock) { + Txn txn = db.startTransaction("receiveBundle:batch"); + try { + int received = 0, stored = 0; + for(Message m : batch.getMessages()) { + received++; + if(db.containsSubscription(txn, m.getGroup())) { + if(storeMessage(txn, m, n)) stored++; + } + } + System.out.println("Received " + received + + " messages, stored " + stored); + db.addBatchToAck(txn, n, batch.getId()); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + } + } + System.out.println("Received " + batches + " batches"); + // Find any lost batches that need to be retransmitted + Set lost; + synchronized(messageLock) { + synchronized(neighbourLock) { + Txn txn = db.startTransaction("receiveBundle:findLost"); + try { + lost = db.addReceivedBundle(txn, n, b.getId()); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + for(BatchId batch : lost) { + synchronized(messageLock) { + synchronized(neighbourLock) { + Txn txn = db.startTransaction("receiveBundle:removeLost"); + try { + System.out.println("Removing lost batch"); + db.removeLostBatch(txn, n, batch); + db.commitTransaction(txn); + } catch(DbException e) { + db.abortTransaction(txn); + throw e; + } + } + } + } + System.gc(); + } +} diff --git a/components/net/sf/briar/i18n/FontManagerImpl.java b/components/net/sf/briar/i18n/FontManagerImpl.java new file mode 100644 index 000000000..8b5f9623f --- /dev/null +++ b/components/net/sf/briar/i18n/FontManagerImpl.java @@ -0,0 +1,99 @@ +package net.sf.briar.i18n; + +import java.awt.Font; +import java.awt.FontFormatException; +import java.awt.font.TextAttribute; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; +import java.util.TreeMap; + +import javax.swing.UIManager; + +import net.sf.briar.api.i18n.FontManager; +import net.sf.briar.util.FileUtils; + +public class FontManagerImpl implements FontManager { + + private static final BundledFont[] BUNDLED_FONTS = { + new BundledFont("TibetanMachineUni.ttf", 14f, new String[] { "bo" }), + new BundledFont("Padauk.ttf", 14f, new String[] { "my" }), + }; + + private final Map fonts = new TreeMap(); + + private volatile Font defaultFont = null, uiFont = null; + + public void initialize(Locale locale) throws IOException { + try { + ClassLoader loader = getClass().getClassLoader(); + for(BundledFont bf : BUNDLED_FONTS) { + InputStream in = loader.getResourceAsStream(bf.filename); + if(in == null) { + File root = FileUtils.getBriarDirectory(); + File file = new File(root, "Data/" + bf.filename); + in = new FileInputStream(file); + } + Font font = Font.createFont(Font.TRUETYPE_FONT, in); + font = font.deriveFont(bf.size); + for(String language : bf.languages) fonts.put(language, font); + } + } catch(FontFormatException e) { + throw new IOException(e); + } + defaultFont = getFont("Sans", 12f); + assert defaultFont != null; // FIXME: This is failing on Windows + setUiFontForLanguage(locale.getLanguage()); + } + + private Font getFont(String name, float size) { + Map attr = new HashMap(); + attr.put(TextAttribute.FAMILY, name); + attr.put(TextAttribute.SIZE, Float.valueOf(size)); + return Font.getFont(attr); + } + + public String[] getBundledFontFilenames() { + String[] names = new String[BUNDLED_FONTS.length]; + for(int i = 0; i < BUNDLED_FONTS.length; i++) + names[i] = BUNDLED_FONTS[i].filename; + return names; + } + + public Font getFontForLanguage(String language) { + assert defaultFont != null; + Font font = fonts.get(language); + return font == null ? defaultFont : font; + } + + public Font getUiFont() { + return uiFont; + } + + public void setUiFontForLanguage(String language) { + uiFont = getFontForLanguage(language); + Enumeration