Bump version to 0.41

// FREEBIE

config/sample.yml

@@ -15,6 +15,7 @@ nexmo:
   number:
 
 gcm:
+  senderId:
   apiKey: 
 
 # Optional. Only if iOS clients are supported.
@@ -56,9 +57,6 @@ graphite:
   host:
   port:
 
-http:
-  shutdownGracePeriod: 0s
-
 database:
   # the name of your JDBC driver
   driverClass: org.postgresql.Driver
@@ -75,24 +73,3 @@ database:
   # any properties specific to your JDBC driver:
   properties:
     charSet: UTF-8
-
-  # the maximum amount of time to wait on an empty pool before throwing an exception
-  maxWaitForConnection: 1s
-
-  # the SQL query to run when validating a connection's liveness
-  validationQuery: "/* MyService Health Check */ SELECT 1"
-
-  # the minimum number of connections to keep open
-  minSize: 8
-
-  # the maximum number of connections to keep open
-  maxSize: 32
-
-  # whether or not idle connections should be validated
-  checkConnectionWhileIdle: false
-
-  # how long a connection must be held before it can be validated
-  checkConnectionHealthWhenIdleFor: 10s
-
-  # the maximum lifetime of an idle connection
-  closeConnectionIfIdleFor: 1 minute

pom.xml

@@ -9,39 +9,83 @@
 
     <groupId>org.whispersystems.textsecure</groupId>
     <artifactId>TextSecureServer</artifactId>
-    <version>0.11</version>
+    <version>0.41</version>
+
+    <properties>
+        <dropwizard.version>0.7.1</dropwizard.version>
+        <jackson.api.version>2.3.3</jackson.api.version>
+        <commons-codec.version>1.6</commons-codec.version>
+    </properties>
 
     <dependencies>
+        <dependency>
+            <groupId>io.dropwizard</groupId>
+            <artifactId>dropwizard-core</artifactId>
+            <version>${dropwizard.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.dropwizard</groupId>
+            <artifactId>dropwizard-jdbi</artifactId>
+            <version>${dropwizard.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.dropwizard</groupId>
+            <artifactId>dropwizard-auth</artifactId>
+            <version>${dropwizard.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.dropwizard</groupId>
+            <artifactId>dropwizard-client</artifactId>
+            <version>${dropwizard.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.dropwizard</groupId>
+            <artifactId>dropwizard-migrations</artifactId>
+            <version>${dropwizard.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.dropwizard</groupId>
+            <artifactId>dropwizard-testing</artifactId>
+            <version>${dropwizard.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.dropwizard</groupId>
+            <artifactId>dropwizard-metrics-graphite</artifactId>
+            <version>${dropwizard.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.dcsquare</groupId>
+            <artifactId>dropwizard-papertrail</artifactId>
+            <version>1.1</version>
+        </dependency>
+
+
+        <dependency>
+            <groupId>com.sun.jersey</groupId>
+            <artifactId>jersey-json</artifactId>
+            <version>1.18.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.codahale.metrics</groupId>
+            <artifactId>metrics-graphite</artifactId>
+            <version>3.0.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.eclipse.jetty.websocket</groupId>
+            <artifactId>websocket-server</artifactId>
+            <version>9.0.7.v20131107</version>
+        </dependency>
+
         <dependency>
             <groupId>bouncycastle</groupId>
             <artifactId>bcprov-jdk16</artifactId>
             <version>140</version>
         </dependency>
-        <dependency>
-            <groupId>com.yammer.dropwizard</groupId>
-            <artifactId>dropwizard-core</artifactId>
-            <version>0.6.2</version>
-        </dependency>
-        <dependency>
-            <groupId>com.yammer.metrics</groupId>
-            <artifactId>metrics-graphite</artifactId>
-            <version>2.2.0</version>
-        </dependency>
         <dependency>
             <groupId>com.google.android.gcm</groupId>
             <artifactId>gcm-server</artifactId>
             <version>1.0.2</version>
         </dependency>
-        <dependency>
-            <groupId>com.google.code.gson</groupId>
-            <artifactId>gson</artifactId>
-            <version>2.2.2</version>
-        </dependency>
-        <dependency>
-            <groupId>net.spy</groupId>
-            <artifactId>spymemcached</artifactId>
-            <version>2.10.1</version>
-        </dependency>
         <dependency>
             <groupId>com.notnoop.apns</groupId>
             <artifactId>apns</artifactId>
@@ -56,45 +100,20 @@
         <dependency>
             <groupId>com.google.protobuf</groupId>
             <artifactId>protobuf-java</artifactId>
-            <version>2.4.1</version>
+            <version>2.5.0</version>
         </dependency>
 
         <dependency>
             <groupId>redis.clients</groupId>
             <artifactId>jedis</artifactId>
-            <version>2.2.1</version>
+            <version>2.6.2</version>
             <type>jar</type>
             <scope>compile</scope>
         </dependency>
-        <dependency>
-            <groupId>com.yammer.dropwizard</groupId>
-            <artifactId>dropwizard-jdbi</artifactId>
-            <version>0.6.2</version>
-        </dependency>
-        <dependency>
-            <groupId>com.yammer.dropwizard</groupId>
-            <artifactId>dropwizard-auth</artifactId>
-            <version>0.6.2</version>
-        </dependency>
-        <dependency>
-            <groupId>com.yammer.dropwizard</groupId>
-            <artifactId>dropwizard-client</artifactId>
-            <version>0.6.2</version>
-        </dependency>
-        <dependency>
-            <groupId>com.yammer.dropwizard</groupId>
-            <artifactId>dropwizard-migrations</artifactId>
-            <version>0.6.2</version>
-        </dependency>
-        <dependency>
-            <groupId>com.yammer.dropwizard</groupId>
-            <artifactId>dropwizard-testing</artifactId>
-            <version>0.6.2</version>
-        </dependency>
         <dependency>
             <groupId>com.twilio.sdk</groupId>
             <artifactId>twilio-java-sdk</artifactId>
-            <version>3.4.1</version>
+            <version>3.4.5</version>
         </dependency>
 
         <dependency>
@@ -102,26 +121,35 @@
             <artifactId>postgresql</artifactId>
             <version>9.1-901.jdbc4</version>
         </dependency>
-
         <dependency>
-            <groupId>com.sun.jersey</groupId>
-            <artifactId>jersey-json</artifactId>
-            <version>1.17.1</version>
+            <groupId>org.igniterealtime.smack</groupId>
+            <artifactId>smack-tcp</artifactId>
+            <version>4.0.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.whispersystems</groupId>
+            <artifactId>websocket-resources</artifactId>
+            <version>0.2.3</version>
         </dependency>
 
-        <dependency>
-            <groupId>org.eclipse.jetty</groupId>
-            <artifactId>jetty-websocket</artifactId>
-            <version>8.1.14.v20131031</version>
-        </dependency>
 
-        <dependency>
-            <groupId>org.coursera</groupId>
-            <artifactId>metrics-datadog</artifactId>
-            <version>0.1.5</version>
-        </dependency>
     </dependencies>
 
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>com.fasterxml.jackson.core</groupId>
+                <artifactId>jackson-databind</artifactId>
+                <version>${jackson.api.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>commons-codec</groupId>
+                <artifactId>commons-codec</artifactId>
+                <version>${commons-codec.version}</version>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
     <build>
         <plugins>
             <plugin>

protobuf/Makefile

@@ -1,3 +1,3 @@
 
 all:
-	protoc --java_out=../src/main/java/ OutgoingMessageSignal.proto
+	protoc --java_out=../src/main/java/ OutgoingMessageSignal.proto PubSubMessage.proto

protobuf/OutgoingMessageSignal.proto

@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2013 Open WhisperSystems
+ * Copyright (C) 2013 - 2015 Open WhisperSystems
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -20,6 +20,15 @@ option java_package = "org.whispersystems.textsecuregcm.entities";
 option java_outer_classname = "MessageProtos";
 
 message OutgoingMessageSignal {
+  enum Type {
+    UNKNOWN       = 0;
+    CIPHERTEXT    = 1;
+    KEY_EXCHANGE  = 2;
+    PREKEY_BUNDLE = 3;
+    PLAINTEXT     = 4;
+    RECEIPT       = 5;
+  }
+
   optional uint32 type = 1;
   optional string source = 2;
   optional  uint32 sourceDevice = 7;
@@ -27,4 +36,8 @@ message OutgoingMessageSignal {
 //  repeated string destinations = 4;
   optional uint64 timestamp = 5;
   optional bytes message = 6;
+}
+
+message ProvisioningUuid {
+  optional string uuid = 1;
 }

protobuf/PubSubMessage.proto

@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2013 Open WhisperSystems
+ * Copyright (C) 2014 Open Whisper Systems
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -14,33 +14,20 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-package org.whispersystems.textsecuregcm.configuration;
+package textsecure;
 
-import com.fasterxml.jackson.annotation.JsonProperty;
-import org.hibernate.validator.constraints.NotEmpty;
+option java_package = "org.whispersystems.textsecuregcm.storage";
+option java_outer_classname = "PubSubProtos";
 
-public class MemcacheConfiguration {
-
-  @NotEmpty
-  @JsonProperty
-  private String servers;
-
-  @JsonProperty
-  private String user;
-
-  @JsonProperty
-  private String password;
-
-
-  public String getServers() {
-    return servers;
+message PubSubMessage {
+  enum Type {
+    UNKNOWN   = 0;
+    QUERY_DB  = 1;
+    DELIVER   = 2;
+    KEEPALIVE = 3;
+    CLOSE     = 4;
   }
 
-  public String getUser() {
-    return user;
-  }
-
-  public String getPassword() {
-    return password;
-  }
+  optional Type  type    = 1;
+  optional bytes content = 2;
 }

protobuf/StoredMessage.proto

@@ -0,0 +1,30 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package textsecure;
+
+option java_package = "org.whispersystems.textsecuregcm.storage";
+option java_outer_classname = "StoredMessageProtos";
+
+message StoredMessage {
+  enum Type {
+    UNKNOWN = 0;
+    MESSAGE = 1;
+  }
+
+  optional Type  type    = 1;
+  optional bytes content = 2;
+}

src/main/java/org/whispersystems/textsecuregcm/WhisperServerConfiguration.java

@@ -17,16 +17,12 @@
 package org.whispersystems.textsecuregcm;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.yammer.dropwizard.config.Configuration;
-import com.yammer.dropwizard.db.DatabaseConfiguration;
-import org.whispersystems.textsecuregcm.configuration.ApnConfiguration;
 import org.whispersystems.textsecuregcm.configuration.FederationConfiguration;
-import org.whispersystems.textsecuregcm.configuration.GcmConfiguration;
 import org.whispersystems.textsecuregcm.configuration.GraphiteConfiguration;
-import org.whispersystems.textsecuregcm.configuration.MemcacheConfiguration;
-import org.whispersystems.textsecuregcm.configuration.MetricsConfiguration;
 import org.whispersystems.textsecuregcm.configuration.NexmoConfiguration;
+import org.whispersystems.textsecuregcm.configuration.PushConfiguration;
 import org.whispersystems.textsecuregcm.configuration.RateLimitsConfiguration;
+import org.whispersystems.textsecuregcm.configuration.RedPhoneConfiguration;
 import org.whispersystems.textsecuregcm.configuration.RedisConfiguration;
 import org.whispersystems.textsecuregcm.configuration.S3Configuration;
 import org.whispersystems.textsecuregcm.configuration.TwilioConfiguration;
@@ -35,6 +31,10 @@ import org.whispersystems.textsecuregcm.configuration.WebsocketConfiguration;
 import javax.validation.Valid;
 import javax.validation.constraints.NotNull;
 
+import io.dropwizard.Configuration;
+import io.dropwizard.client.JerseyClientConfiguration;
+import io.dropwizard.db.DataSourceFactory;
+
 public class WhisperServerConfiguration extends Configuration {
 
   @NotNull
@@ -46,8 +46,9 @@ public class WhisperServerConfiguration extends Configuration {
   private NexmoConfiguration nexmo;
 
   @NotNull
+  @Valid
   @JsonProperty
-  private GcmConfiguration gcm;
+  private PushConfiguration push;
 
   @NotNull
   @Valid
@@ -57,15 +58,18 @@ public class WhisperServerConfiguration extends Configuration {
   @NotNull
   @Valid
   @JsonProperty
-  private MemcacheConfiguration memcache;
+  private RedisConfiguration cache;
 
   @NotNull
   @Valid
   @JsonProperty
-  private RedisConfiguration redis;
+  private RedisConfiguration directory;
 
+  @Valid
+  @NotNull
   @JsonProperty
-  private ApnConfiguration apn = new ApnConfiguration();
+  private DataSourceFactory messageStore;
+
 
   @Valid
   @JsonProperty
@@ -74,7 +78,7 @@ public class WhisperServerConfiguration extends Configuration {
   @Valid
   @NotNull
   @JsonProperty
-  private DatabaseConfiguration database = new DatabaseConfiguration();
+  private DataSourceFactory database = new DataSourceFactory();
 
   @Valid
   @NotNull
@@ -87,11 +91,16 @@ public class WhisperServerConfiguration extends Configuration {
 
   @Valid
   @JsonProperty
-  private MetricsConfiguration metrics = new MetricsConfiguration();
+  private WebsocketConfiguration websocket = new WebsocketConfiguration();
+
+  @JsonProperty
+  private RedPhoneConfiguration redphone = new RedPhoneConfiguration();
 
   @Valid
+  @NotNull
   @JsonProperty
-  private WebsocketConfiguration websocket = new WebsocketConfiguration();
+  private JerseyClientConfiguration httpClient = new JerseyClientConfiguration();
+
 
   public WebsocketConfiguration getWebsocketConfiguration() {
     return websocket;
@@ -105,27 +114,31 @@ public class WhisperServerConfiguration extends Configuration {
     return nexmo;
   }
 
-  public GcmConfiguration getGcmConfiguration() {
-    return gcm;
+  public PushConfiguration getPushConfiguration() {
+    return push;
   }
 
-  public ApnConfiguration getApnConfiguration() {
-    return apn;
+  public JerseyClientConfiguration getJerseyClientConfiguration() {
+    return httpClient;
   }
 
   public S3Configuration getS3Configuration() {
     return s3;
   }
 
-  public MemcacheConfiguration getMemcacheConfiguration() {
-    return memcache;
+  public RedisConfiguration getCacheConfiguration() {
+    return cache;
   }
 
-  public RedisConfiguration getRedisConfiguration() {
-    return redis;
+  public RedisConfiguration getDirectoryConfiguration() {
+    return directory;
   }
 
-  public DatabaseConfiguration getDatabaseConfiguration() {
+  public DataSourceFactory getMessageStoreConfiguration() {
+    return messageStore;
+  }
+
+  public DataSourceFactory getDataSourceFactory() {
     return database;
   }
 
@@ -141,7 +154,7 @@ public class WhisperServerConfiguration extends Configuration {
     return graphite;
   }
 
-  public MetricsConfiguration getMetricsConfiguration() {
-    return metrics;
+  public RedPhoneConfiguration getRedphoneConfiguration() {
+    return redphone;
   }
 }

src/main/java/org/whispersystems/textsecuregcm/WhisperServerService.java

@@ -16,18 +16,13 @@
  */
 package org.whispersystems.textsecuregcm;
 
+import com.codahale.metrics.SharedMetricRegistries;
+import com.codahale.metrics.graphite.GraphiteReporter;
+import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.google.common.base.Optional;
-import com.yammer.dropwizard.Service;
-import com.yammer.dropwizard.config.Bootstrap;
-import com.yammer.dropwizard.config.Environment;
-import com.yammer.dropwizard.config.HttpConfiguration;
-import com.yammer.dropwizard.db.DatabaseConfiguration;
-import com.yammer.dropwizard.jdbi.DBIFactory;
-import com.yammer.dropwizard.migrations.MigrationsBundle;
-import com.yammer.metrics.Metrics;
-import com.yammer.metrics.reporting.GraphiteReporter;
-import net.spy.memcached.MemcachedClient;
+import com.sun.jersey.api.client.Client;
 import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.eclipse.jetty.servlets.CrossOriginFilter;
 import org.skife.jdbi.v2.DBI;
 import org.whispersystems.textsecuregcm.auth.AccountAuthenticator;
 import org.whispersystems.textsecuregcm.auth.FederatedPeerAuthenticator;
@@ -37,25 +32,31 @@ import org.whispersystems.textsecuregcm.controllers.AccountController;
 import org.whispersystems.textsecuregcm.controllers.AttachmentController;
 import org.whispersystems.textsecuregcm.controllers.DeviceController;
 import org.whispersystems.textsecuregcm.controllers.DirectoryController;
-import org.whispersystems.textsecuregcm.controllers.FederationController;
-import org.whispersystems.textsecuregcm.controllers.KeysController;
+import org.whispersystems.textsecuregcm.controllers.FederationControllerV1;
+import org.whispersystems.textsecuregcm.controllers.FederationControllerV2;
+import org.whispersystems.textsecuregcm.controllers.KeepAliveController;
+import org.whispersystems.textsecuregcm.controllers.KeysControllerV1;
+import org.whispersystems.textsecuregcm.controllers.KeysControllerV2;
 import org.whispersystems.textsecuregcm.controllers.MessageController;
-import org.whispersystems.textsecuregcm.controllers.WebsocketControllerFactory;
+import org.whispersystems.textsecuregcm.controllers.ProvisioningController;
+import org.whispersystems.textsecuregcm.controllers.ReceiptController;
 import org.whispersystems.textsecuregcm.federation.FederatedClientManager;
 import org.whispersystems.textsecuregcm.federation.FederatedPeer;
 import org.whispersystems.textsecuregcm.limits.RateLimiters;
+import org.whispersystems.textsecuregcm.liquibase.NameableMigrationsBundle;
 import org.whispersystems.textsecuregcm.mappers.IOExceptionMapper;
 import org.whispersystems.textsecuregcm.mappers.RateLimitExceededExceptionMapper;
 import org.whispersystems.textsecuregcm.metrics.CpuUsageGauge;
 import org.whispersystems.textsecuregcm.metrics.FreeMemoryGauge;
-import org.whispersystems.textsecuregcm.metrics.JsonMetricsReporter;
 import org.whispersystems.textsecuregcm.metrics.NetworkReceivedGauge;
 import org.whispersystems.textsecuregcm.metrics.NetworkSentGauge;
-import org.whispersystems.textsecuregcm.providers.MemcacheHealthCheck;
-import org.whispersystems.textsecuregcm.providers.MemcachedClientFactory;
 import org.whispersystems.textsecuregcm.providers.RedisClientFactory;
 import org.whispersystems.textsecuregcm.providers.RedisHealthCheck;
+import org.whispersystems.textsecuregcm.providers.TimeProvider;
+import org.whispersystems.textsecuregcm.push.FeedbackHandler;
 import org.whispersystems.textsecuregcm.push.PushSender;
+import org.whispersystems.textsecuregcm.push.PushServiceClient;
+import org.whispersystems.textsecuregcm.push.WebsocketSender;
 import org.whispersystems.textsecuregcm.sms.NexmoSmsSender;
 import org.whispersystems.textsecuregcm.sms.SmsSender;
 import org.whispersystems.textsecuregcm.sms.TwilioSmsSender;
@@ -64,23 +65,42 @@ import org.whispersystems.textsecuregcm.storage.AccountsManager;
 import org.whispersystems.textsecuregcm.storage.Device;
 import org.whispersystems.textsecuregcm.storage.DirectoryManager;
 import org.whispersystems.textsecuregcm.storage.Keys;
+import org.whispersystems.textsecuregcm.storage.Messages;
+import org.whispersystems.textsecuregcm.storage.MessagesManager;
 import org.whispersystems.textsecuregcm.storage.PendingAccounts;
 import org.whispersystems.textsecuregcm.storage.PendingAccountsManager;
 import org.whispersystems.textsecuregcm.storage.PendingDevices;
 import org.whispersystems.textsecuregcm.storage.PendingDevicesManager;
 import org.whispersystems.textsecuregcm.storage.PubSubManager;
-import org.whispersystems.textsecuregcm.storage.StoredMessageManager;
-import org.whispersystems.textsecuregcm.storage.StoredMessages;
-import org.whispersystems.textsecuregcm.util.CORSHeaderFilter;
+import org.whispersystems.textsecuregcm.util.Constants;
 import org.whispersystems.textsecuregcm.util.UrlSigner;
+import org.whispersystems.textsecuregcm.websocket.AuthenticatedConnectListener;
+import org.whispersystems.textsecuregcm.websocket.DeadLetterHandler;
+import org.whispersystems.textsecuregcm.websocket.ProvisioningConnectListener;
+import org.whispersystems.textsecuregcm.websocket.WebSocketAccountAuthenticator;
 import org.whispersystems.textsecuregcm.workers.DirectoryCommand;
+import org.whispersystems.textsecuregcm.workers.VacuumCommand;
+import org.whispersystems.websocket.WebSocketResourceProviderFactory;
+import org.whispersystems.websocket.setup.WebSocketEnvironment;
 
+import javax.servlet.DispatcherType;
+import javax.servlet.FilterRegistration;
+import javax.servlet.ServletRegistration;
 import java.security.Security;
+import java.util.EnumSet;
 import java.util.concurrent.TimeUnit;
 
+import static com.codahale.metrics.MetricRegistry.name;
+import io.dropwizard.Application;
+import io.dropwizard.client.JerseyClientBuilder;
+import io.dropwizard.db.DataSourceFactory;
+import io.dropwizard.jdbi.DBIFactory;
+import io.dropwizard.metrics.graphite.GraphiteReporterFactory;
+import io.dropwizard.setup.Bootstrap;
+import io.dropwizard.setup.Environment;
 import redis.clients.jedis.JedisPool;
 
-public class WhisperServerService extends Service<WhisperServerConfiguration> {
+public class WhisperServerService extends Application<WhisperServerConfiguration> {
 
   static {
     Security.addProvider(new BouncyCastleProvider());
@@ -88,99 +108,147 @@ public class WhisperServerService extends Service<WhisperServerConfiguration> {
 
   @Override
   public void initialize(Bootstrap<WhisperServerConfiguration> bootstrap) {
-    bootstrap.setName("whisper-server");
     bootstrap.addCommand(new DirectoryCommand());
-    bootstrap.addBundle(new MigrationsBundle<WhisperServerConfiguration>() {
+    bootstrap.addCommand(new VacuumCommand());
+    bootstrap.addBundle(new NameableMigrationsBundle<WhisperServerConfiguration>("accountdb", "accountsdb.xml") {
       @Override
-      public DatabaseConfiguration getDatabaseConfiguration(WhisperServerConfiguration configuration) {
-        return configuration.getDatabaseConfiguration();
+      public DataSourceFactory getDataSourceFactory(WhisperServerConfiguration configuration) {
+        return configuration.getDataSourceFactory();
       }
     });
+
+    bootstrap.addBundle(new NameableMigrationsBundle<WhisperServerConfiguration>("messagedb", "messagedb.xml") {
+      @Override
+      public DataSourceFactory getDataSourceFactory(WhisperServerConfiguration configuration) {
+        return configuration.getMessageStoreConfiguration();
+      }
+    });
+  }
+
+  @Override
+  public String getName() {
+    return "whisper-server";
   }
 
   @Override
   public void run(WhisperServerConfiguration config, Environment environment)
       throws Exception
   {
-    config.getHttpConfiguration().setConnectorType(HttpConfiguration.ConnectorType.NONBLOCKING);
-    
+    SharedMetricRegistries.add(Constants.METRICS_NAME, environment.metrics());
+    environment.getObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+
     DBIFactory dbiFactory = new DBIFactory();
-    DBI        jdbi       = dbiFactory.build(environment, config.getDatabaseConfiguration(), "postgresql");
+    DBI        database   = dbiFactory.build(environment, config.getDataSourceFactory(), "accountdb");
+    DBI        messagedb  = dbiFactory.build(environment, config.getMessageStoreConfiguration(), "messagedb");
 
-    Accounts        accounts        = jdbi.onDemand(Accounts.class);
-    PendingAccounts pendingAccounts = jdbi.onDemand(PendingAccounts.class);
-    PendingDevices  pendingDevices  = jdbi.onDemand(PendingDevices.class);
-    Keys            keys            = jdbi.onDemand(Keys.class);
-    StoredMessages  storedMessages  = jdbi.onDemand(StoredMessages.class );
+    Accounts        accounts        = database.onDemand(Accounts.class);
+    PendingAccounts pendingAccounts = database.onDemand(PendingAccounts.class);
+    PendingDevices  pendingDevices  = database.onDemand(PendingDevices.class);
+    Keys            keys            = database.onDemand(Keys.class);
+    Messages        messages        = messagedb.onDemand(Messages.class);
 
-    MemcachedClient memcachedClient = new MemcachedClientFactory(config.getMemcacheConfiguration()).getClient();
-    JedisPool       redisClient     = new RedisClientFactory(config.getRedisConfiguration()).getRedisClientPool();
+    JedisPool       cacheClient        = new RedisClientFactory(config.getCacheConfiguration().getUrl()).getRedisClientPool();
+    JedisPool       directoryClient    = new RedisClientFactory(config.getDirectoryConfiguration().getUrl()).getRedisClientPool();
+    Client          httpClient         = new JerseyClientBuilder(environment).using(config.getJerseyClientConfiguration())
+                                                                             .build(getName());
 
-    DirectoryManager         directory              = new DirectoryManager(redisClient);
-    PendingAccountsManager   pendingAccountsManager = new PendingAccountsManager(pendingAccounts, memcachedClient);
-    PendingDevicesManager    pendingDevicesManager  = new PendingDevicesManager(pendingDevices, memcachedClient);
-    AccountsManager          accountsManager        = new AccountsManager(accounts, directory, memcachedClient);
-    FederatedClientManager   federatedClientManager = new FederatedClientManager(config.getFederationConfiguration());
-    PubSubManager            pubSubManager          = new PubSubManager(redisClient);
-    StoredMessageManager     storedMessageManager   = new StoredMessageManager(storedMessages, pubSubManager);
+    DirectoryManager       directory              = new DirectoryManager(directoryClient);
+    PendingAccountsManager pendingAccountsManager = new PendingAccountsManager(pendingAccounts, cacheClient);
+    PendingDevicesManager  pendingDevicesManager  = new PendingDevicesManager (pendingDevices, cacheClient);
+    AccountsManager        accountsManager        = new AccountsManager(accounts, directory, cacheClient);
+    FederatedClientManager federatedClientManager = new FederatedClientManager(config.getFederationConfiguration());
+    MessagesManager        messagesManager        = new MessagesManager(messages);
+    DeadLetterHandler      deadLetterHandler      = new DeadLetterHandler(messagesManager);
+    PubSubManager          pubSubManager          = new PubSubManager(cacheClient, deadLetterHandler);
+    PushServiceClient      pushServiceClient      = new PushServiceClient(httpClient, config.getPushConfiguration());
+    WebsocketSender        websocketSender        = new WebsocketSender(messagesManager, pubSubManager);
+    AccountAuthenticator   deviceAuthenticator    = new AccountAuthenticator(accountsManager);
+    RateLimiters           rateLimiters           = new RateLimiters(config.getLimitsConfiguration(), cacheClient);
 
-    AccountAuthenticator     deviceAuthenticator    = new AccountAuthenticator(accountsManager);
-    RateLimiters             rateLimiters           = new RateLimiters(config.getLimitsConfiguration(), memcachedClient);
+    TwilioSmsSender          twilioSmsSender     = new TwilioSmsSender(config.getTwilioConfiguration());
+    Optional<NexmoSmsSender> nexmoSmsSender      = initializeNexmoSmsSender(config.getNexmoConfiguration());
+    SmsSender                smsSender           = new SmsSender(twilioSmsSender, nexmoSmsSender, config.getTwilioConfiguration().isInternational());
+    UrlSigner                urlSigner           = new UrlSigner(config.getS3Configuration());
+    PushSender               pushSender          = new PushSender(pushServiceClient, websocketSender);
+    FeedbackHandler          feedbackHandler     = new FeedbackHandler(pushServiceClient, accountsManager);
+    Optional<byte[]>         authorizationKey    = config.getRedphoneConfiguration().getAuthorizationKey();
 
-    TwilioSmsSender          twilioSmsSender        = new TwilioSmsSender(config.getTwilioConfiguration());
-    Optional<NexmoSmsSender> nexmoSmsSender         = initializeNexmoSmsSender(config.getNexmoConfiguration());
-    SmsSender                smsSender              = new SmsSender(twilioSmsSender, nexmoSmsSender, config.getTwilioConfiguration().isInternational());
-    UrlSigner                urlSigner              = new UrlSigner(config.getS3Configuration());
-    PushSender               pushSender             = new PushSender(config.getGcmConfiguration(),
-                                                                     config.getApnConfiguration(),
-                                                                     storedMessageManager,
-                                                                     accountsManager);
+    environment.lifecycle().manage(feedbackHandler);
 
     AttachmentController attachmentController = new AttachmentController(rateLimiters, federatedClientManager, urlSigner);
-    KeysController       keysController       = new KeysController(rateLimiters, keys, accountsManager, federatedClientManager);
+    KeysControllerV1     keysControllerV1     = new KeysControllerV1(rateLimiters, keys, accountsManager, federatedClientManager);
+    KeysControllerV2     keysControllerV2     = new KeysControllerV2(rateLimiters, keys, accountsManager, federatedClientManager);
     MessageController    messageController    = new MessageController(rateLimiters, pushSender, accountsManager, federatedClientManager);
 
-    environment.addProvider(new MultiBasicAuthProvider<>(new FederatedPeerAuthenticator(config.getFederationConfiguration()),
-                                                         FederatedPeer.class,
-                                                         deviceAuthenticator,
-                                                         Device.class, "WhisperServer"));
+    environment.jersey().register(new MultiBasicAuthProvider<>(new FederatedPeerAuthenticator(config.getFederationConfiguration()),
+                                                               FederatedPeer.class,
+                                                               deviceAuthenticator,
+                                                               Device.class, "WhisperServer"));
 
-    environment.addResource(new AccountController(pendingAccountsManager, accountsManager, rateLimiters, smsSender));
-    environment.addResource(new DeviceController(pendingDevicesManager, accountsManager, rateLimiters));
-    environment.addResource(new DirectoryController(rateLimiters, directory));
-    environment.addResource(new FederationController(accountsManager, attachmentController, keysController, messageController));
-    environment.addResource(attachmentController);
-    environment.addResource(keysController);
-    environment.addResource(messageController);
+    environment.jersey().register(new AccountController(pendingAccountsManager, accountsManager, rateLimiters, smsSender, messagesManager, new TimeProvider(), authorizationKey));
+    environment.jersey().register(new DeviceController(pendingDevicesManager, accountsManager, rateLimiters));
+    environment.jersey().register(new DirectoryController(rateLimiters, directory));
+    environment.jersey().register(new FederationControllerV1(accountsManager, attachmentController, messageController, keysControllerV1));
+    environment.jersey().register(new FederationControllerV2(accountsManager, attachmentController, messageController, keysControllerV2));
+    environment.jersey().register(new ReceiptController(accountsManager, federatedClientManager, pushSender));
+    environment.jersey().register(new ProvisioningController(rateLimiters, pushSender));
+    environment.jersey().register(attachmentController);
+    environment.jersey().register(keysControllerV1);
+    environment.jersey().register(keysControllerV2);
+    environment.jersey().register(messageController);
 
     if (config.getWebsocketConfiguration().isEnabled()) {
-      environment.addServlet(new WebsocketControllerFactory(deviceAuthenticator, storedMessageManager, pubSubManager),
-                             "/v1/websocket/");
-      environment.addFilter(new CORSHeaderFilter(), "/*");
+      WebSocketEnvironment webSocketEnvironment = new WebSocketEnvironment(environment, config, 90000);
+      webSocketEnvironment.setAuthenticator(new WebSocketAccountAuthenticator(deviceAuthenticator));
+      webSocketEnvironment.setConnectListener(new AuthenticatedConnectListener(accountsManager, pushSender, messagesManager, pubSubManager));
+      webSocketEnvironment.jersey().register(new KeepAliveController());
+
+      WebSocketEnvironment provisioningEnvironment = new WebSocketEnvironment(environment, config);
+      provisioningEnvironment.setConnectListener(new ProvisioningConnectListener(pubSubManager));
+      provisioningEnvironment.jersey().register(new KeepAliveController());
+      
+      WebSocketResourceProviderFactory webSocketServlet    = new WebSocketResourceProviderFactory(webSocketEnvironment   );
+      WebSocketResourceProviderFactory provisioningServlet = new WebSocketResourceProviderFactory(provisioningEnvironment);
+
+      ServletRegistration.Dynamic websocket    = environment.servlets().addServlet("WebSocket", webSocketServlet      );
+      ServletRegistration.Dynamic provisioning = environment.servlets().addServlet("Provisioning", provisioningServlet);
+
+      websocket.addMapping("/v1/websocket/");
+      websocket.setAsyncSupported(true);
+
+      provisioning.addMapping("/v1/websocket/provisioning/");
+      provisioning.setAsyncSupported(true);
+
+      webSocketServlet.start();
+      provisioningServlet.start();
+
+      FilterRegistration.Dynamic filter = environment.servlets().addFilter("CORS", CrossOriginFilter.class);
+      filter.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, "/*");
+      filter.setInitParameter("allowedOrigins", "*");
+      filter.setInitParameter("allowedHeaders", "Content-Type,Authorization,X-Requested-With,Content-Length,Accept,Origin");
+      filter.setInitParameter("allowedMethods", "GET,PUT,POST,DELETE,OPTIONS");
+      filter.setInitParameter("preflightMaxAge", "5184000");
+      filter.setInitParameter("allowCredentials", "true");
     }
 
-    environment.addHealthCheck(new RedisHealthCheck(redisClient));
-    environment.addHealthCheck(new MemcacheHealthCheck(memcachedClient));
+    environment.healthChecks().register("directory", new RedisHealthCheck(directoryClient));
+    environment.healthChecks().register("cache", new RedisHealthCheck(cacheClient));
 
-    environment.addProvider(new IOExceptionMapper());
-    environment.addProvider(new RateLimitExceededExceptionMapper());
+    environment.jersey().register(new IOExceptionMapper());
+    environment.jersey().register(new RateLimitExceededExceptionMapper());
 
-    Metrics.newGauge(CpuUsageGauge.class, "cpu", new CpuUsageGauge());
-    Metrics.newGauge(FreeMemoryGauge.class, "free_memory", new FreeMemoryGauge());
-    Metrics.newGauge(NetworkSentGauge.class, "bytes_sent", new NetworkSentGauge());
-    Metrics.newGauge(NetworkReceivedGauge.class, "bytes_received", new NetworkReceivedGauge());
+    environment.metrics().register(name(CpuUsageGauge.class, "cpu"), new CpuUsageGauge());
+    environment.metrics().register(name(FreeMemoryGauge.class, "free_memory"), new FreeMemoryGauge());
+    environment.metrics().register(name(NetworkSentGauge.class, "bytes_sent"), new NetworkSentGauge());
+    environment.metrics().register(name(NetworkReceivedGauge.class, "bytes_received"), new NetworkReceivedGauge());
 
     if (config.getGraphiteConfiguration().isEnabled()) {
-      GraphiteReporter.enable(15, TimeUnit.SECONDS,
-                              config.getGraphiteConfiguration().getHost(),
-                              config.getGraphiteConfiguration().getPort());
-    }
+      GraphiteReporterFactory graphiteReporterFactory = new GraphiteReporterFactory();
+      graphiteReporterFactory.setHost(config.getGraphiteConfiguration().getHost());
+      graphiteReporterFactory.setPort(config.getGraphiteConfiguration().getPort());
 
-    if (config.getMetricsConfiguration().isEnabled()) {
-      new JsonMetricsReporter("textsecure", Metrics.defaultRegistry(),
-                              config.getMetricsConfiguration().getToken(),
-                              config.getMetricsConfiguration().getHost())
-          .start(60, TimeUnit.SECONDS);
+      GraphiteReporter graphiteReporter = (GraphiteReporter) graphiteReporterFactory.build(environment.metrics());
+      graphiteReporter.start(15, TimeUnit.SECONDS);
     }
   }
 

src/main/java/org/whispersystems/textsecuregcm/auth/AccountAuthenticator.java

@@ -16,29 +16,27 @@
  */
 package org.whispersystems.textsecuregcm.auth;
 
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.SharedMetricRegistries;
 import com.google.common.base.Optional;
-import com.yammer.dropwizard.auth.AuthenticationException;
-import com.yammer.dropwizard.auth.Authenticator;
-import com.yammer.dropwizard.auth.basic.BasicCredentials;
-import com.yammer.metrics.Metrics;
-import com.yammer.metrics.core.Meter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.storage.Account;
-import org.whispersystems.textsecuregcm.storage.Device;
 import org.whispersystems.textsecuregcm.storage.AccountsManager;
+import org.whispersystems.textsecuregcm.storage.Device;
+import org.whispersystems.textsecuregcm.util.Constants;
 
-import java.util.concurrent.TimeUnit;
+import static com.codahale.metrics.MetricRegistry.name;
+import io.dropwizard.auth.AuthenticationException;
+import io.dropwizard.auth.Authenticator;
+import io.dropwizard.auth.basic.BasicCredentials;
 
 public class AccountAuthenticator implements Authenticator<BasicCredentials, Account> {
 
-  private final Meter authenticationFailedMeter    = Metrics.newMeter(AccountAuthenticator.class,
-                                                                      "authentication", "failed",
-                                                                      TimeUnit.MINUTES);
-
-  private final Meter authenticationSucceededMeter = Metrics.newMeter(AccountAuthenticator.class,
-                                                                      "authentication", "succeeded",
-                                                                      TimeUnit.MINUTES);
+  private final MetricRegistry metricRegistry               = SharedMetricRegistries.getOrCreate(Constants.METRICS_NAME);
+  private final Meter          authenticationFailedMeter    = metricRegistry.meter(name(getClass(), "authentication", "failed"   ));
+  private final Meter          authenticationSucceededMeter = metricRegistry.meter(name(getClass(), "authentication", "succeeded"));
 
   private final Logger logger = LoggerFactory.getLogger(AccountAuthenticator.class);
 

src/main/java/org/whispersystems/textsecuregcm/auth/AuthorizationHeader.java

@@ -25,13 +25,13 @@ import java.io.IOException;
 public class AuthorizationHeader {
 
   private final String number;
-  private final long accountId;
+  private final long   accountId;
   private final String password;
 
   private AuthorizationHeader(String number, long accountId, String password) {
-    this.number = number;
+    this.number    = number;
     this.accountId = accountId;
-    this.password = password;
+    this.password  = password;
   }
 
   public static AuthorizationHeader fromUserAndPassword(String user, String password) throws InvalidAuthorizationHeaderException {

src/main/java/org/whispersystems/textsecuregcm/auth/AuthorizationToken.java

@@ -0,0 +1,76 @@
+package org.whispersystems.textsecuregcm.auth;
+
+
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.binary.Hex;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.whispersystems.textsecuregcm.util.Util;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+import java.security.InvalidKeyException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.concurrent.TimeUnit;
+
+public class AuthorizationToken {
+
+  private final Logger logger = LoggerFactory.getLogger(AuthorizationToken.class);
+
+  private final String token;
+  private final byte[] key;
+
+  public AuthorizationToken(String token, byte[] key) {
+    this.token = token;
+    this.key   = key;
+  }
+
+  public boolean isValid(String number, long currentTimeMillis) {
+    String[] parts = token.split(":");
+
+    if (parts.length != 3) {
+      return false;
+    }
+
+    if (!number.equals(parts[0])) {
+      return false;
+    }
+
+    if (!isValidTime(parts[1], currentTimeMillis)) {
+      return false;
+    }
+
+    return isValidSignature(parts[0] + ":" + parts[1], parts[2]);
+  }
+
+  private boolean isValidTime(String timeString, long currentTimeMillis) {
+    try {
+      long tokenTime = Long.parseLong(timeString);
+      long ourTime   = TimeUnit.MILLISECONDS.toSeconds(currentTimeMillis);
+
+      return TimeUnit.SECONDS.toHours(Math.abs(ourTime - tokenTime)) < 24;
+    } catch (NumberFormatException e) {
+      logger.warn("Number Format", e);
+      return false;
+    }
+  }
+
+  private boolean isValidSignature(String prefix, String suffix) {
+    try {
+      Mac hmac = Mac.getInstance("HmacSHA256");
+      hmac.init(new SecretKeySpec(key, "HmacSHA256"));
+
+      byte[] ourSuffix   = Util.truncate(hmac.doFinal(prefix.getBytes()), 10);
+      byte[] theirSuffix = Hex.decodeHex(suffix.toCharArray());
+
+      return MessageDigest.isEqual(ourSuffix, theirSuffix);
+    } catch (NoSuchAlgorithmException | InvalidKeyException e) {
+      throw new AssertionError(e);
+    } catch (DecoderException e) {
+      logger.warn("Authorizationtoken", e);
+      return false;
+    }
+  }
+
+}

src/main/java/org/whispersystems/textsecuregcm/auth/FederatedPeerAuthenticator.java

@@ -16,30 +16,35 @@
  */
 package org.whispersystems.textsecuregcm.auth;
 
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.SharedMetricRegistries;
 import com.google.common.base.Optional;
-import com.yammer.dropwizard.auth.AuthenticationException;
-import com.yammer.dropwizard.auth.Authenticator;
-import com.yammer.dropwizard.auth.basic.BasicCredentials;
-import com.yammer.metrics.Metrics;
-import com.yammer.metrics.core.Meter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.configuration.FederationConfiguration;
 import org.whispersystems.textsecuregcm.federation.FederatedPeer;
+import org.whispersystems.textsecuregcm.util.Constants;
 
 import java.util.List;
-import java.util.concurrent.TimeUnit;
+
+import static com.codahale.metrics.MetricRegistry.name;
+import io.dropwizard.auth.AuthenticationException;
+import io.dropwizard.auth.Authenticator;
+import io.dropwizard.auth.basic.BasicCredentials;
 
 
 public class FederatedPeerAuthenticator implements Authenticator<BasicCredentials, FederatedPeer> {
 
-  private final Meter authenticationFailedMeter    = Metrics.newMeter(FederatedPeerAuthenticator.class,
-                                                                      "authentication", "failed",
-                                                                      TimeUnit.MINUTES);
+  private final MetricRegistry metricRegistry = SharedMetricRegistries.getOrCreate(Constants.METRICS_NAME);
 
-  private final Meter authenticationSucceededMeter = Metrics.newMeter(FederatedPeerAuthenticator.class,
-                                                                      "authentication", "succeeded",
-                                                                      TimeUnit.MINUTES);
+  private final Meter authenticationFailedMeter    = metricRegistry.meter(name(getClass(),
+                                                                               "authentication",
+                                                                               "failed"));
+
+  private final Meter authenticationSucceededMeter = metricRegistry.meter(name(getClass(),
+                                                                               "authentication",
+                                                                               "succeeded"));
 
   private final Logger logger = LoggerFactory.getLogger(FederatedPeerAuthenticator.class);
 

src/main/java/org/whispersystems/textsecuregcm/auth/MultiBasicAuthProvider.java

@@ -21,17 +21,14 @@ import com.sun.jersey.core.spi.component.ComponentContext;
 import com.sun.jersey.core.spi.component.ComponentScope;
 import com.sun.jersey.spi.inject.Injectable;
 import com.sun.jersey.spi.inject.InjectableProvider;
-import com.yammer.dropwizard.auth.Auth;
-import com.yammer.dropwizard.auth.Authenticator;
-import com.yammer.dropwizard.auth.basic.BasicAuthProvider;
-import com.yammer.dropwizard.auth.basic.BasicCredentials;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+
+import io.dropwizard.auth.Auth;
+import io.dropwizard.auth.Authenticator;
+import io.dropwizard.auth.basic.BasicAuthProvider;
+import io.dropwizard.auth.basic.BasicCredentials;
 
 public class MultiBasicAuthProvider<T1,T2> implements InjectableProvider<Auth, Parameter> {
 
-  private final Logger logger = LoggerFactory.getLogger(MultiBasicAuthProvider.class);
-
   private final BasicAuthProvider<T1> provider1;
   private final BasicAuthProvider<T2> provider2;
 
@@ -44,8 +41,8 @@ public class MultiBasicAuthProvider<T1,T2> implements InjectableProvider<Auth, P
                                 Class<?> clazz2,
                                 String realm)
   {
-    this.provider1 = new BasicAuthProvider<T1>(authenticator1, realm);
-    this.provider2 = new BasicAuthProvider<T2>(authenticator2, realm);
+    this.provider1 = new BasicAuthProvider<>(authenticator1, realm);
+    this.provider2 = new BasicAuthProvider<>(authenticator2, realm);
     this.clazz1    = clazz1;
     this.clazz2    = clazz2;
   }

src/main/java/org/whispersystems/textsecuregcm/configuration/DataDogConfiguration.java

@@ -1,20 +0,0 @@
-package org.whispersystems.textsecuregcm.configuration;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-public class DataDogConfiguration {
-
-  @JsonProperty
-  private String apiKey;
-
-  @JsonProperty
-  private boolean enabled = false;
-
-  public String getApiKey() {
-    return apiKey;
-  }
-
-  public boolean isEnabled() {
-    return enabled && apiKey != null;
-  }
-}

src/main/java/org/whispersystems/textsecuregcm/configuration/FederationConfiguration.java

@@ -18,12 +18,8 @@ package org.whispersystems.textsecuregcm.configuration;
 
 
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonParser;
 import org.whispersystems.textsecuregcm.federation.FederatedPeer;
 
-import java.util.LinkedList;
 import java.util.List;
 
 public class FederationConfiguration {
@@ -34,31 +30,7 @@ public class FederationConfiguration {
   @JsonProperty
   private String name;
 
-  @JsonProperty
-  private String herokuPeers;
-
   public List<FederatedPeer> getPeers() {
-    if (peers != null) {
-      return peers;
-    }
-
-    if (herokuPeers != null) {
-      List<FederatedPeer> peers        = new LinkedList<>();
-      JsonElement         root         = new JsonParser().parse(herokuPeers);
-      JsonArray           peerElements = root.getAsJsonArray();
-
-      for (JsonElement peer : peerElements) {
-        String name                = peer.getAsJsonObject().get("name").getAsString();
-        String url                 = peer.getAsJsonObject().get("url").getAsString();
-        String authenticationToken = peer.getAsJsonObject().get("authenticationToken").getAsString();
-        String certificate         = peer.getAsJsonObject().get("certificate").getAsString();
-
-        peers.add(new FederatedPeer(name, url, authenticationToken, certificate));
-      }
-
-      return peers;
-    }
-
     return peers;
   }
 

src/main/java/org/whispersystems/textsecuregcm/configuration/GcmConfiguration.java

@@ -19,8 +19,14 @@ package org.whispersystems.textsecuregcm.configuration;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import org.hibernate.validator.constraints.NotEmpty;
 
+import javax.validation.constraints.NotNull;
+
 public class GcmConfiguration {
 
+  @NotNull
+  @JsonProperty
+  private long senderId;
+
   @NotEmpty
   @JsonProperty
   private String apiKey;
@@ -28,4 +34,8 @@ public class GcmConfiguration {
   public String getApiKey() {
     return apiKey;
   }
+
+  public long getSenderId() {
+    return senderId;
+  }
 }

src/main/java/org/whispersystems/textsecuregcm/configuration/MessageStoreConfiguration.java

@@ -0,0 +1,14 @@
+package org.whispersystems.textsecuregcm.configuration;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.hibernate.validator.constraints.NotEmpty;
+
+public class MessageStoreConfiguration {
+  @JsonProperty
+  @NotEmpty
+  private String url;
+
+  public String getUrl() {
+    return url;
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/configuration/MetricsConfiguration.java

@@ -1,27 +0,0 @@
-package org.whispersystems.textsecuregcm.configuration;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-public class MetricsConfiguration {
-
-  @JsonProperty
-  private String token;
-
-  @JsonProperty
-  private String host;
-
-  @JsonProperty
-  private boolean enabled = false;
-
-  public String getHost() {
-    return host;
-  }
-
-  public String getToken() {
-    return token;
-  }
-
-  public boolean isEnabled() {
-    return enabled && token != null && host != null;
-  }
-}

src/main/java/org/whispersystems/textsecuregcm/configuration/PushConfiguration.java

@@ -0,0 +1,40 @@
+package org.whispersystems.textsecuregcm.configuration;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.hibernate.validator.constraints.NotEmpty;
+
+import javax.validation.constraints.Min;
+
+public class PushConfiguration {
+  @JsonProperty
+  @NotEmpty
+  private String host;
+
+  @JsonProperty
+  @Min(1)
+  private int port;
+
+  @JsonProperty
+  @NotEmpty
+  private String username;
+
+  @JsonProperty
+  @NotEmpty
+  private String password;
+
+  public String getHost() {
+    return host;
+  }
+
+  public int getPort() {
+    return port;
+  }
+
+  public String getUsername() {
+    return username;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/configuration/RedPhoneConfiguration.java

@@ -0,0 +1,20 @@
+package org.whispersystems.textsecuregcm.configuration;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.base.Optional;
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.binary.Hex;
+
+public class RedPhoneConfiguration {
+
+  @JsonProperty
+  private String authKey;
+
+  public Optional<byte[]> getAuthorizationKey() throws DecoderException {
+    if (authKey == null || authKey.trim().length() == 0) {
+      return Optional.absent();
+    }
+
+    return Optional.of(Hex.decodeHex(authKey.toCharArray()));
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/controllers/AccountController.java

@@ -16,24 +16,26 @@
  */
 package org.whispersystems.textsecuregcm.controllers;
 
+import com.codahale.metrics.annotation.Timed;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Optional;
-import com.yammer.dropwizard.auth.Auth;
-import com.yammer.metrics.annotation.Timed;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.auth.AuthenticationCredentials;
 import org.whispersystems.textsecuregcm.auth.AuthorizationHeader;
+import org.whispersystems.textsecuregcm.auth.AuthorizationToken;
 import org.whispersystems.textsecuregcm.auth.InvalidAuthorizationHeaderException;
 import org.whispersystems.textsecuregcm.entities.AccountAttributes;
 import org.whispersystems.textsecuregcm.entities.ApnRegistrationId;
 import org.whispersystems.textsecuregcm.entities.GcmRegistrationId;
 import org.whispersystems.textsecuregcm.limits.RateLimiters;
+import org.whispersystems.textsecuregcm.providers.TimeProvider;
 import org.whispersystems.textsecuregcm.sms.SmsSender;
 import org.whispersystems.textsecuregcm.sms.TwilioSmsSender;
 import org.whispersystems.textsecuregcm.storage.Account;
 import org.whispersystems.textsecuregcm.storage.AccountsManager;
 import org.whispersystems.textsecuregcm.storage.Device;
+import org.whispersystems.textsecuregcm.storage.MessagesManager;
 import org.whispersystems.textsecuregcm.storage.PendingAccountsManager;
 import org.whispersystems.textsecuregcm.util.Util;
 import org.whispersystems.textsecuregcm.util.VerificationCode;
@@ -55,6 +57,8 @@ import java.io.IOException;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 
+import io.dropwizard.auth.Auth;
+
 @Path("/v1/accounts")
 public class AccountController {
 
@@ -64,16 +68,25 @@ public class AccountController {
   private final AccountsManager        accounts;
   private final RateLimiters           rateLimiters;
   private final SmsSender              smsSender;
+  private final MessagesManager        messagesManager;
+  private final TimeProvider           timeProvider;
+  private final Optional<byte[]>       authorizationKey;
 
   public AccountController(PendingAccountsManager pendingAccounts,
                            AccountsManager accounts,
                            RateLimiters rateLimiters,
-                           SmsSender smsSenderFactory)
+                           SmsSender smsSenderFactory,
+                           MessagesManager messagesManager,
+                           TimeProvider timeProvider,
+                           Optional<byte[]> authorizationKey)
   {
-    this.pendingAccounts = pendingAccounts;
-    this.accounts        = accounts;
-    this.rateLimiters    = rateLimiters;
-    this.smsSender       = smsSenderFactory;
+    this.pendingAccounts  = pendingAccounts;
+    this.accounts         = accounts;
+    this.rateLimiters     = rateLimiters;
+    this.smsSender        = smsSenderFactory;
+    this.messagesManager  = messagesManager;
+    this.timeProvider     = timeProvider;
+    this.authorizationKey = authorizationKey;
   }
 
   @Timed
@@ -139,39 +152,59 @@ public class AccountController {
         throw new WebApplicationException(Response.status(417).build());
       }
 
-      Device device = new Device();
-      device.setId(Device.MASTER_ID);
-      device.setAuthenticationCredentials(new AuthenticationCredentials(password));
-      device.setSignalingKey(accountAttributes.getSignalingKey());
-      device.setFetchesMessages(accountAttributes.getFetchesMessages());
-      device.setRegistrationId(accountAttributes.getRegistrationId());
-
-      Account account = new Account();
-      account.setNumber(number);
-      account.setSupportsSms(accountAttributes.getSupportsSms());
-      account.addDevice(device);
-
-      accounts.create(account);
-
-      pendingAccounts.remove(number);
-
-      logger.debug("Stored device...");
+      createAccount(number, password, accountAttributes);
     } catch (InvalidAuthorizationHeaderException e) {
       logger.info("Bad Authorization Header", e);
       throw new WebApplicationException(Response.status(401).build());
     }
   }
 
+  @Timed
+  @PUT
+  @Consumes(MediaType.APPLICATION_JSON)
+  @Path("/token/{verification_token}")
+  public void verifyToken(@PathParam("verification_token") String verificationToken,
+                          @HeaderParam("Authorization")    String authorizationHeader,
+                          @Valid                           AccountAttributes accountAttributes)
+      throws RateLimitExceededException
+  {
+    try {
+      AuthorizationHeader header   = AuthorizationHeader.fromFullHeader(authorizationHeader);
+      String              number   = header.getNumber();
+      String              password = header.getPassword();
 
+      rateLimiters.getVerifyLimiter().validate(number);
+
+      if (!authorizationKey.isPresent()) {
+        logger.debug("Attempt to authorize with key but not configured...");
+        throw new WebApplicationException(Response.status(403).build());
+      }
+
+      AuthorizationToken token = new AuthorizationToken(verificationToken, authorizationKey.get());
+
+      if (!token.isValid(number, timeProvider.getCurrentTimeMillis())) {
+        throw new WebApplicationException(Response.status(403).build());
+      }
+
+      createAccount(number, password, accountAttributes);
+    } catch (InvalidAuthorizationHeaderException e) {
+      logger.info("Bad authorization header", e);
+      throw new WebApplicationException(Response.status(401).build());
+    }
+  }
 
   @Timed
   @PUT
   @Path("/gcm/")
   @Consumes(MediaType.APPLICATION_JSON)
-  public void setGcmRegistrationId(@Auth Account account, @Valid GcmRegistrationId registrationId)  {
+  public void setGcmRegistrationId(@Auth Account account, @Valid GcmRegistrationId registrationId) {
     Device device = account.getAuthenticatedDevice().get();
     device.setApnId(null);
     device.setGcmId(registrationId.getGcmRegistrationId());
+
+    if (registrationId.isWebSocketChannel()) device.setFetchesMessages(true);
+    else                                     device.setFetchesMessages(false);
+
     accounts.update(account);
   }
 
@@ -181,6 +214,7 @@ public class AccountController {
   public void deleteGcmRegistrationId(@Auth Account account) {
     Device device = account.getAuthenticatedDevice().get();
     device.setGcmId(null);
+    device.setFetchesMessages(false);
     accounts.update(account);
   }
 
@@ -192,6 +226,7 @@ public class AccountController {
     Device device = account.getAuthenticatedDevice().get();
     device.setApnId(registrationId.getApnRegistrationId());
     device.setGcmId(null);
+    device.setFetchesMessages(true);
     accounts.update(account);
   }
 
@@ -201,6 +236,25 @@ public class AccountController {
   public void deleteApnRegistrationId(@Auth Account account) {
     Device device = account.getAuthenticatedDevice().get();
     device.setApnId(null);
+    device.setFetchesMessages(false);
+    accounts.update(account);
+  }
+
+  @Timed
+  @PUT
+  @Path("/wsc/")
+  public void setWebSocketChannelSupported(@Auth Account account) {
+    Device device = account.getAuthenticatedDevice().get();
+    device.setFetchesMessages(true);
+    accounts.update(account);
+  }
+
+  @Timed
+  @DELETE
+  @Path("/wsc/")
+  public void deleteWebSocketChannel(@Auth Account account) {
+    Device device = account.getAuthenticatedDevice().get();
+    device.setFetchesMessages(false);
     accounts.update(account);
   }
 
@@ -213,6 +267,26 @@ public class AccountController {
         encodedVerificationText)).build();
   }
 
+  private void createAccount(String number, String password, AccountAttributes accountAttributes) {
+    Device device = new Device();
+    device.setId(Device.MASTER_ID);
+    device.setAuthenticationCredentials(new AuthenticationCredentials(password));
+    device.setSignalingKey(accountAttributes.getSignalingKey());
+    device.setFetchesMessages(accountAttributes.getFetchesMessages());
+    device.setRegistrationId(accountAttributes.getRegistrationId());
+
+    Account account = new Account();
+    account.setNumber(number);
+    account.setSupportsSms(accountAttributes.getSupportsSms());
+    account.addDevice(device);
+
+    accounts.create(account);
+    messagesManager.clear(number);
+    pendingAccounts.remove(number);
+
+    logger.debug("Stored device...");
+  }
+
   @VisibleForTesting protected VerificationCode generateVerificationCode() {
     try {
       SecureRandom random = SecureRandom.getInstance("SHA1PRNG");

src/main/java/org/whispersystems/textsecuregcm/controllers/AttachmentController.java

@@ -17,9 +17,8 @@
 package org.whispersystems.textsecuregcm.controllers;
 
 import com.amazonaws.HttpMethod;
+import com.codahale.metrics.annotation.Timed;
 import com.google.common.base.Optional;
-import com.yammer.dropwizard.auth.Auth;
-import com.yammer.metrics.annotation.Timed;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.entities.AttachmentDescriptor;
@@ -44,6 +43,8 @@ import java.net.URL;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 
+import io.dropwizard.auth.Auth;
+
 
 @Path("/v1/attachments")
 public class AttachmentController {

src/main/java/org/whispersystems/textsecuregcm/controllers/DeviceController.java

@@ -16,10 +16,9 @@
  */
 package org.whispersystems.textsecuregcm.controllers;
 
+import com.codahale.metrics.annotation.Timed;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Optional;
-import com.yammer.dropwizard.auth.Auth;
-import com.yammer.metrics.annotation.Timed;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.auth.AuthenticationCredentials;
@@ -29,9 +28,10 @@ import org.whispersystems.textsecuregcm.entities.AccountAttributes;
 import org.whispersystems.textsecuregcm.entities.DeviceResponse;
 import org.whispersystems.textsecuregcm.limits.RateLimiters;
 import org.whispersystems.textsecuregcm.storage.Account;
-import org.whispersystems.textsecuregcm.storage.Device;
 import org.whispersystems.textsecuregcm.storage.AccountsManager;
+import org.whispersystems.textsecuregcm.storage.Device;
 import org.whispersystems.textsecuregcm.storage.PendingDevicesManager;
+import org.whispersystems.textsecuregcm.util.Util;
 import org.whispersystems.textsecuregcm.util.VerificationCode;
 
 import javax.validation.Valid;
@@ -45,9 +45,12 @@ import javax.ws.rs.Produces;
 import javax.ws.rs.WebApplicationException;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
+import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 
+import io.dropwizard.auth.Auth;
+
 @Path("/v1/devices")
 public class DeviceController {
 
@@ -68,7 +71,7 @@ public class DeviceController {
 
   @Timed
   @GET
-  @Path("/provisioning_code")
+  @Path("/provisioning/code")
   @Produces(MediaType.APPLICATION_JSON)
   public VerificationCode createDeviceToken(@Auth Account account)
       throws RateLimitExceededException
@@ -101,7 +104,7 @@ public class DeviceController {
       Optional<String> storedVerificationCode = pendingDevices.getCodeForNumber(number);
 
       if (!storedVerificationCode.isPresent() ||
-          !verificationCode.equals(storedVerificationCode.get()))
+          !MessageDigest.isEqual(verificationCode.getBytes(), storedVerificationCode.get().getBytes()))
       {
         throw new WebApplicationException(Response.status(403).build());
       }
@@ -117,6 +120,8 @@ public class DeviceController {
       device.setSignalingKey(accountAttributes.getSignalingKey());
       device.setFetchesMessages(accountAttributes.getFetchesMessages());
       device.setId(account.get().getNextDeviceId());
+      device.setRegistrationId(accountAttributes.getRegistrationId());
+      device.setLastSeen(Util.todayInMillis());
 
       account.get().addDevice(device);
       accounts.update(account.get());

src/main/java/org/whispersystems/textsecuregcm/controllers/DirectoryController.java

@@ -16,11 +16,11 @@
  */
 package org.whispersystems.textsecuregcm.controllers;
 
+import com.codahale.metrics.Histogram;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.SharedMetricRegistries;
+import com.codahale.metrics.annotation.Timed;
 import com.google.common.base.Optional;
-import com.yammer.dropwizard.auth.Auth;
-import com.yammer.metrics.Metrics;
-import com.yammer.metrics.annotation.Timed;
-import com.yammer.metrics.core.Histogram;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.entities.ClientContact;
@@ -30,6 +30,7 @@ import org.whispersystems.textsecuregcm.limits.RateLimiters;
 import org.whispersystems.textsecuregcm.storage.Account;
 import org.whispersystems.textsecuregcm.storage.DirectoryManager;
 import org.whispersystems.textsecuregcm.util.Base64;
+import org.whispersystems.textsecuregcm.util.Constants;
 
 import javax.validation.Valid;
 import javax.ws.rs.Consumes;
@@ -45,11 +46,15 @@ import java.io.IOException;
 import java.util.LinkedList;
 import java.util.List;
 
+import static com.codahale.metrics.MetricRegistry.name;
+import io.dropwizard.auth.Auth;
+
 @Path("/v1/directory")
 public class DirectoryController {
 
-  private final Logger    logger            = LoggerFactory.getLogger(DirectoryController.class);
-  private final Histogram contactsHistogram = Metrics.newHistogram(DirectoryController.class, "contacts");
+  private final Logger         logger            = LoggerFactory.getLogger(DirectoryController.class);
+  private final MetricRegistry metricRegistry    = SharedMetricRegistries.getOrCreate(Constants.METRICS_NAME);
+  private final Histogram      contactsHistogram = metricRegistry.histogram(name(getClass(), "contacts"));
 
   private final RateLimiters     rateLimiters;
   private final DirectoryManager directory;
@@ -69,7 +74,7 @@ public class DirectoryController {
     rateLimiters.getContactsLimiter().validate(account.getNumber());
 
     try {
-      Optional<ClientContact> contact = directory.get(Base64.decodeWithoutPadding(token));
+      Optional<ClientContact> contact = directory.get(decodeToken(token));
 
       if (contact.isPresent()) return Response.ok().entity(contact.get()).build();
       else                     return Response.status(404).build();
@@ -95,7 +100,7 @@ public class DirectoryController {
       List<byte[]> tokens = new LinkedList<>();
 
       for (String encodedContact : contacts.getContacts()) {
-        tokens.add(Base64.decodeWithoutPadding(encodedContact));
+        tokens.add(decodeToken(encodedContact));
       }
 
       List<ClientContact> intersection = directory.get(tokens);
@@ -105,4 +110,8 @@ public class DirectoryController {
       throw new WebApplicationException(Response.status(400).build());
     }
   }
+
+  private byte[] decodeToken(String encoded) throws IOException {
+    return Base64.decodeWithoutPadding(encoded.replace('-', '+').replace('_', '/'));
+  }
 }

src/main/java/org/whispersystems/textsecuregcm/controllers/FederationController.java

@@ -1,167 +1,19 @@
-/**
- * Copyright (C) 2013 Open WhisperSystems
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
 package org.whispersystems.textsecuregcm.controllers;
 
-import com.google.common.base.Optional;
-import com.yammer.dropwizard.auth.Auth;
-import com.yammer.metrics.annotation.Timed;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.whispersystems.textsecuregcm.entities.AccountCount;
-import org.whispersystems.textsecuregcm.entities.AttachmentUri;
-import org.whispersystems.textsecuregcm.entities.ClientContact;
-import org.whispersystems.textsecuregcm.entities.ClientContacts;
-import org.whispersystems.textsecuregcm.entities.IncomingMessageList;
-import org.whispersystems.textsecuregcm.entities.PreKey;
-import org.whispersystems.textsecuregcm.entities.UnstructuredPreKeyList;
-import org.whispersystems.textsecuregcm.federation.FederatedPeer;
-import org.whispersystems.textsecuregcm.federation.NonLimitedAccount;
-import org.whispersystems.textsecuregcm.storage.Account;
 import org.whispersystems.textsecuregcm.storage.AccountsManager;
-import org.whispersystems.textsecuregcm.util.Util;
 
-import javax.validation.Valid;
-import javax.ws.rs.GET;
-import javax.ws.rs.PUT;
-import javax.ws.rs.Path;
-import javax.ws.rs.PathParam;
-import javax.ws.rs.Produces;
-import javax.ws.rs.core.MediaType;
-import java.io.IOException;
-import java.util.LinkedList;
-import java.util.List;
-
-@Path("/v1/federation")
 public class FederationController {
 
-  private final Logger logger = LoggerFactory.getLogger(FederationController.class);
+  protected final AccountsManager      accounts;
+  protected final AttachmentController attachmentController;
+  protected final MessageController    messageController;
 
-  private static final int ACCOUNT_CHUNK_SIZE = 10000;
-
-  private final AccountsManager      accounts;
-  private final AttachmentController attachmentController;
-  private final KeysController       keysController;
-  private final MessageController    messageController;
-
-  public FederationController(AccountsManager      accounts,
+  public FederationController(AccountsManager accounts,
                               AttachmentController attachmentController,
-                              KeysController       keysController,
-                              MessageController     messageController)
+                              MessageController messageController)
   {
     this.accounts             = accounts;
     this.attachmentController = attachmentController;
-    this.keysController       = keysController;
     this.messageController    = messageController;
   }
-
-  @Timed
-  @GET
-  @Path("/attachment/{attachmentId}")
-  @Produces(MediaType.APPLICATION_JSON)
-  public AttachmentUri getSignedAttachmentUri(@Auth                      FederatedPeer peer,
-                                              @PathParam("attachmentId") long attachmentId)
-      throws IOException
-  {
-    return attachmentController.redirectToAttachment(new NonLimitedAccount("Unknown", -1, peer.getName()),
-                                                     attachmentId, Optional.<String>absent());
-  }
-
-  @Timed
-  @GET
-  @Path("/key/{number}")
-  @Produces(MediaType.APPLICATION_JSON)
-  public PreKey getKey(@Auth                FederatedPeer peer,
-                       @PathParam("number") String number)
-      throws IOException
-  {
-    try {
-      return keysController.get(new NonLimitedAccount("Unknown", -1, peer.getName()), number, Optional.<String>absent());
-    } catch (RateLimitExceededException e) {
-      logger.warn("Rate limiting on federated channel", e);
-      throw new IOException(e);
-    }
-  }
-
-  @Timed
-  @GET
-  @Path("/key/{number}/{device}")
-  @Produces(MediaType.APPLICATION_JSON)
-  public UnstructuredPreKeyList getKeys(@Auth                FederatedPeer peer,
-                                        @PathParam("number") String number,
-                                        @PathParam("device") String device)
-      throws IOException
-  {
-    try {
-      return keysController.getDeviceKey(new NonLimitedAccount("Unknown", -1, peer.getName()),
-                                         number, device, Optional.<String>absent());
-    } catch (RateLimitExceededException e) {
-      logger.warn("Rate limiting on federated channel", e);
-      throw new IOException(e);
-    }
-  }
-
-  @Timed
-  @PUT
-  @Path("/messages/{source}/{sourceDeviceId}/{destination}")
-  public void sendMessages(@Auth                        FederatedPeer peer,
-                           @PathParam("source")         String source,
-                           @PathParam("sourceDeviceId") long sourceDeviceId,
-                           @PathParam("destination")    String destination,
-                           @Valid                       IncomingMessageList messages)
-      throws IOException
-  {
-    try {
-      messages.setRelay(null);
-      messageController.sendMessage(new NonLimitedAccount(source, sourceDeviceId, peer.getName()), destination, messages);
-    } catch (RateLimitExceededException e) {
-      logger.warn("Rate limiting on federated channel", e);
-      throw new IOException(e);
-    }
-  }
-
-  @Timed
-  @GET
-  @Path("/user_count")
-  @Produces(MediaType.APPLICATION_JSON)
-  public AccountCount getUserCount(@Auth FederatedPeer peer) {
-    return new AccountCount((int)accounts.getCount());
-  }
-
-  @Timed
-  @GET
-  @Path("/user_tokens/{offset}")
-  @Produces(MediaType.APPLICATION_JSON)
-  public ClientContacts getUserTokens(@Auth                FederatedPeer peer,
-                                      @PathParam("offset") int offset)
-  {
-    List<Account>       accountList    = accounts.getAll(offset, ACCOUNT_CHUNK_SIZE);
-    List<ClientContact> clientContacts = new LinkedList<>();
-
-    for (Account account : accountList) {
-      byte[]        token         = Util.getContactToken(account.getNumber());
-      ClientContact clientContact = new ClientContact(token, null, account.getSupportsSms());
-
-      if (!account.isActive()) {
-        clientContact.setInactive(true);
-      }
-
-      clientContacts.add(clientContact);
-    }
-
-    return new ClientContacts(clientContacts);
-  }
 }

src/main/java/org/whispersystems/textsecuregcm/controllers/FederationControllerV1.java

@@ -0,0 +1,164 @@
+/**
+ * Copyright (C) 2013 Open WhisperSystems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.controllers;
+
+import com.codahale.metrics.annotation.Timed;
+import com.google.common.base.Optional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.whispersystems.textsecuregcm.entities.AccountCount;
+import org.whispersystems.textsecuregcm.entities.AttachmentUri;
+import org.whispersystems.textsecuregcm.entities.ClientContact;
+import org.whispersystems.textsecuregcm.entities.ClientContacts;
+import org.whispersystems.textsecuregcm.entities.IncomingMessageList;
+import org.whispersystems.textsecuregcm.entities.PreKeyResponseV1;
+import org.whispersystems.textsecuregcm.entities.PreKeyV1;
+import org.whispersystems.textsecuregcm.federation.FederatedPeer;
+import org.whispersystems.textsecuregcm.federation.NonLimitedAccount;
+import org.whispersystems.textsecuregcm.storage.Account;
+import org.whispersystems.textsecuregcm.storage.AccountsManager;
+import org.whispersystems.textsecuregcm.util.Util;
+
+import javax.validation.Valid;
+import javax.ws.rs.GET;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.List;
+
+import io.dropwizard.auth.Auth;
+
+@Path("/v1/federation")
+public class FederationControllerV1 extends FederationController {
+
+  private final Logger logger = LoggerFactory.getLogger(FederationControllerV1.class);
+
+  private static final int ACCOUNT_CHUNK_SIZE = 10000;
+
+  private final KeysControllerV1 keysControllerV1;
+
+  public FederationControllerV1(AccountsManager accounts,
+                                AttachmentController attachmentController,
+                                MessageController messageController,
+                                KeysControllerV1 keysControllerV1)
+  {
+    super(accounts, attachmentController, messageController);
+    this.keysControllerV1 = keysControllerV1;
+  }
+
+  @Timed
+  @GET
+  @Path("/attachment/{attachmentId}")
+  @Produces(MediaType.APPLICATION_JSON)
+  public AttachmentUri getSignedAttachmentUri(@Auth                      FederatedPeer peer,
+                                              @PathParam("attachmentId") long attachmentId)
+      throws IOException
+  {
+    return attachmentController.redirectToAttachment(new NonLimitedAccount("Unknown", -1, peer.getName()),
+                                                     attachmentId, Optional.<String>absent());
+  }
+
+  @Timed
+  @GET
+  @Path("/key/{number}")
+  @Produces(MediaType.APPLICATION_JSON)
+  public Optional<PreKeyV1> getKey(@Auth                FederatedPeer peer,
+                                   @PathParam("number") String number)
+      throws IOException
+  {
+    try {
+      return keysControllerV1.get(new NonLimitedAccount("Unknown", -1, peer.getName()),
+                                  number, Optional.<String>absent());
+    } catch (RateLimitExceededException e) {
+      logger.warn("Rate limiting on federated channel", e);
+      throw new IOException(e);
+    }
+  }
+
+  @Timed
+  @GET
+  @Path("/key/{number}/{device}")
+  @Produces(MediaType.APPLICATION_JSON)
+  public Optional<PreKeyResponseV1> getKeysV1(@Auth                FederatedPeer peer,
+                                              @PathParam("number") String number,
+                                              @PathParam("device") String device)
+      throws IOException
+  {
+    try {
+      return keysControllerV1.getDeviceKey(new NonLimitedAccount("Unknown", -1, peer.getName()),
+                                           number, device, Optional.<String>absent());
+    } catch (RateLimitExceededException e) {
+      logger.warn("Rate limiting on federated channel", e);
+      throw new IOException(e);
+    }
+  }
+
+  @Timed
+  @PUT
+  @Path("/messages/{source}/{sourceDeviceId}/{destination}")
+  public void sendMessages(@Auth                        FederatedPeer peer,
+                           @PathParam("source")         String source,
+                           @PathParam("sourceDeviceId") long sourceDeviceId,
+                           @PathParam("destination")    String destination,
+                           @Valid                       IncomingMessageList messages)
+      throws IOException
+  {
+    try {
+      messages.setRelay(null);
+      messageController.sendMessage(new NonLimitedAccount(source, sourceDeviceId, peer.getName()), destination, messages);
+    } catch (RateLimitExceededException e) {
+      logger.warn("Rate limiting on federated channel", e);
+      throw new IOException(e);
+    }
+  }
+
+  @Timed
+  @GET
+  @Path("/user_count")
+  @Produces(MediaType.APPLICATION_JSON)
+  public AccountCount getUserCount(@Auth FederatedPeer peer) {
+    return new AccountCount((int)accounts.getCount());
+  }
+
+  @Timed
+  @GET
+  @Path("/user_tokens/{offset}")
+  @Produces(MediaType.APPLICATION_JSON)
+  public ClientContacts getUserTokens(@Auth                FederatedPeer peer,
+                                      @PathParam("offset") int offset)
+  {
+    List<Account>       accountList    = accounts.getAll(offset, ACCOUNT_CHUNK_SIZE);
+    List<ClientContact> clientContacts = new LinkedList<>();
+
+    for (Account account : accountList) {
+      byte[]        token         = Util.getContactToken(account.getNumber());
+      ClientContact clientContact = new ClientContact(token, null, account.getSupportsSms());
+
+      if (!account.isActive()) {
+        clientContact.setInactive(true);
+      }
+
+      clientContacts.add(clientContact);
+    }
+
+    return new ClientContacts(clientContacts);
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/controllers/FederationControllerV2.java

@@ -0,0 +1,51 @@
+package org.whispersystems.textsecuregcm.controllers;
+
+import com.codahale.metrics.annotation.Timed;
+import com.google.common.base.Optional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.whispersystems.textsecuregcm.entities.PreKeyResponseV2;
+import org.whispersystems.textsecuregcm.federation.FederatedPeer;
+import org.whispersystems.textsecuregcm.federation.NonLimitedAccount;
+import org.whispersystems.textsecuregcm.storage.AccountsManager;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import java.io.IOException;
+
+import io.dropwizard.auth.Auth;
+
+@Path("/v2/federation")
+public class FederationControllerV2 extends FederationController {
+
+  private final Logger logger = LoggerFactory.getLogger(FederationControllerV2.class);
+
+  private final KeysControllerV2 keysControllerV2;
+
+  public FederationControllerV2(AccountsManager accounts, AttachmentController attachmentController, MessageController messageController, KeysControllerV2 keysControllerV2) {
+    super(accounts, attachmentController, messageController);
+    this.keysControllerV2 = keysControllerV2;
+  }
+
+  @Timed
+  @GET
+  @Path("/key/{number}/{device}")
+  @Produces(MediaType.APPLICATION_JSON)
+  public Optional<PreKeyResponseV2> getKeysV2(@Auth                FederatedPeer peer,
+                                              @PathParam("number") String number,
+                                              @PathParam("device") String device)
+      throws IOException
+  {
+    try {
+      return keysControllerV2.getDeviceKeys(new NonLimitedAccount("Unknown", -1, peer.getName()),
+                                            number, device, Optional.<String>absent());
+    } catch (RateLimitExceededException e) {
+      logger.warn("Rate limiting on federated channel", e);
+      throw new IOException(e);
+    }
+  }
+
+}

src/main/java/org/whispersystems/textsecuregcm/controllers/InvalidDestinationException.java

@@ -0,0 +1,7 @@
+package org.whispersystems.textsecuregcm.controllers;
+
+public class InvalidDestinationException extends Exception {
+  public InvalidDestinationException(String message) {
+    super(message);
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/controllers/KeepAliveController.java

@@ -0,0 +1,20 @@
+package org.whispersystems.textsecuregcm.controllers;
+
+import com.codahale.metrics.annotation.Timed;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.core.Response;
+
+
+@Path("/v1/keepalive")
+public class KeepAliveController {
+
+  @Timed
+  @GET
+  public Response getKeepAlive() {
+    return Response.ok().build();
+  }
+
+}

src/main/java/org/whispersystems/textsecuregcm/controllers/KeysController.java

@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2013 Open WhisperSystems
+ * Copyright (C) 2014 Open Whisper Systems
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -16,46 +16,32 @@
  */
 package org.whispersystems.textsecuregcm.controllers;
 
+import com.codahale.metrics.annotation.Timed;
 import com.google.common.base.Optional;
-import com.yammer.dropwizard.auth.Auth;
-import com.yammer.metrics.annotation.Timed;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.whispersystems.textsecuregcm.entities.PreKey;
-import org.whispersystems.textsecuregcm.entities.PreKeyList;
-import org.whispersystems.textsecuregcm.entities.PreKeyStatus;
-import org.whispersystems.textsecuregcm.entities.UnstructuredPreKeyList;
+import org.whispersystems.textsecuregcm.entities.PreKeyCount;
 import org.whispersystems.textsecuregcm.federation.FederatedClientManager;
-import org.whispersystems.textsecuregcm.federation.NoSuchPeerException;
 import org.whispersystems.textsecuregcm.limits.RateLimiters;
 import org.whispersystems.textsecuregcm.storage.Account;
 import org.whispersystems.textsecuregcm.storage.AccountsManager;
 import org.whispersystems.textsecuregcm.storage.Device;
+import org.whispersystems.textsecuregcm.storage.KeyRecord;
 import org.whispersystems.textsecuregcm.storage.Keys;
 
-import javax.validation.Valid;
-import javax.ws.rs.Consumes;
 import javax.ws.rs.GET;
-import javax.ws.rs.PUT;
-import javax.ws.rs.Path;
-import javax.ws.rs.PathParam;
 import javax.ws.rs.Produces;
-import javax.ws.rs.QueryParam;
 import javax.ws.rs.WebApplicationException;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
-import java.util.LinkedList;
 import java.util.List;
 
-@Path("/v1/keys")
+import io.dropwizard.auth.Auth;
+
 public class KeysController {
 
-  private final Logger logger = LoggerFactory.getLogger(KeysController.class);
-
-  private final RateLimiters           rateLimiters;
-  private final Keys                   keys;
-  private final AccountsManager        accounts;
-  private final FederatedClientManager federatedClientManager;
+  protected final RateLimiters           rateLimiters;
+  protected final Keys                   keys;
+  protected final AccountsManager        accounts;
+  protected final FederatedClientManager federatedClientManager;
 
   public KeysController(RateLimiters rateLimiters, Keys keys, AccountsManager accounts,
                         FederatedClientManager federatedClientManager)
@@ -66,119 +52,65 @@ public class KeysController {
     this.federatedClientManager = federatedClientManager;
   }
 
-  @Timed
-  @PUT
-  @Consumes(MediaType.APPLICATION_JSON)
-  public void setKeys(@Auth Account account, @Valid PreKeyList preKeys)  {
-    Device device      = account.getAuthenticatedDevice().get();
-    String identityKey = preKeys.getLastResortKey().getIdentityKey();
-
-    if (!identityKey.equals(account.getIdentityKey())) {
-      account.setIdentityKey(identityKey);
-      accounts.update(account);
-    }
-
-    keys.store(account.getNumber(), device.getId(), preKeys.getKeys(), preKeys.getLastResortKey());
-  }
-
   @Timed
   @GET
-  @Path("/")
   @Produces(MediaType.APPLICATION_JSON)
-  public PreKeyStatus getStatus(@Auth Account account) {
+  public PreKeyCount getStatus(@Auth Account account) {
     int count = keys.getCount(account.getNumber(), account.getAuthenticatedDevice().get().getId());
 
     if (count > 0) {
       count = count - 1;
     }
 
-    return new PreKeyStatus(count);
+    return new PreKeyCount(count);
   }
 
-  @Timed
-  @GET
-  @Path("/{number}/{device_id}")
-  @Produces(MediaType.APPLICATION_JSON)
-  public UnstructuredPreKeyList getDeviceKey(@Auth                   Account account,
-                                             @PathParam("number")    String number,
-                                             @PathParam("device_id") String deviceId,
-                                             @QueryParam("relay")    Optional<String> relay)
-      throws RateLimitExceededException
+  protected TargetKeys getLocalKeys(String number, String deviceIdSelector)
+      throws NoSuchUserException
   {
-    try {
-      if (account.isRateLimited()) {
-        rateLimiters.getPreKeysLimiter().validate(account.getNumber() +  "__" + number + "." + deviceId);
-      }
-
-      Optional<UnstructuredPreKeyList> results;
-
-      if (!relay.isPresent()) results = getLocalKeys(number, deviceId);
-      else                    results = federatedClientManager.getClient(relay.get()).getKeys(number, deviceId);
-
-      if (results.isPresent()) return results.get();
-      else                     throw new WebApplicationException(Response.status(404).build());
-    } catch (NoSuchPeerException e) {
-      throw new WebApplicationException(Response.status(404).build());
-    }
-  }
-
-  @Timed
-  @GET
-  @Path("/{number}")
-  @Produces(MediaType.APPLICATION_JSON)
-  public PreKey get(@Auth                Account account,
-                    @PathParam("number") String number,
-                    @QueryParam("relay") Optional<String> relay)
-      throws RateLimitExceededException
-  {
-    UnstructuredPreKeyList results = getDeviceKey(account, number, String.valueOf(Device.MASTER_ID), relay);
-    return results.getKeys().get(0);
-  }
-
-  private Optional<UnstructuredPreKeyList> getLocalKeys(String number, String deviceIdSelector) {
     Optional<Account> destination = accounts.get(number);
 
     if (!destination.isPresent() || !destination.get().isActive()) {
-      return Optional.absent();
+      throw new NoSuchUserException("Target account is inactive");
     }
 
     try {
       if (deviceIdSelector.equals("*")) {
-        Optional<UnstructuredPreKeyList> preKeys = keys.get(number);
-        return getActiveKeys(destination.get(), preKeys);
+        Optional<List<KeyRecord>> preKeys = keys.get(number);
+        return new TargetKeys(destination.get(), preKeys);
       }
 
       long             deviceId     = Long.parseLong(deviceIdSelector);
       Optional<Device> targetDevice = destination.get().getDevice(deviceId);
 
       if (!targetDevice.isPresent() || !targetDevice.get().isActive()) {
-        return Optional.absent();
+        throw new NoSuchUserException("Target device is inactive.");
       }
 
-      Optional<UnstructuredPreKeyList> preKeys = keys.get(number, deviceId);
-      return getActiveKeys(destination.get(), preKeys);
+      Optional<List<KeyRecord>> preKeys = keys.get(number, deviceId);
+      return new TargetKeys(destination.get(), preKeys);
     } catch (NumberFormatException e) {
       throw new WebApplicationException(Response.status(422).build());
     }
   }
 
-  private Optional<UnstructuredPreKeyList> getActiveKeys(Account destination,
-                                                         Optional<UnstructuredPreKeyList> preKeys)
-  {
-    if (!preKeys.isPresent()) return Optional.absent();
 
-    List<PreKey> filteredKeys = new LinkedList<>();
+  public static class TargetKeys {
+    private final Account         destination;
+    private final Optional<List<KeyRecord>> keys;
 
-    for (PreKey preKey : preKeys.get().getKeys()) {
-      Optional<Device> device = destination.getDevice(preKey.getDeviceId());
-
-      if (device.isPresent() && device.get().isActive()) {
-        preKey.setRegistrationId(device.get().getRegistrationId());
-        filteredKeys.add(preKey);
-      }
+    public TargetKeys(Account destination, Optional<List<KeyRecord>> keys) {
+      this.destination = destination;
+      this.keys        = keys;
     }
 
-    if (filteredKeys.isEmpty()) return Optional.absent();
-    else                        return Optional.of(new UnstructuredPreKeyList(filteredKeys));
+    public Optional<List<KeyRecord>> getKeys() {
+      return keys;
+    }
+
+    public Account getDestination() {
+      return destination;
+    }
   }
+
 }

src/main/java/org/whispersystems/textsecuregcm/controllers/KeysControllerV1.java

@@ -0,0 +1,136 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.controllers;
+
+import com.codahale.metrics.annotation.Timed;
+import com.google.common.base.Optional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.whispersystems.textsecuregcm.entities.PreKeyResponseV1;
+import org.whispersystems.textsecuregcm.entities.PreKeyStateV1;
+import org.whispersystems.textsecuregcm.entities.PreKeyV1;
+import org.whispersystems.textsecuregcm.federation.FederatedClientManager;
+import org.whispersystems.textsecuregcm.federation.NoSuchPeerException;
+import org.whispersystems.textsecuregcm.limits.RateLimiters;
+import org.whispersystems.textsecuregcm.storage.Account;
+import org.whispersystems.textsecuregcm.storage.AccountsManager;
+import org.whispersystems.textsecuregcm.storage.Device;
+import org.whispersystems.textsecuregcm.storage.KeyRecord;
+import org.whispersystems.textsecuregcm.storage.Keys;
+
+import javax.validation.Valid;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.GET;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import java.util.LinkedList;
+import java.util.List;
+
+import io.dropwizard.auth.Auth;
+
+@Path("/v1/keys")
+public class KeysControllerV1 extends KeysController {
+
+  private final Logger logger = LoggerFactory.getLogger(KeysControllerV1.class);
+
+  public KeysControllerV1(RateLimiters rateLimiters, Keys keys, AccountsManager accounts,
+                          FederatedClientManager federatedClientManager)
+  {
+    super(rateLimiters, keys, accounts, federatedClientManager);
+  }
+
+  @Timed
+  @PUT
+  @Consumes(MediaType.APPLICATION_JSON)
+  public void setKeys(@Auth Account account, @Valid PreKeyStateV1 preKeys)  {
+    Device device      = account.getAuthenticatedDevice().get();
+    String identityKey = preKeys.getLastResortKey().getIdentityKey();
+
+    if (!identityKey.equals(account.getIdentityKey())) {
+      account.setIdentityKey(identityKey);
+      accounts.update(account);
+    }
+
+    keys.store(account.getNumber(), device.getId(), preKeys.getKeys(), preKeys.getLastResortKey());
+  }
+
+  @Timed
+  @GET
+  @Path("/{number}/{device_id}")
+  @Produces(MediaType.APPLICATION_JSON)
+  public Optional<PreKeyResponseV1> getDeviceKey(@Auth                   Account account,
+                                                 @PathParam("number")    String number,
+                                                 @PathParam("device_id") String deviceId,
+                                                 @QueryParam("relay")    Optional<String> relay)
+      throws RateLimitExceededException
+  {
+    try {
+      if (account.isRateLimited()) {
+        rateLimiters.getPreKeysLimiter().validate(account.getNumber() +  "__" + number + "." + deviceId);
+      }
+
+      if (relay.isPresent()) {
+        return federatedClientManager.getClient(relay.get()).getKeysV1(number, deviceId);
+      }
+
+      TargetKeys targetKeys = getLocalKeys(number, deviceId);
+
+      if (!targetKeys.getKeys().isPresent()) {
+        return Optional.absent();
+      }
+
+      List<PreKeyV1> preKeys     = new LinkedList<>();
+      Account        destination = targetKeys.getDestination();
+
+      for (KeyRecord record : targetKeys.getKeys().get()) {
+        Optional<Device> device = destination.getDevice(record.getDeviceId());
+        if (device.isPresent() && device.get().isActive()) {
+          preKeys.add(new PreKeyV1(record.getDeviceId(), record.getKeyId(),
+                                   record.getPublicKey(), destination.getIdentityKey(),
+                                   device.get().getRegistrationId()));
+        }
+      }
+
+      if (preKeys.isEmpty()) return Optional.absent();
+      else                   return Optional.of(new PreKeyResponseV1(preKeys));
+    } catch (NoSuchPeerException | NoSuchUserException e) {
+      throw new WebApplicationException(Response.status(404).build());
+    }
+  }
+
+  @Timed
+  @GET
+  @Path("/{number}")
+  @Produces(MediaType.APPLICATION_JSON)
+  public Optional<PreKeyV1> get(@Auth                Account account,
+                                @PathParam("number") String number,
+                                @QueryParam("relay") Optional<String> relay)
+      throws RateLimitExceededException
+  {
+    Optional<PreKeyResponseV1> results = getDeviceKey(account, number, String.valueOf(Device.MASTER_ID), relay);
+
+    if (results.isPresent()) return Optional.of(results.get().getKeys().get(0));
+    else                     return Optional.absent();
+  }
+
+}

src/main/java/org/whispersystems/textsecuregcm/controllers/KeysControllerV2.java

@@ -0,0 +1,156 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.controllers;
+
+
+import com.codahale.metrics.annotation.Timed;
+import com.google.common.base.Optional;
+import org.whispersystems.textsecuregcm.entities.SignedPreKey;
+import org.whispersystems.textsecuregcm.entities.PreKeyResponseItemV2;
+import org.whispersystems.textsecuregcm.entities.PreKeyResponseV2;
+import org.whispersystems.textsecuregcm.entities.PreKeyStateV2;
+import org.whispersystems.textsecuregcm.entities.PreKeyV2;
+import org.whispersystems.textsecuregcm.federation.FederatedClientManager;
+import org.whispersystems.textsecuregcm.federation.NoSuchPeerException;
+import org.whispersystems.textsecuregcm.limits.RateLimiters;
+import org.whispersystems.textsecuregcm.storage.Account;
+import org.whispersystems.textsecuregcm.storage.AccountsManager;
+import org.whispersystems.textsecuregcm.storage.Device;
+import org.whispersystems.textsecuregcm.storage.KeyRecord;
+import org.whispersystems.textsecuregcm.storage.Keys;
+
+import javax.validation.Valid;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.GET;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import java.util.LinkedList;
+import java.util.List;
+
+import io.dropwizard.auth.Auth;
+
+@Path("/v2/keys")
+public class KeysControllerV2 extends KeysController {
+
+  public KeysControllerV2(RateLimiters rateLimiters, Keys keys, AccountsManager accounts,
+                          FederatedClientManager federatedClientManager)
+  {
+    super(rateLimiters, keys, accounts, federatedClientManager);
+  }
+
+
+  @Timed
+  @PUT
+  @Consumes(MediaType.APPLICATION_JSON)
+  public void setKeys(@Auth Account account, @Valid PreKeyStateV2 preKeys)  {
+    Device  device        = account.getAuthenticatedDevice().get();
+    boolean updateAccount = false;
+
+    if (!preKeys.getSignedPreKey().equals(device.getSignedPreKey())) {
+      device.setSignedPreKey(preKeys.getSignedPreKey());
+      updateAccount = true;
+    }
+
+    if (!preKeys.getIdentityKey().equals(account.getIdentityKey())) {
+      account.setIdentityKey(preKeys.getIdentityKey());
+      updateAccount = true;
+    }
+
+    if (updateAccount) {
+      accounts.update(account);
+    }
+
+    keys.store(account.getNumber(), device.getId(), preKeys.getPreKeys(), preKeys.getLastResortKey());
+  }
+
+  @Timed
+  @GET
+  @Path("/{number}/{device_id}")
+  @Produces(MediaType.APPLICATION_JSON)
+  public Optional<PreKeyResponseV2> getDeviceKeys(@Auth                   Account account,
+                                                  @PathParam("number")    String number,
+                                                  @PathParam("device_id") String deviceId,
+                                                  @QueryParam("relay")    Optional<String> relay)
+      throws RateLimitExceededException
+  {
+    try {
+      if (account.isRateLimited()) {
+        rateLimiters.getPreKeysLimiter().validate(account.getNumber() +  "__" + number + "." + deviceId);
+      }
+
+      if (relay.isPresent()) {
+        return federatedClientManager.getClient(relay.get()).getKeysV2(number, deviceId);
+      }
+
+      TargetKeys                 targetKeys  = getLocalKeys(number, deviceId);
+      Account                    destination = targetKeys.getDestination();
+      List<PreKeyResponseItemV2> devices     = new LinkedList<>();
+
+      for (Device device : destination.getDevices()) {
+        if (device.isActive() && (deviceId.equals("*") || device.getId() == Long.parseLong(deviceId))) {
+          SignedPreKey signedPreKey = device.getSignedPreKey();
+          PreKeyV2     preKey       = null;
+
+          if (targetKeys.getKeys().isPresent()) {
+            for (KeyRecord keyRecord : targetKeys.getKeys().get()) {
+              if (keyRecord.getDeviceId() == device.getId()) {
+                preKey = new PreKeyV2(keyRecord.getKeyId(), keyRecord.getPublicKey());
+              }
+            }
+          }
+
+          if (signedPreKey != null || preKey != null) {
+            devices.add(new PreKeyResponseItemV2(device.getId(), device.getRegistrationId(), signedPreKey, preKey));
+          }
+        }
+      }
+
+      if (devices.isEmpty()) return Optional.absent();
+      else                   return Optional.of(new PreKeyResponseV2(destination.getIdentityKey(), devices));
+    } catch (NoSuchPeerException | NoSuchUserException e) {
+      throw new WebApplicationException(Response.status(404).build());
+    }
+  }
+
+  @Timed
+  @PUT
+  @Path("/signed")
+  @Consumes(MediaType.APPLICATION_JSON)
+  public void setSignedKey(@Auth Account account, @Valid SignedPreKey signedPreKey) {
+    Device device = account.getAuthenticatedDevice().get();
+    device.setSignedPreKey(signedPreKey);
+    accounts.update(account);
+  }
+
+  @Timed
+  @GET
+  @Path("/signed")
+  @Produces(MediaType.APPLICATION_JSON)
+  public Optional<SignedPreKey> getSignedKey(@Auth Account account) {
+    Device       device       = account.getAuthenticatedDevice().get();
+    SignedPreKey signedPreKey = device.getSignedPreKey();
+
+    if (signedPreKey != null) return Optional.of(signedPreKey);
+    else                      return Optional.absent();
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/controllers/MessageController.java

@@ -16,10 +16,9 @@
  */
 package org.whispersystems.textsecuregcm.controllers;
 
+import com.codahale.metrics.annotation.Timed;
 import com.google.common.base.Optional;
 import com.google.protobuf.ByteString;
-import com.yammer.dropwizard.auth.Auth;
-import com.yammer.metrics.annotation.Timed;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.entities.IncomingMessage;
@@ -27,6 +26,7 @@ import org.whispersystems.textsecuregcm.entities.IncomingMessageList;
 import org.whispersystems.textsecuregcm.entities.MessageProtos.OutgoingMessageSignal;
 import org.whispersystems.textsecuregcm.entities.MessageResponse;
 import org.whispersystems.textsecuregcm.entities.MismatchedDevices;
+import org.whispersystems.textsecuregcm.entities.SendMessageResponse;
 import org.whispersystems.textsecuregcm.entities.StaleDevices;
 import org.whispersystems.textsecuregcm.federation.FederatedClient;
 import org.whispersystems.textsecuregcm.federation.FederatedClientManager;
@@ -39,6 +39,7 @@ import org.whispersystems.textsecuregcm.storage.Account;
 import org.whispersystems.textsecuregcm.storage.AccountsManager;
 import org.whispersystems.textsecuregcm.storage.Device;
 import org.whispersystems.textsecuregcm.util.Base64;
+import org.whispersystems.textsecuregcm.util.Util;
 
 import javax.validation.Valid;
 import javax.ws.rs.Consumes;
@@ -56,6 +57,8 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
 
+import io.dropwizard.auth.Auth;
+
 @Path("/v1/messages")
 public class MessageController {
 
@@ -81,16 +84,21 @@ public class MessageController {
   @Path("/{destination}")
   @PUT
   @Consumes(MediaType.APPLICATION_JSON)
-  public void sendMessage(@Auth                     Account source,
-                          @PathParam("destination") String destinationName,
-                          @Valid                    IncomingMessageList messages)
+  @Produces(MediaType.APPLICATION_JSON)
+  public SendMessageResponse sendMessage(@Auth                     Account source,
+                                         @PathParam("destination") String destinationName,
+                                         @Valid                    IncomingMessageList messages)
       throws IOException, RateLimitExceededException
   {
     rateLimiters.getMessagesLimiter().validate(source.getNumber());
 
     try {
-      if (messages.getRelay() == null) sendLocalMessage(source, destinationName, messages);
-      else                             sendRelayMessage(source, destinationName, messages);
+      boolean isSyncMessage = source.getNumber().equals(destinationName);
+
+      if (Util.isEmpty(messages.getRelay())) sendLocalMessage(source, destinationName, messages, isSyncMessage);
+      else                                   sendRelayMessage(source, destinationName, messages, isSyncMessage);
+
+      return new SendMessageResponse(!isSyncMessage && source.getActiveDeviceCount() > 1);
     } catch (NoSuchUserException e) {
       throw new WebApplicationException(Response.status(404).build());
     } catch (MismatchedDevicesException e) {
@@ -104,6 +112,8 @@ public class MessageController {
                                                 .type(MediaType.APPLICATION_JSON)
                                                 .entity(new StaleDevices(e.getStaleDevices()))
                                                 .build());
+    } catch (InvalidDestinationException e) {
+      throw new WebApplicationException(Response.status(400).build());
     }
   }
 
@@ -129,19 +139,23 @@ public class MessageController {
 
   private void sendLocalMessage(Account source,
                                 String destinationName,
-                                IncomingMessageList messages)
+                                IncomingMessageList messages,
+                                boolean isSyncMessage)
       throws NoSuchUserException, MismatchedDevicesException, IOException, StaleDevicesException
   {
-    Account destination = getDestinationAccount(destinationName);
+    Account destination;
 
-    validateCompleteDeviceList(destination, messages.getMessages());
+    if (!isSyncMessage) destination = getDestinationAccount(destinationName);
+    else                destination = source;
+
+    validateCompleteDeviceList(destination, messages.getMessages(), isSyncMessage);
     validateRegistrationIds(destination, messages.getMessages());
 
     for (IncomingMessage incomingMessage : messages.getMessages()) {
       Optional<Device> destinationDevice = destination.getDevice(incomingMessage.getDestinationDeviceId());
 
       if (destinationDevice.isPresent()) {
-        sendLocalMessage(source, destination, destinationDevice.get(), incomingMessage);
+        sendLocalMessage(source, destination, destinationDevice.get(), messages.getTimestamp(), incomingMessage);
       }
     }
   }
@@ -149,6 +163,7 @@ public class MessageController {
   private void sendLocalMessage(Account source,
                                 Account destinationAccount,
                                 Device destinationDevice,
+                                long timestamp,
                                 IncomingMessage incomingMessage)
       throws NoSuchUserException, IOException
   {
@@ -158,7 +173,7 @@ public class MessageController {
 
       messageBuilder.setType(incomingMessage.getType())
                     .setSource(source.getNumber())
-                    .setTimestamp(System.currentTimeMillis())
+                    .setTimestamp(timestamp == 0 ? System.currentTimeMillis() : timestamp)
                     .setSourceDevice((int)source.getAuthenticatedDevice().get().getId());
 
       if (messageBody.isPresent()) {
@@ -181,9 +196,12 @@ public class MessageController {
 
   private void sendRelayMessage(Account source,
                                 String destinationName,
-                                IncomingMessageList messages)
-      throws IOException, NoSuchUserException
+                                IncomingMessageList messages,
+                                boolean isSyncMessage)
+      throws IOException, NoSuchUserException, InvalidDestinationException
   {
+    if (isSyncMessage) throw new InvalidDestinationException("Transcript messages can't be relayed!");
+
     try {
       FederatedClient client = federatedClientManager.getClient(messages.getRelay());
       client.sendMessages(source.getNumber(), source.getAuthenticatedDevice().get().getId(),
@@ -226,7 +244,9 @@ public class MessageController {
     }
   }
 
-  private void validateCompleteDeviceList(Account account, List<IncomingMessage> messages)
+  private void validateCompleteDeviceList(Account account,
+                                          List<IncomingMessage> messages,
+                                          boolean isSyncMessage)
       throws MismatchedDevicesException
   {
     Set<Long> messageDeviceIds = new HashSet<>();
@@ -240,7 +260,9 @@ public class MessageController {
     }
 
     for (Device device : account.getDevices()) {
-      if (device.isActive()) {
+      if (device.isActive() &&
+          !(isSyncMessage && device.getId() == account.getAuthenticatedDevice().get().getId()))
+      {
         accountDeviceIds.add(device.getId());
 
         if (!messageDeviceIds.contains(device.getId())) {

src/main/java/org/whispersystems/textsecuregcm/controllers/MismatchedDevicesException.java

@@ -1,7 +1,6 @@
 package org.whispersystems.textsecuregcm.controllers;
 
 import java.util.List;
-import java.util.Set;
 
 public class MismatchedDevicesException extends Exception {
 

src/main/java/org/whispersystems/textsecuregcm/controllers/NoSuchUserException.java

@@ -16,8 +16,6 @@
  */
 package org.whispersystems.textsecuregcm.controllers;
 
-import org.whispersystems.textsecuregcm.federation.NoSuchPeerException;
-
 import java.util.LinkedList;
 import java.util.List;
 
@@ -27,7 +25,7 @@ public class NoSuchUserException extends Exception {
 
   public NoSuchUserException(String user) {
     super(user);
-    missing = new LinkedList<String>();
+    missing = new LinkedList<>();
     missing.add(user);
   }
 

src/main/java/org/whispersystems/textsecuregcm/controllers/ProvisioningController.java

@@ -0,0 +1,55 @@
+package org.whispersystems.textsecuregcm.controllers;
+
+import com.codahale.metrics.annotation.Timed;
+import org.whispersystems.textsecuregcm.entities.ProvisioningMessage;
+import org.whispersystems.textsecuregcm.limits.RateLimiters;
+import org.whispersystems.textsecuregcm.push.PushSender;
+import org.whispersystems.textsecuregcm.push.WebsocketSender;
+import org.whispersystems.textsecuregcm.storage.Account;
+import org.whispersystems.textsecuregcm.util.Base64;
+import org.whispersystems.textsecuregcm.websocket.InvalidWebsocketAddressException;
+import org.whispersystems.textsecuregcm.websocket.ProvisioningAddress;
+
+import javax.validation.Valid;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import java.io.IOException;
+
+import io.dropwizard.auth.Auth;
+
+@Path("/v1/provisioning")
+public class ProvisioningController {
+
+  private final RateLimiters    rateLimiters;
+  private final WebsocketSender websocketSender;
+
+  public ProvisioningController(RateLimiters rateLimiters, PushSender pushSender) {
+    this.rateLimiters    = rateLimiters;
+    this.websocketSender = pushSender.getWebSocketSender();
+  }
+
+  @Timed
+  @Path("/{destination}")
+  @PUT
+  @Consumes(MediaType.APPLICATION_JSON)
+  @Produces(MediaType.APPLICATION_JSON)
+  public void sendProvisioningMessage(@Auth                     Account source,
+                                      @PathParam("destination") String destinationName,
+                                      @Valid                    ProvisioningMessage message)
+      throws RateLimitExceededException, InvalidWebsocketAddressException, IOException
+  {
+    rateLimiters.getMessagesLimiter().validate(source.getNumber());
+
+    if (!websocketSender.sendProvisioningMessage(new ProvisioningAddress(destinationName),
+                                                 Base64.decode(message.getBody())))
+    {
+      throw new WebApplicationException(Response.Status.NOT_FOUND);
+    }
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/controllers/ReceiptController.java

@@ -0,0 +1,111 @@
+package org.whispersystems.textsecuregcm.controllers;
+
+import com.codahale.metrics.annotation.Timed;
+import com.google.common.base.Optional;
+import org.whispersystems.textsecuregcm.federation.FederatedClientManager;
+import org.whispersystems.textsecuregcm.federation.NoSuchPeerException;
+import org.whispersystems.textsecuregcm.push.NotPushRegisteredException;
+import org.whispersystems.textsecuregcm.push.PushSender;
+import org.whispersystems.textsecuregcm.push.TransientPushFailureException;
+import org.whispersystems.textsecuregcm.storage.Account;
+import org.whispersystems.textsecuregcm.storage.AccountsManager;
+import org.whispersystems.textsecuregcm.storage.Device;
+
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Response;
+import java.io.IOException;
+import java.util.Set;
+
+import io.dropwizard.auth.Auth;
+import static org.whispersystems.textsecuregcm.entities.MessageProtos.OutgoingMessageSignal;
+
+@Path("/v1/receipt")
+public class ReceiptController {
+
+  private final AccountsManager        accountManager;
+  private final PushSender             pushSender;
+  private final FederatedClientManager federatedClientManager;
+
+  public ReceiptController(AccountsManager accountManager,
+                           FederatedClientManager federatedClientManager,
+                           PushSender pushSender)
+  {
+    this.accountManager         = accountManager;
+    this.federatedClientManager = federatedClientManager;
+    this.pushSender             = pushSender;
+  }
+
+  @Timed
+  @PUT
+  @Path("/{destination}/{messageId}")
+  public void sendDeliveryReceipt(@Auth                     Account source,
+                                  @PathParam("destination") String destination,
+                                  @PathParam("messageId")   long messageId,
+                                  @QueryParam("relay")      Optional<String> relay)
+      throws IOException
+  {
+    try {
+      if (relay.isPresent() && !relay.get().isEmpty()) {
+        sendRelayedReceipt(source, destination, messageId, relay.get());
+      } else {
+        sendDirectReceipt(source, destination, messageId);
+      }
+    } catch (NoSuchUserException | NotPushRegisteredException e) {
+      throw new WebApplicationException(Response.Status.NOT_FOUND);
+    } catch (TransientPushFailureException e) {
+      throw new IOException(e);
+    }
+  }
+
+  private void sendRelayedReceipt(Account source, String destination, long messageId, String relay)
+      throws NoSuchUserException, IOException
+  {
+    try {
+      federatedClientManager.getClient(relay)
+                            .sendDeliveryReceipt(source.getNumber(),
+                                                 source.getAuthenticatedDevice().get().getId(),
+                                                 destination, messageId);
+    } catch (NoSuchPeerException e) {
+      throw new NoSuchUserException(e);
+    }
+  }
+
+  private void sendDirectReceipt(Account source, String destination, long messageId)
+      throws NotPushRegisteredException, TransientPushFailureException, NoSuchUserException
+  {
+    Account     destinationAccount = getDestinationAccount(destination);
+    Set<Device> destinationDevices = destinationAccount.getDevices();
+
+    OutgoingMessageSignal.Builder message =
+        OutgoingMessageSignal.newBuilder()
+                             .setSource(source.getNumber())
+                             .setSourceDevice((int) source.getAuthenticatedDevice().get().getId())
+                             .setTimestamp(messageId)
+                             .setType(OutgoingMessageSignal.Type.RECEIPT_VALUE);
+
+    if (source.getRelay().isPresent()) {
+      message.setRelay(source.getRelay().get());
+    }
+
+    for (Device destinationDevice : destinationDevices) {
+      pushSender.sendMessage(destinationAccount, destinationDevice, message.build());
+    }
+  }
+
+  private Account getDestinationAccount(String destination)
+      throws NoSuchUserException
+  {
+    Optional<Account> account = accountManager.get(destination);
+
+    if (!account.isPresent()) {
+      throw new NoSuchUserException(destination);
+    }
+
+    return account.get();
+  }
+
+}

src/main/java/org/whispersystems/textsecuregcm/controllers/WebsocketController.java

@@ -1,155 +0,0 @@
-package org.whispersystems.textsecuregcm.controllers;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.eclipse.jetty.websocket.WebSocket;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.whispersystems.textsecuregcm.entities.AcknowledgeWebsocketMessage;
-import org.whispersystems.textsecuregcm.entities.IncomingWebsocketMessage;
-import org.whispersystems.textsecuregcm.storage.Account;
-import org.whispersystems.textsecuregcm.storage.Device;
-import org.whispersystems.textsecuregcm.storage.PubSubListener;
-import org.whispersystems.textsecuregcm.storage.PubSubManager;
-import org.whispersystems.textsecuregcm.storage.PubSubMessage;
-import org.whispersystems.textsecuregcm.storage.StoredMessageManager;
-import org.whispersystems.textsecuregcm.websocket.WebsocketAddress;
-import org.whispersystems.textsecuregcm.websocket.WebsocketMessage;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-public class WebsocketController implements WebSocket.OnTextMessage, PubSubListener {
-
-  private static final Logger            logger          = LoggerFactory.getLogger(WebsocketController.class);
-  private static final ObjectMapper      mapper          = new ObjectMapper();
-  private static final Map<Long, String> pendingMessages = new HashMap<>();
-
-  private final StoredMessageManager storedMessageManager;
-  private final PubSubManager        pubSubManager;
-
-  private final Account account;
-  private final Device  device;
-
-  private Connection connection;
-  private long       pendingMessageSequence;
-
-  public WebsocketController(StoredMessageManager storedMessageManager,
-                             PubSubManager pubSubManager,
-                             Account account)
-  {
-    this.storedMessageManager = storedMessageManager;
-    this.pubSubManager        = pubSubManager;
-    this.account              = account;
-    this.device               = account.getAuthenticatedDevice().get();
-  }
-
-
-  @Override
-  public void onOpen(Connection connection) {
-    this.connection = connection;
-    pubSubManager.subscribe(new WebsocketAddress(this.account.getId(), this.device.getId()), this);
-    handleQueryDatabase();
-  }
-
-  @Override
-  public void onClose(int i, String s) {
-    handleClose();
-  }
-
-  @Override
-  public void onMessage(String body) {
-    try {
-      IncomingWebsocketMessage incomingMessage = mapper.readValue(body, IncomingWebsocketMessage.class);
-
-      switch (incomingMessage.getType()) {
-        case IncomingWebsocketMessage.TYPE_ACKNOWLEDGE_MESSAGE: handleMessageAck(body); break;
-        case IncomingWebsocketMessage.TYPE_PING_MESSAGE:        handlePing();           break;
-        default:                                                handleClose();          break;
-      }
-    } catch (IOException e) {
-      logger.debug("Parse", e);
-      handleClose();
-    }
-  }
-
-  @Override
-  public void onPubSubMessage(PubSubMessage outgoingMessage) {
-    switch (outgoingMessage.getType()) {
-      case PubSubMessage.TYPE_DELIVER:  handleDeliverOutgoingMessage(outgoingMessage.getContents()); break;
-      case PubSubMessage.TYPE_QUERY_DB: handleQueryDatabase();                                       break;
-      default:
-        logger.warn("Unknown pubsub message: " + outgoingMessage.getType());
-    }
-  }
-
-  private void handleDeliverOutgoingMessage(String message) {
-    try {
-      long messageSequence;
-
-      synchronized (pendingMessages) {
-        messageSequence = pendingMessageSequence++;
-        pendingMessages.put(messageSequence, message);
-      }
-
-      connection.sendMessage(mapper.writeValueAsString(new WebsocketMessage(messageSequence, message)));
-    } catch (IOException e) {
-      logger.debug("Response failed", e);
-      handleClose();
-    }
-  }
-
-  private void handleMessageAck(String message) {
-    try {
-      AcknowledgeWebsocketMessage ack = mapper.readValue(message, AcknowledgeWebsocketMessage.class);
-
-      synchronized (pendingMessages) {
-        pendingMessages.remove(ack.getId());
-      }
-    } catch (IOException e) {
-      logger.warn("Mapping", e);
-    }
-  }
-
-  private void handlePing() {
-    try {
-      IncomingWebsocketMessage pongMessage = new IncomingWebsocketMessage(IncomingWebsocketMessage.TYPE_PONG_MESSAGE);
-      connection.sendMessage(mapper.writeValueAsString(pongMessage));
-    } catch (IOException e) {
-      logger.warn("Pong failed", e);
-      handleClose();
-    }
-  }
-
-  private void handleClose() {
-    pubSubManager.unsubscribe(new WebsocketAddress(account.getId(), device.getId()), this);
-    connection.close();
-
-    List<String> remainingMessages = new LinkedList<>();
-
-    synchronized (pendingMessages) {
-      Long[] pendingKeys = pendingMessages.keySet().toArray(new Long[0]);
-      Arrays.sort(pendingKeys);
-
-      for (long pendingKey : pendingKeys) {
-        remainingMessages.add(pendingMessages.get(pendingKey));
-      }
-
-      pendingMessages.clear();
-    }
-
-    storedMessageManager.storeMessages(account, device, remainingMessages);
-  }
-
-  private void handleQueryDatabase() {
-    List<String> messages = storedMessageManager.getOutgoingMessages(account, device);
-
-    for (String message : messages) {
-      handleDeliverOutgoingMessage(message);
-    }
-  }
-
-}

src/main/java/org/whispersystems/textsecuregcm/controllers/WebsocketControllerFactory.java

@@ -1,98 +0,0 @@
-package org.whispersystems.textsecuregcm.controllers;
-
-import com.google.common.base.Optional;
-import com.yammer.dropwizard.auth.AuthenticationException;
-import com.yammer.dropwizard.auth.basic.BasicCredentials;
-import org.eclipse.jetty.websocket.WebSocket;
-import org.eclipse.jetty.websocket.WebSocketServlet;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.whispersystems.textsecuregcm.auth.AccountAuthenticator;
-import org.whispersystems.textsecuregcm.storage.Account;
-import org.whispersystems.textsecuregcm.storage.PubSubManager;
-import org.whispersystems.textsecuregcm.storage.StoredMessageManager;
-
-import javax.servlet.http.HttpServletRequest;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-
-public class WebsocketControllerFactory extends WebSocketServlet {
-
-  private final Logger logger = LoggerFactory.getLogger(WebsocketControllerFactory.class);
-
-  private final StoredMessageManager storedMessageManager;
-  private final PubSubManager        pubSubManager;
-  private final AccountAuthenticator accountAuthenticator;
-
-  private final LinkedHashMap<BasicCredentials, Optional<Account>> cache =
-      new LinkedHashMap<BasicCredentials, Optional<Account>>() {
-    @Override
-    protected boolean removeEldestEntry(Map.Entry<BasicCredentials, Optional<Account>> eldest) {
-      return size() > 10;
-    }
-  };
-
-  public WebsocketControllerFactory(AccountAuthenticator accountAuthenticator,
-                                    StoredMessageManager storedMessageManager,
-                                    PubSubManager pubSubManager)
-  {
-    this.accountAuthenticator = accountAuthenticator;
-    this.storedMessageManager = storedMessageManager;
-    this.pubSubManager        = pubSubManager;
-  }
-
-  @Override
-  public WebSocket doWebSocketConnect(HttpServletRequest request, String s) {
-    try {
-      String username = request.getParameter("user");
-      String password = request.getParameter("password");
-
-      if (username == null || password == null) {
-        return null;
-      }
-
-      BasicCredentials credentials = new BasicCredentials(username, password);
-
-      Optional<Account> account = cache.remove(credentials);
-
-      if (account == null) {
-        account = accountAuthenticator.authenticate(new BasicCredentials(username, password));
-      }
-
-      if (!account.isPresent()) {
-        return null;
-      }
-
-      return new WebsocketController(storedMessageManager, pubSubManager, account.get());
-    } catch (AuthenticationException e) {
-      throw new AssertionError(e);
-    }
-  }
-
-  @Override
-  public boolean checkOrigin(HttpServletRequest request, String origin) {
-    try {
-      String username = request.getParameter("user");
-      String password = request.getParameter("password");
-
-      if (username == null || password == null) {
-        return false;
-      }
-
-      BasicCredentials  credentials = new BasicCredentials(username, password);
-      Optional<Account> account     = accountAuthenticator.authenticate(credentials);
-
-      if (!account.isPresent()) {
-        return false;
-      }
-
-      cache.put(credentials, account);
-
-      return true;
-    } catch (AuthenticationException e) {
-      logger.warn("Auth Failure", e);
-      return false;
-    }
-  }
-}

src/main/java/org/whispersystems/textsecuregcm/entities/ApnMessage.java

@@ -0,0 +1,34 @@
+package org.whispersystems.textsecuregcm.entities;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.annotations.VisibleForTesting;
+import org.hibernate.validator.constraints.NotEmpty;
+
+import javax.validation.constraints.Min;
+
+public class ApnMessage {
+  @JsonProperty
+  @NotEmpty
+  private String apnId;
+
+  @JsonProperty
+  @NotEmpty
+  private String number;
+
+  @JsonProperty
+  @Min(1)
+  private int deviceId;
+
+  @JsonProperty
+  @NotEmpty
+  private String message;
+
+  public ApnMessage() {}
+
+  public ApnMessage(String apnId, String number, int deviceId, String message) {
+    this.apnId    = apnId;
+    this.number   = number;
+    this.deviceId = deviceId;
+    this.message  = message;
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/entities/ClientContact.java

@@ -18,15 +18,10 @@ package org.whispersystems.textsecuregcm.entities;
 
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonValue;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
-import com.google.gson.Gson;
-import org.whispersystems.textsecuregcm.util.Base64;
 import org.whispersystems.textsecuregcm.util.ByteArrayAdapter;
 
-import javax.xml.bind.annotation.XmlRootElement;
-import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 import java.util.Arrays;
 
 @JsonInclude(JsonInclude.Include.NON_DEFAULT)
@@ -73,9 +68,9 @@ public class ClientContact {
     this.inactive = inactive;
   }
 
-  public String toString() {
-    return new Gson().toJson(this);
-  }
+//  public String toString() {
+//    return new Gson().toJson(this);
+//  }
 
   @Override
   public boolean equals(Object other) {

src/main/java/org/whispersystems/textsecuregcm/entities/EncryptedOutgoingMessage.java

@@ -41,23 +41,27 @@ public class EncryptedOutgoingMessage {
   private static final int    MAC_KEY_SIZE    = 20;
   private static final int    MAC_SIZE        = 10;
 
-  private final OutgoingMessageSignal outgoingMessage;
-  private final String signalingKey;
+  private final byte[] serialized;
+  private final String serializedAndEncoded;
 
   public EncryptedOutgoingMessage(OutgoingMessageSignal outgoingMessage,
                                   String signalingKey)
+      throws CryptoEncodingException
   {
-    this.outgoingMessage = outgoingMessage;
-    this.signalingKey    = signalingKey;
-  }
-
-  public String serialize() throws CryptoEncodingException {
     byte[]        plaintext  = outgoingMessage.toByteArray();
     SecretKeySpec cipherKey  = getCipherKey (signalingKey);
     SecretKeySpec macKey     = getMacKey(signalingKey);
-    byte[]        ciphertext = getCiphertext(plaintext, cipherKey, macKey);
 
-    return Base64.encodeBytes(ciphertext);
+    this.serialized           = getCiphertext(plaintext, cipherKey, macKey);
+    this.serializedAndEncoded = Base64.encodeBytes(this.serialized);
+  }
+
+  public String toEncodedString() {
+    return serializedAndEncoded;
+  }
+
+  public byte[] toByteArray() {
+    return serialized;
   }
 
   private byte[] getCiphertext(byte[] plaintext, SecretKeySpec cipherKey, SecretKeySpec macKey)

src/main/java/org/whispersystems/textsecuregcm/entities/GcmMessage.java

@@ -0,0 +1,42 @@
+package org.whispersystems.textsecuregcm.entities;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.hibernate.validator.constraints.NotEmpty;
+
+import javax.validation.constraints.Min;
+
+public class GcmMessage {
+
+  @JsonProperty
+  @NotEmpty
+  private String gcmId;
+
+  @JsonProperty
+  @NotEmpty
+  private String number;
+
+  @JsonProperty
+  @Min(1)
+  private int deviceId;
+
+  @JsonProperty
+  private String message;
+
+  @JsonProperty
+  private boolean receipt;
+
+  @JsonProperty
+  private boolean notification;
+
+  public GcmMessage() {}
+
+  public GcmMessage(String gcmId, String number, int deviceId, String message, boolean receipt, boolean notification) {
+    this.gcmId        = gcmId;
+    this.number       = number;
+    this.deviceId     = deviceId;
+    this.message      = message;
+    this.receipt      = receipt;
+    this.notification = notification;
+  }
+
+}

src/main/java/org/whispersystems/textsecuregcm/entities/GcmRegistrationId.java

@@ -25,9 +25,15 @@ public class GcmRegistrationId {
   @NotEmpty
   private String gcmRegistrationId;
 
+  @JsonProperty
+  private boolean webSocketChannel;
+
   public String getGcmRegistrationId() {
     return gcmRegistrationId;
   }
 
+  public boolean isWebSocketChannel() {
+    return webSocketChannel;
+  }
 }
 

src/main/java/org/whispersystems/textsecuregcm/entities/IncomingMessage.java

@@ -41,7 +41,7 @@ public class IncomingMessage {
   private String relay;
 
   @JsonProperty
-  private long   timestamp;
+  private long   timestamp; // deprecated
 
 
   public String getDestination() {

src/main/java/org/whispersystems/textsecuregcm/entities/IncomingMessageList.java

@@ -32,6 +32,9 @@ public class IncomingMessageList {
   @JsonProperty
   private String relay;
 
+  @JsonProperty
+  private long timestamp;
+
   public IncomingMessageList() {}
 
   public List<IncomingMessage> getMessages() {
@@ -45,4 +48,8 @@ public class IncomingMessageList {
   public void setRelay(String relay) {
     this.relay = relay;
   }
+
+  public long getTimestamp() {
+    return timestamp;
+  }
 }

src/main/java/org/whispersystems/textsecuregcm/entities/PreKeyBase.java

@@ -0,0 +1,8 @@
+package org.whispersystems.textsecuregcm.entities;
+
+public interface PreKeyBase {
+
+  public long getKeyId();
+  public String getPublicKey();
+
+}

src/main/java/org/whispersystems/textsecuregcm/entities/PreKeyCount.java

@@ -3,16 +3,16 @@ package org.whispersystems.textsecuregcm.entities;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 
-public class PreKeyStatus {
+public class PreKeyCount {
 
   @JsonProperty
   private int count;
 
-  public PreKeyStatus(int count) {
+  public PreKeyCount(int count) {
     this.count = count;
   }
 
-  public PreKeyStatus() {}
+  public PreKeyCount() {}
 
   public int getCount() {
     return count;

src/main/java/org/whispersystems/textsecuregcm/entities/PreKeyResponseItemV2.java

@@ -0,0 +1,64 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.entities;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.annotations.VisibleForTesting;
+
+public class PreKeyResponseItemV2 {
+
+  @JsonProperty
+  private long deviceId;
+
+  @JsonProperty
+  private int registrationId;
+
+  @JsonProperty
+  private SignedPreKey signedPreKey;
+
+  @JsonProperty
+  private PreKeyV2 preKey;
+
+  public PreKeyResponseItemV2() {}
+
+  public PreKeyResponseItemV2(long deviceId, int registrationId, SignedPreKey signedPreKey, PreKeyV2 preKey) {
+    this.deviceId       = deviceId;
+    this.registrationId = registrationId;
+    this.signedPreKey   = signedPreKey;
+    this.preKey         = preKey;
+  }
+
+  @VisibleForTesting
+  public SignedPreKey getSignedPreKey() {
+    return signedPreKey;
+  }
+
+  @VisibleForTesting
+  public PreKeyV2 getPreKey() {
+    return preKey;
+  }
+
+  @VisibleForTesting
+  public int getRegistrationId() {
+    return registrationId;
+  }
+
+  @VisibleForTesting
+  public long getDeviceId() {
+    return deviceId;
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/entities/PreKeyResponseV1.java

@@ -18,7 +18,6 @@ package org.whispersystems.textsecuregcm.entities;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.annotations.VisibleForTesting;
-import org.hibernate.validator.constraints.NotEmpty;
 
 import javax.validation.Valid;
 import javax.validation.constraints.NotNull;
@@ -26,36 +25,36 @@ import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 
-public class UnstructuredPreKeyList {
+public class PreKeyResponseV1 {
 
   @JsonProperty
   @NotNull
   @Valid
-  private List<PreKey> keys;
+  private List<PreKeyV1> keys;
 
   @VisibleForTesting
-  public UnstructuredPreKeyList() {}
+  public PreKeyResponseV1() {}
 
-  public UnstructuredPreKeyList(PreKey preKey) {
-    this.keys = new LinkedList<PreKey>();
+  public PreKeyResponseV1(PreKeyV1 preKey) {
+    this.keys = new LinkedList<>();
     this.keys.add(preKey);
   }
 
-  public UnstructuredPreKeyList(List<PreKey> preKeys) {
+  public PreKeyResponseV1(List<PreKeyV1> preKeys) {
     this.keys = preKeys;
   }
 
-  public List<PreKey> getKeys() {
+  public List<PreKeyV1> getKeys() {
     return keys;
   }
 
   @VisibleForTesting
   public boolean equals(Object o) {
-    if (!(o instanceof UnstructuredPreKeyList) ||
-        ((UnstructuredPreKeyList) o).keys.size() != keys.size())
+    if (!(o instanceof PreKeyResponseV1) ||
+        ((PreKeyResponseV1) o).keys.size() != keys.size())
       return false;
-    Iterator<PreKey> otherKeys = ((UnstructuredPreKeyList) o).keys.iterator();
-    for (PreKey key : keys) {
+    Iterator<PreKeyV1> otherKeys = ((PreKeyResponseV1) o).keys.iterator();
+    for (PreKeyV1 key : keys) {
       if (!otherKeys.next().equals(key))
         return false;
     }
@@ -64,7 +63,7 @@ public class UnstructuredPreKeyList {
 
   public int hashCode() {
     int ret = 0xFBA4C795 * keys.size();
-    for (PreKey key : keys)
+    for (PreKeyV1 key : keys)
       ret ^= key.getPublicKey().hashCode();
     return ret;
   }

src/main/java/org/whispersystems/textsecuregcm/entities/PreKeyResponseV2.java

@@ -0,0 +1,61 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.entities;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.annotations.VisibleForTesting;
+
+import java.util.List;
+
+public class PreKeyResponseV2 {
+
+  @JsonProperty
+  private String identityKey;
+
+  @JsonProperty
+  private List<PreKeyResponseItemV2> devices;
+
+  public PreKeyResponseV2() {}
+
+  public PreKeyResponseV2(String identityKey, List<PreKeyResponseItemV2> devices) {
+    this.identityKey = identityKey;
+    this.devices     = devices;
+  }
+
+  @VisibleForTesting
+  public String getIdentityKey() {
+    return identityKey;
+  }
+
+  @VisibleForTesting
+  @JsonIgnore
+  public PreKeyResponseItemV2 getDevice(int deviceId) {
+    for (PreKeyResponseItemV2 device : devices) {
+      if (device.getDeviceId() == deviceId) return device;
+    }
+
+    return null;
+  }
+
+  @VisibleForTesting
+  @JsonIgnore
+  public int getDevicesCount() {
+    return devices.size();
+  }
+
+}

src/main/java/org/whispersystems/textsecuregcm/entities/PreKeyStateV1.java

@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2013 Open WhisperSystems
+ * Copyright (C) 2014 Open Whisper Systems
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -18,39 +18,38 @@ package org.whispersystems.textsecuregcm.entities;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.annotations.VisibleForTesting;
-import org.hibernate.validator.constraints.NotEmpty;
 
 import javax.validation.Valid;
 import javax.validation.constraints.NotNull;
 import java.util.List;
 
-public class PreKeyList {
+public class PreKeyStateV1 {
 
   @JsonProperty
   @NotNull
   @Valid
-  private PreKey lastResortKey;
+  private PreKeyV1 lastResortKey;
 
   @JsonProperty
   @NotNull
   @Valid
-  private List<PreKey> keys;
+  private List<PreKeyV1> keys;
 
-  public List<PreKey> getKeys() {
+  public List<PreKeyV1> getKeys() {
     return keys;
   }
 
   @VisibleForTesting
-  public void setKeys(List<PreKey> keys) {
+  public void setKeys(List<PreKeyV1> keys) {
     this.keys = keys;
   }
 
-  public PreKey getLastResortKey() {
+  public PreKeyV1 getLastResortKey() {
     return lastResortKey;
   }
 
   @VisibleForTesting
-  public void setLastResortKey(PreKey lastResortKey) {
+  public void setLastResortKey(PreKeyV1 lastResortKey) {
     this.lastResortKey = lastResortKey;
   }
 }

src/main/java/org/whispersystems/textsecuregcm/entities/PreKeyStateV2.java

@@ -0,0 +1,76 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.entities;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.annotations.VisibleForTesting;
+
+import org.hibernate.validator.constraints.NotEmpty;
+
+import javax.validation.Valid;
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+public class PreKeyStateV2 {
+
+  @JsonProperty
+  @NotNull
+  @Valid
+  private List<PreKeyV2> preKeys;
+
+  @JsonProperty
+  @NotNull
+  @Valid
+  private SignedPreKey signedPreKey;
+
+  @JsonProperty
+  @NotNull
+  @Valid
+  private PreKeyV2 lastResortKey;
+
+  @JsonProperty
+  @NotEmpty
+  private String identityKey;
+
+  public PreKeyStateV2() {}
+
+  @VisibleForTesting
+  public PreKeyStateV2(String identityKey, SignedPreKey signedPreKey,
+                       List<PreKeyV2> keys, PreKeyV2 lastResortKey)
+  {
+    this.identityKey   = identityKey;
+    this.signedPreKey  = signedPreKey;
+    this.preKeys       = keys;
+    this.lastResortKey = lastResortKey;
+  }
+
+  public List<PreKeyV2> getPreKeys() {
+    return preKeys;
+  }
+
+  public SignedPreKey getSignedPreKey() {
+    return signedPreKey;
+  }
+
+  public String getIdentityKey() {
+    return identityKey;
+  }
+
+  public PreKeyV2 getLastResortKey() {
+    return lastResortKey;
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/entities/PreKeyV1.java

@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2013 Open WhisperSystems
+ * Copyright (C) 2014 Open Whisper Systems
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
@@ -17,22 +17,14 @@
 package org.whispersystems.textsecuregcm.entities;
 
 
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.annotations.VisibleForTesting;
 
 import javax.validation.constraints.NotNull;
-import javax.xml.bind.annotation.XmlTransient;
-import java.io.Serializable;
 
 @JsonInclude(JsonInclude.Include.NON_DEFAULT)
-public class PreKey {
-
-  @JsonIgnore
-  private long    id;
-
-  @JsonIgnore
-  private String  number;
+public class PreKeyV1 implements PreKeyBase {
 
   @JsonProperty
   private long deviceId;
@@ -49,78 +41,43 @@ public class PreKey {
   @NotNull
   private String  identityKey;
 
-  @JsonProperty
-  private boolean lastResort;
-
   @JsonProperty
   private int registrationId;
 
-  public PreKey() {}
+  public PreKeyV1() {}
 
-  public PreKey(long id, String number, long deviceId, long keyId,
-                String publicKey, String identityKey,
-                boolean lastResort)
+  public PreKeyV1(long deviceId, long keyId, String publicKey, String identityKey, int registrationId)
+  {
+    this.deviceId       = deviceId;
+    this.keyId          = keyId;
+    this.publicKey      = publicKey;
+    this.identityKey    = identityKey;
+    this.registrationId = registrationId;
+  }
+
+  @VisibleForTesting
+  public PreKeyV1(long deviceId, long keyId, String publicKey, String identityKey)
   {
-    this.id          = id;
-    this.number      = number;
     this.deviceId    = deviceId;
     this.keyId       = keyId;
     this.publicKey   = publicKey;
     this.identityKey = identityKey;
-    this.lastResort  = lastResort;
-  }
-
-  @XmlTransient
-  public long getId() {
-    return id;
-  }
-
-  public void setId(long id) {
-    this.id = id;
-  }
-
-  @XmlTransient
-  public String getNumber() {
-    return number;
-  }
-
-  public void setNumber(String number) {
-    this.number = number;
   }
 
+  @Override
   public String getPublicKey() {
     return publicKey;
   }
 
-  public void setPublicKey(String publicKey) {
-    this.publicKey = publicKey;
-  }
-
+  @Override
   public long getKeyId() {
     return keyId;
   }
 
-  public void setKeyId(long keyId) {
-    this.keyId = keyId;
-  }
-
   public String getIdentityKey() {
     return identityKey;
   }
 
-  public void setIdentityKey(String identityKey) {
-    this.identityKey = identityKey;
-  }
-
-  @XmlTransient
-  public boolean isLastResort() {
-    return lastResort;
-  }
-
-  public void setLastResort(boolean lastResort) {
-    this.lastResort = lastResort;
-  }
-
   public void setDeviceId(long deviceId) {
     this.deviceId = deviceId;
   }

src/main/java/org/whispersystems/textsecuregcm/entities/PreKeyV2.java

@@ -0,0 +1,82 @@
+package org.whispersystems.textsecuregcm.entities;
+
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.hibernate.validator.constraints.NotEmpty;
+
+import javax.validation.constraints.NotNull;
+
+public class PreKeyV2 implements PreKeyBase {
+
+  @JsonProperty
+  @NotNull
+  private long    keyId;
+
+  @JsonProperty
+  @NotEmpty
+  private String  publicKey;
+
+  public PreKeyV2() {}
+
+  public PreKeyV2(long keyId, String publicKey)
+  {
+    this.keyId     = keyId;
+    this.publicKey = publicKey;
+  }
+
+  @Override
+  public String getPublicKey() {
+    return publicKey;
+  }
+
+  public void setPublicKey(String publicKey) {
+    this.publicKey = publicKey;
+  }
+
+  @Override
+  public long getKeyId() {
+    return keyId;
+  }
+
+  public void setKeyId(long keyId) {
+    this.keyId = keyId;
+  }
+
+  @Override
+  public boolean equals(Object object) {
+    if (object == null || !(object instanceof PreKeyV2)) return false;
+    PreKeyV2 that = (PreKeyV2)object;
+
+    if (publicKey == null) {
+      return this.keyId == that.keyId && that.publicKey == null;
+    } else {
+      return this.keyId == that.keyId && this.publicKey.equals(that.publicKey);
+    }
+  }
+
+  @Override
+  public int hashCode() {
+    if (publicKey == null) {
+      return (int)this.keyId;
+    } else {
+      return ((int)this.keyId) ^ publicKey.hashCode();
+    }
+  }
+
+}

src/main/java/org/whispersystems/textsecuregcm/entities/ProvisioningMessage.java

@@ -0,0 +1,15 @@
+package org.whispersystems.textsecuregcm.entities;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.hibernate.validator.constraints.NotEmpty;
+
+public class ProvisioningMessage {
+
+  @JsonProperty
+  @NotEmpty
+  private String body;
+
+  public String getBody() {
+    return body;
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/entities/SendMessageResponse.java

@@ -0,0 +1,16 @@
+package org.whispersystems.textsecuregcm.entities;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+public class SendMessageResponse {
+
+  @JsonProperty
+  private boolean needsSync;
+
+  public SendMessageResponse() {}
+
+  public SendMessageResponse(boolean needsSync) {
+    this.needsSync = needsSync;
+  }
+
+}

src/main/java/org/whispersystems/textsecuregcm/entities/SignedPreKey.java

@@ -0,0 +1,46 @@
+package org.whispersystems.textsecuregcm.entities;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.hibernate.validator.constraints.NotEmpty;
+
+import java.io.Serializable;
+
+public class SignedPreKey extends PreKeyV2 {
+
+  @JsonProperty
+  @NotEmpty
+  private String signature;
+
+  public SignedPreKey() {}
+
+  public SignedPreKey(long keyId, String publicKey, String signature) {
+    super(keyId, publicKey);
+    this.signature = signature;
+  }
+
+  public String getSignature() {
+    return signature;
+  }
+
+  @Override
+  public boolean equals(Object object) {
+    if (object == null || !(object instanceof SignedPreKey)) return false;
+    SignedPreKey that = (SignedPreKey) object;
+
+    if (signature == null) {
+      return super.equals(object) && that.signature == null;
+    } else {
+      return super.equals(object) && this.signature.equals(that.signature);
+    }
+  }
+
+  @Override
+  public int hashCode() {
+    if (signature == null) {
+      return super.hashCode();
+    } else {
+      return super.hashCode() ^ signature.hashCode();
+    }
+  }
+
+}

src/main/java/org/whispersystems/textsecuregcm/entities/UnregisteredEvent.java

@@ -0,0 +1,40 @@
+package org.whispersystems.textsecuregcm.entities;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.hibernate.validator.constraints.NotEmpty;
+
+import javax.validation.constraints.Min;
+
+public class UnregisteredEvent {
+
+  @JsonProperty
+  @NotEmpty
+  private String registrationId;
+
+  @JsonProperty
+  @NotEmpty
+  private String number;
+
+  @JsonProperty
+  @Min(1)
+  private int deviceId;
+
+  @JsonProperty
+  private long timestamp;
+
+  public String getRegistrationId() {
+    return registrationId;
+  }
+
+  public String getNumber() {
+    return number;
+  }
+
+  public int getDeviceId() {
+    return deviceId;
+  }
+
+  public long getTimestamp() {
+    return timestamp;
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/entities/UnregisteredEventList.java

@@ -0,0 +1,17 @@
+package org.whispersystems.textsecuregcm.entities;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class UnregisteredEventList {
+
+  @JsonProperty
+  private List<UnregisteredEvent> devices;
+
+  public List<UnregisteredEvent> getDevices() {
+    if (devices == null) return new LinkedList<>();
+    else                 return devices;
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/federation/FederatedClient.java

@@ -36,7 +36,8 @@ import org.whispersystems.textsecuregcm.entities.AttachmentUri;
 import org.whispersystems.textsecuregcm.entities.ClientContact;
 import org.whispersystems.textsecuregcm.entities.ClientContacts;
 import org.whispersystems.textsecuregcm.entities.IncomingMessageList;
-import org.whispersystems.textsecuregcm.entities.UnstructuredPreKeyList;
+import org.whispersystems.textsecuregcm.entities.PreKeyResponseV1;
+import org.whispersystems.textsecuregcm.entities.PreKeyResponseV2;
 import org.whispersystems.textsecuregcm.util.Base64;
 
 import javax.net.ssl.SSLContext;
@@ -62,11 +63,13 @@ public class FederatedClient {
 
   private final Logger logger = LoggerFactory.getLogger(FederatedClient.class);
 
-  private static final String USER_COUNT_PATH     = "/v1/federation/user_count";
-  private static final String USER_TOKENS_PATH    = "/v1/federation/user_tokens/%d";
-  private static final String RELAY_MESSAGE_PATH  = "/v1/federation/messages/%s/%d/%s";
-  private static final String PREKEY_PATH_DEVICE  = "/v1/federation/key/%s/%s";
-  private static final String ATTACHMENT_URI_PATH = "/v1/federation/attachment/%d";
+  private static final String USER_COUNT_PATH       = "/v1/federation/user_count";
+  private static final String USER_TOKENS_PATH      = "/v1/federation/user_tokens/%d";
+  private static final String RELAY_MESSAGE_PATH    = "/v1/federation/messages/%s/%d/%s";
+  private static final String PREKEY_PATH_DEVICE_V1 = "/v1/federation/key/%s/%s";
+  private static final String PREKEY_PATH_DEVICE_V2 = "/v2/federation/key/%s/%s";
+  private static final String ATTACHMENT_URI_PATH   = "/v1/federation/attachment/%d";
+  private static final String RECEIPT_PATH          = "/v1/receipt/%s/%d/%s/%d";
 
   private final FederatedPeer peer;
   private final Client        client;
@@ -107,9 +110,9 @@ public class FederatedClient {
     }
   }
 
-  public Optional<UnstructuredPreKeyList> getKeys(String destination, String device) {
+  public Optional<PreKeyResponseV1> getKeysV1(String destination, String device) {
     try {
-      WebResource resource = client.resource(peer.getUrl()).path(String.format(PREKEY_PATH_DEVICE, destination, device));
+      WebResource resource = client.resource(peer.getUrl()).path(String.format(PREKEY_PATH_DEVICE_V1, destination, device));
 
       ClientResponse response = resource.accept(MediaType.APPLICATION_JSON)
                                         .header("Authorization", authorizationHeader)
@@ -119,7 +122,7 @@ public class FederatedClient {
         throw new WebApplicationException(clientResponseToResponse(response));
       }
 
-      return Optional.of(response.getEntity(UnstructuredPreKeyList.class));
+      return Optional.of(response.getEntity(PreKeyResponseV1.class));
 
     } catch (UniformInterfaceException | ClientHandlerException e) {
       logger.warn("PreKey", e);
@@ -127,6 +130,27 @@ public class FederatedClient {
     }
   }
 
+  public Optional<PreKeyResponseV2> getKeysV2(String destination, String device) {
+    try {
+      WebResource resource = client.resource(peer.getUrl()).path(String.format(PREKEY_PATH_DEVICE_V2, destination, device));
+
+      ClientResponse response = resource.accept(MediaType.APPLICATION_JSON)
+                                        .header("Authorization", authorizationHeader)
+                                        .get(ClientResponse.class);
+
+      if (response.getStatus() < 200 || response.getStatus() >= 300) {
+        throw new WebApplicationException(clientResponseToResponse(response));
+      }
+
+      return Optional.of(response.getEntity(PreKeyResponseV2.class));
+
+    } catch (UniformInterfaceException | ClientHandlerException e) {
+      logger.warn("PreKey", e);
+      return Optional.absent();
+    }
+  }
+
+
   public int getUserCount() {
     try {
       WebResource  resource = client.resource(peer.getUrl()).path(USER_COUNT_PATH);
@@ -174,6 +198,25 @@ public class FederatedClient {
     }
   }
 
+  public void sendDeliveryReceipt(String source, long sourceDeviceId, String destination, long messageId)
+      throws IOException
+  {
+    try {
+      String         path     = String.format(RECEIPT_PATH, source, sourceDeviceId, destination, messageId);
+      WebResource    resource = client.resource(peer.getUrl()).path(path);
+      ClientResponse response = resource.type(MediaType.APPLICATION_JSON)
+                                        .header("Authorization", authorizationHeader)
+                                        .put(ClientResponse.class);
+
+      if (response.getStatus() != 200 && response.getStatus() != 204) {
+        throw new WebApplicationException(clientResponseToResponse(response));
+      }
+    } catch (UniformInterfaceException | ClientHandlerException e) {
+      logger.warn("sendMessage", e);
+      throw new IOException(e);
+    }
+  }
+
   private String getAuthorizationHeader(String federationName, FederatedPeer peer) {
     return "Basic " + Base64.encodeBytes((federationName + ":" + peer.getAuthenticationToken()).getBytes());
   }

src/main/java/org/whispersystems/textsecuregcm/federation/NonLimitedAccount.java

@@ -40,6 +40,6 @@ public class NonLimitedAccount extends Account {
 
   @Override
   public Optional<Device> getAuthenticatedDevice() {
-    return Optional.of(new Device(deviceId, null, null, null, null, null, false, 0));
+    return Optional.of(new Device(deviceId, null, null, null, null, null, false, 0, null, System.currentTimeMillis()));
   }
 }

src/main/java/org/whispersystems/textsecuregcm/limits/LeakyBucket.java

@@ -16,9 +16,13 @@
  */
 package org.whispersystems.textsecuregcm.limits;
 
-import java.io.Serializable;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 
-public class LeakyBucket implements Serializable {
+import java.io.IOException;
+
+public class LeakyBucket {
 
   private final int    bucketSize;
   private final double leakRatePerMillis;
@@ -27,10 +31,14 @@ public class LeakyBucket implements Serializable {
   private long lastUpdateTimeMillis;
 
   public LeakyBucket(int bucketSize, double leakRatePerMillis) {
+    this(bucketSize, leakRatePerMillis, bucketSize, System.currentTimeMillis());
+  }
+
+  private LeakyBucket(int bucketSize, double leakRatePerMillis, int spaceRemaining, long lastUpdateTimeMillis) {
     this.bucketSize           = bucketSize;
     this.leakRatePerMillis    = leakRatePerMillis;
-    this.spaceRemaining       = bucketSize;
-    this.lastUpdateTimeMillis = System.currentTimeMillis();
+    this.spaceRemaining       = spaceRemaining;
+    this.lastUpdateTimeMillis = lastUpdateTimeMillis;
   }
 
   public boolean add(int amount) {
@@ -50,4 +58,40 @@ public class LeakyBucket implements Serializable {
     return Math.min(this.bucketSize,
                     (int)Math.floor(this.spaceRemaining + (elapsedTime * this.leakRatePerMillis)));
   }
+
+  public String serialize(ObjectMapper mapper) throws JsonProcessingException {
+    return mapper.writeValueAsString(new LeakyBucketEntity(bucketSize, leakRatePerMillis, spaceRemaining, lastUpdateTimeMillis));
+  }
+
+  public static LeakyBucket fromSerialized(ObjectMapper mapper, String serialized) throws IOException {
+    LeakyBucketEntity entity = mapper.readValue(serialized, LeakyBucketEntity.class);
+
+    return new LeakyBucket(entity.bucketSize, entity.leakRatePerMillis,
+                           entity.spaceRemaining, entity.lastUpdateTimeMillis);
+  }
+
+  private static class LeakyBucketEntity {
+    @JsonProperty
+    private int    bucketSize;
+
+    @JsonProperty
+    private double leakRatePerMillis;
+
+    @JsonProperty
+    private int    spaceRemaining;
+
+    @JsonProperty
+    private long   lastUpdateTimeMillis;
+
+    public LeakyBucketEntity() {}
+
+    private LeakyBucketEntity(int bucketSize, double leakRatePerMillis,
+                              int spaceRemaining, long lastUpdateTimeMillis)
+    {
+      this.bucketSize           = bucketSize;
+      this.leakRatePerMillis    = leakRatePerMillis;
+      this.spaceRemaining       = spaceRemaining;
+      this.lastUpdateTimeMillis = lastUpdateTimeMillis;
+    }
+  }
 }

src/main/java/org/whispersystems/textsecuregcm/limits/RateLimiter.java

@@ -16,27 +16,41 @@
  */
 package org.whispersystems.textsecuregcm.limits;
 
-import com.yammer.metrics.Metrics;
-import com.yammer.metrics.core.Meter;
-import net.spy.memcached.MemcachedClient;
-
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.SharedMetricRegistries;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.controllers.RateLimitExceededException;
+import org.whispersystems.textsecuregcm.util.Constants;
+import org.whispersystems.textsecuregcm.util.SystemMapper;
 
-import java.util.concurrent.TimeUnit;
+import java.io.IOException;
+
+import static com.codahale.metrics.MetricRegistry.name;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPool;
 
 public class RateLimiter {
 
-  private final Meter           meter;
-  private final MemcachedClient memcachedClient;
-  private final String          name;
-  private final int             bucketSize;
-  private final double          leakRatePerMillis;
+  private final Logger       logger = LoggerFactory.getLogger(RateLimiter.class);
+  private final ObjectMapper mapper = SystemMapper.getMapper();
 
-  public RateLimiter(MemcachedClient memcachedClient, String name,
+  private final Meter     meter;
+  private final JedisPool cacheClient;
+  private final String    name;
+  private final int       bucketSize;
+  private final double    leakRatePerMillis;
+
+  public RateLimiter(JedisPool cacheClient, String name,
                      int bucketSize, double leakRatePerMinute)
   {
-    this.meter             = Metrics.newMeter(RateLimiter.class, name, "exceeded", TimeUnit.MINUTES);
-    this.memcachedClient   = memcachedClient;
+    MetricRegistry metricRegistry = SharedMetricRegistries.getOrCreate(Constants.METRICS_NAME);
+
+    this.meter             = metricRegistry.meter(name(getClass(), name, "exceeded"));
+    this.cacheClient       = cacheClient;
     this.name              = name;
     this.bucketSize        = bucketSize;
     this.leakRatePerMillis = leakRatePerMinute / (60.0 * 1000.0);
@@ -58,21 +72,29 @@ public class RateLimiter {
   }
 
   private void setBucket(String key, LeakyBucket bucket) {
-    memcachedClient.set(getBucketName(key),
-                        (int)Math.ceil((bucketSize / leakRatePerMillis) / 1000), bucket);
-  }
-
-  private LeakyBucket getBucket(String key) {
-    LeakyBucket bucket = (LeakyBucket)memcachedClient.get(getBucketName(key));
-
-    if (bucket == null) {
-      return new LeakyBucket(bucketSize, leakRatePerMillis);
-    } else {
-      return bucket;
+    try (Jedis jedis = cacheClient.getResource()) {
+      String serialized = bucket.serialize(mapper);
+      jedis.setex(getBucketName(key), (int) Math.ceil((bucketSize / leakRatePerMillis) / 1000), serialized);
+    } catch (JsonProcessingException e) {
+      throw new IllegalArgumentException(e);
     }
   }
 
+  private LeakyBucket getBucket(String key) {
+    try (Jedis jedis = cacheClient.getResource()) {
+      String serialized = jedis.get(getBucketName(key));
+
+      if (serialized != null) {
+        return LeakyBucket.fromSerialized(mapper, serialized);
+      }
+    } catch (IOException e) {
+      logger.warn("Deserialization error", e);
+    }
+
+    return new LeakyBucket(bucketSize, leakRatePerMillis);
+  }
+
   private String getBucketName(String key) {
-    return LeakyBucket.class.getSimpleName() + name + key;
+    return "leaky_bucket::" + name + "::" + key;
   }
 }

src/main/java/org/whispersystems/textsecuregcm/limits/RateLimiters.java

@@ -17,9 +17,10 @@
 package org.whispersystems.textsecuregcm.limits;
 
 
-import net.spy.memcached.MemcachedClient;
 import org.whispersystems.textsecuregcm.configuration.RateLimitsConfiguration;
 
+import redis.clients.jedis.JedisPool;
+
 public class RateLimiters {
 
   private final RateLimiter smsDestinationLimiter;
@@ -34,40 +35,40 @@ public class RateLimiters {
   private final RateLimiter allocateDeviceLimiter;
   private final RateLimiter verifyDeviceLimiter;
 
-  public RateLimiters(RateLimitsConfiguration config, MemcachedClient memcachedClient) {
-    this.smsDestinationLimiter = new RateLimiter(memcachedClient, "smsDestination",
+  public RateLimiters(RateLimitsConfiguration config, JedisPool cacheClient) {
+    this.smsDestinationLimiter = new RateLimiter(cacheClient, "smsDestination",
                                                  config.getSmsDestination().getBucketSize(),
                                                  config.getSmsDestination().getLeakRatePerMinute());
 
-    this.voiceDestinationLimiter = new RateLimiter(memcachedClient, "voxDestination",
+    this.voiceDestinationLimiter = new RateLimiter(cacheClient, "voxDestination",
                                                    config.getVoiceDestination().getBucketSize(),
                                                    config.getVoiceDestination().getLeakRatePerMinute());
 
-    this.verifyLimiter = new RateLimiter(memcachedClient, "verify",
+    this.verifyLimiter = new RateLimiter(cacheClient, "verify",
                                          config.getVerifyNumber().getBucketSize(),
                                          config.getVerifyNumber().getLeakRatePerMinute());
 
-    this.attachmentLimiter = new RateLimiter(memcachedClient, "attachmentCreate",
+    this.attachmentLimiter = new RateLimiter(cacheClient, "attachmentCreate",
                                              config.getAttachments().getBucketSize(),
                                              config.getAttachments().getLeakRatePerMinute());
 
-    this.contactsLimiter = new RateLimiter(memcachedClient, "contactsQuery",
+    this.contactsLimiter = new RateLimiter(cacheClient, "contactsQuery",
                                            config.getContactQueries().getBucketSize(),
                                            config.getContactQueries().getLeakRatePerMinute());
 
-    this.preKeysLimiter = new RateLimiter(memcachedClient, "prekeys",
+    this.preKeysLimiter = new RateLimiter(cacheClient, "prekeys",
                                           config.getPreKeys().getBucketSize(),
                                           config.getPreKeys().getLeakRatePerMinute());
 
-    this.messagesLimiter = new RateLimiter(memcachedClient, "messages",
+    this.messagesLimiter = new RateLimiter(cacheClient, "messages",
                                            config.getMessages().getBucketSize(),
                                            config.getMessages().getLeakRatePerMinute());
 
-    this.allocateDeviceLimiter = new RateLimiter(memcachedClient, "allocateDevice",
+    this.allocateDeviceLimiter = new RateLimiter(cacheClient, "allocateDevice",
                                                  config.getAllocateDevice().getBucketSize(),
                                                  config.getAllocateDevice().getLeakRatePerMinute());
 
-    this.verifyDeviceLimiter = new RateLimiter(memcachedClient, "verifyDevice",
+    this.verifyDeviceLimiter = new RateLimiter(cacheClient, "verifyDevice",
                                                config.getVerifyDevice().getBucketSize(),
                                                config.getVerifyDevice().getLeakRatePerMinute());
 

src/main/java/org/whispersystems/textsecuregcm/liquibase/AbstractLiquibaseCommand.java

@@ -0,0 +1,65 @@
+package org.whispersystems.textsecuregcm.liquibase;
+
+import com.codahale.metrics.MetricRegistry;
+import net.sourceforge.argparse4j.inf.Namespace;
+
+import java.sql.SQLException;
+
+import io.dropwizard.Configuration;
+import io.dropwizard.cli.ConfiguredCommand;
+import io.dropwizard.db.DataSourceFactory;
+import io.dropwizard.db.DatabaseConfiguration;
+import io.dropwizard.db.ManagedDataSource;
+import io.dropwizard.setup.Bootstrap;
+import liquibase.Liquibase;
+import liquibase.exception.LiquibaseException;
+import liquibase.exception.ValidationFailedException;
+
+public abstract class AbstractLiquibaseCommand<T extends Configuration> extends ConfiguredCommand<T> {
+
+  private final DatabaseConfiguration<T> strategy;
+  private final Class<T>                 configurationClass;
+  private final String                   migrations;
+
+  protected AbstractLiquibaseCommand(String name,
+                                     String description,
+                                     String migrations,
+                                     DatabaseConfiguration<T> strategy,
+                                     Class<T> configurationClass) {
+    super(name, description);
+    this.migrations         = migrations;
+    this.strategy           = strategy;
+    this.configurationClass = configurationClass;
+  }
+
+  @Override
+  protected Class<T> getConfigurationClass() {
+    return configurationClass;
+  }
+
+  @Override
+  @SuppressWarnings("UseOfSystemOutOrSystemErr")
+  protected void run(Bootstrap<T> bootstrap, Namespace namespace, T configuration) throws Exception {
+    final DataSourceFactory dbConfig = strategy.getDataSourceFactory(configuration);
+    dbConfig.setMaxSize(1);
+    dbConfig.setMinSize(1);
+    dbConfig.setInitialSize(1);
+
+    try (final CloseableLiquibase liquibase = openLiquibase(dbConfig, namespace)) {
+      run(namespace, liquibase);
+    } catch (ValidationFailedException e) {
+      e.printDescriptiveError(System.err);
+      throw e;
+    }
+  }
+
+  private CloseableLiquibase openLiquibase(final DataSourceFactory dataSourceFactory, final Namespace namespace)
+      throws ClassNotFoundException, SQLException, LiquibaseException
+  {
+    final ManagedDataSource dataSource = dataSourceFactory.build(new MetricRegistry(), "liquibase");
+    return new CloseableLiquibase(dataSource, migrations);
+  }
+
+  protected abstract void run(Namespace namespace, Liquibase liquibase) throws Exception;
+
+}

src/main/java/org/whispersystems/textsecuregcm/liquibase/CloseableLiquibase.java

@@ -0,0 +1,28 @@
+package org.whispersystems.textsecuregcm.liquibase;
+
+import java.sql.SQLException;
+
+import io.dropwizard.db.ManagedDataSource;
+import liquibase.Liquibase;
+import liquibase.database.jvm.JdbcConnection;
+import liquibase.exception.LiquibaseException;
+import liquibase.resource.ClassLoaderResourceAccessor;
+
+
+public class CloseableLiquibase extends Liquibase implements AutoCloseable {
+  private final ManagedDataSource dataSource;
+
+  public CloseableLiquibase(ManagedDataSource dataSource, String migrations)
+      throws LiquibaseException, ClassNotFoundException, SQLException
+  {
+    super(migrations,
+          new ClassLoaderResourceAccessor(),
+          new JdbcConnection(dataSource.getConnection()));
+    this.dataSource = dataSource;
+  }
+
+  @Override
+  public void close() throws Exception {
+    dataSource.stop();
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/liquibase/DbMigrateCommand.java

@@ -0,0 +1,72 @@
+package org.whispersystems.textsecuregcm.liquibase;
+
+
+import com.google.common.base.Charsets;
+import com.google.common.base.Joiner;
+import net.sourceforge.argparse4j.impl.Arguments;
+import net.sourceforge.argparse4j.inf.Namespace;
+import net.sourceforge.argparse4j.inf.Subparser;
+
+import java.io.OutputStreamWriter;
+import java.util.List;
+
+import io.dropwizard.Configuration;
+import io.dropwizard.db.DatabaseConfiguration;
+import liquibase.Liquibase;
+
+public class DbMigrateCommand<T extends Configuration> extends AbstractLiquibaseCommand<T> {
+
+  public DbMigrateCommand(String migration, DatabaseConfiguration<T> strategy, Class<T> configurationClass) {
+    super("migrate", "Apply all pending change sets.", migration, strategy, configurationClass);
+  }
+
+  @Override
+  public void configure(Subparser subparser) {
+    super.configure(subparser);
+
+    subparser.addArgument("-n", "--dry-run")
+             .action(Arguments.storeTrue())
+             .dest("dry-run")
+             .setDefault(Boolean.FALSE)
+             .help("output the DDL to stdout, don't run it");
+
+    subparser.addArgument("-c", "--count")
+             .type(Integer.class)
+             .dest("count")
+             .help("only apply the next N change sets");
+
+    subparser.addArgument("-i", "--include")
+             .action(Arguments.append())
+             .dest("contexts")
+             .help("include change sets from the given context");
+  }
+
+  @Override
+  @SuppressWarnings("UseOfSystemOutOrSystemErr")
+  public void run(Namespace namespace, Liquibase liquibase) throws Exception {
+    final String context = getContext(namespace);
+    final Integer count = namespace.getInt("count");
+    final Boolean dryRun = namespace.getBoolean("dry-run");
+    if (count != null) {
+      if (dryRun) {
+        liquibase.update(count, context, new OutputStreamWriter(System.out, Charsets.UTF_8));
+      } else {
+        liquibase.update(count, context);
+      }
+    } else {
+      if (dryRun) {
+        liquibase.update(context, new OutputStreamWriter(System.out, Charsets.UTF_8));
+      } else {
+        liquibase.update(context);
+      }
+    }
+  }
+
+  private String getContext(Namespace namespace) {
+    final List<Object> contexts = namespace.getList("contexts");
+    if (contexts == null) {
+      return "";
+    }
+    return Joiner.on(',').join(contexts);
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/liquibase/DbStatusCommand.java

@@ -0,0 +1,51 @@
+package org.whispersystems.textsecuregcm.liquibase;
+
+import com.google.common.base.Charsets;
+import com.google.common.base.Joiner;
+import net.sourceforge.argparse4j.impl.Arguments;
+import net.sourceforge.argparse4j.inf.Namespace;
+import net.sourceforge.argparse4j.inf.Subparser;
+
+import java.io.OutputStreamWriter;
+import java.util.List;
+
+import io.dropwizard.Configuration;
+import io.dropwizard.db.DatabaseConfiguration;
+import liquibase.Liquibase;
+
+public class DbStatusCommand <T extends Configuration> extends AbstractLiquibaseCommand<T> {
+
+  public DbStatusCommand(String migrations, DatabaseConfiguration<T> strategy, Class<T> configurationClass) {
+    super("status", "Check for pending change sets.", migrations, strategy, configurationClass);
+  }
+
+  @Override
+  public void configure(Subparser subparser) {
+    super.configure(subparser);
+
+    subparser.addArgument("-v", "--verbose")
+             .action(Arguments.storeTrue())
+             .dest("verbose")
+             .help("Output verbose information");
+    subparser.addArgument("-i", "--include")
+             .action(Arguments.append())
+             .dest("contexts")
+             .help("include change sets from the given context");
+  }
+
+  @Override
+  @SuppressWarnings("UseOfSystemOutOrSystemErr")
+  public void run(Namespace namespace, Liquibase liquibase) throws Exception {
+    liquibase.reportStatus(namespace.getBoolean("verbose"),
+                           getContext(namespace),
+                           new OutputStreamWriter(System.out, Charsets.UTF_8));
+  }
+
+  private String getContext(Namespace namespace) {
+    final List<Object> contexts = namespace.getList("contexts");
+    if (contexts == null) {
+      return "";
+    }
+    return Joiner.on(',').join(contexts);
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/liquibase/NameableDbCommand.java

@@ -0,0 +1,44 @@
+package org.whispersystems.textsecuregcm.liquibase;
+
+import com.google.common.collect.Maps;
+import net.sourceforge.argparse4j.inf.Namespace;
+import net.sourceforge.argparse4j.inf.Subparser;
+
+import java.util.SortedMap;
+
+import io.dropwizard.Configuration;
+import io.dropwizard.db.DatabaseConfiguration;
+import liquibase.Liquibase;
+
+public class NameableDbCommand<T extends Configuration> extends AbstractLiquibaseCommand<T> {
+  private static final String COMMAND_NAME_ATTR = "subcommand";
+  private final SortedMap<String, AbstractLiquibaseCommand<T>> subcommands;
+
+  public NameableDbCommand(String name, String migrations, DatabaseConfiguration<T> strategy, Class<T> configurationClass) {
+    super(name, "Run database migrations tasks", migrations, strategy, configurationClass);
+    this.subcommands = Maps.newTreeMap();
+    addSubcommand(new DbMigrateCommand<>(migrations, strategy, configurationClass));
+    addSubcommand(new DbStatusCommand<>(migrations, strategy, configurationClass));
+  }
+
+  private void addSubcommand(AbstractLiquibaseCommand<T> subcommand) {
+    subcommands.put(subcommand.getName(), subcommand);
+  }
+
+  @Override
+  public void configure(Subparser subparser) {
+    for (AbstractLiquibaseCommand<T> subcommand : subcommands.values()) {
+      final Subparser cmdParser = subparser.addSubparsers()
+                                           .addParser(subcommand.getName())
+                                           .setDefault(COMMAND_NAME_ATTR, subcommand.getName())
+                                           .description(subcommand.getDescription());
+      subcommand.configure(cmdParser);
+    }
+  }
+
+  @Override
+  public void run(Namespace namespace, Liquibase liquibase) throws Exception {
+    final AbstractLiquibaseCommand<T> subcommand = subcommands.get(namespace.getString(COMMAND_NAME_ATTR));
+    subcommand.run(namespace, liquibase);
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/liquibase/NameableMigrationsBundle.java

@@ -0,0 +1,27 @@
+package org.whispersystems.textsecuregcm.liquibase;
+
+import io.dropwizard.Bundle;
+import io.dropwizard.Configuration;
+import io.dropwizard.db.DatabaseConfiguration;
+import io.dropwizard.setup.Bootstrap;
+import io.dropwizard.setup.Environment;
+import io.dropwizard.util.Generics;
+
+public abstract class NameableMigrationsBundle<T extends Configuration> implements Bundle, DatabaseConfiguration<T> {
+
+  private final String name;
+  private final String migrations;
+
+  public NameableMigrationsBundle(String name, String migrations) {
+    this.name       = name;
+    this.migrations = migrations;
+  }
+
+  public final void initialize(Bootstrap<?> bootstrap) {
+    Class klass = Generics.getTypeParameter(this.getClass(), Configuration.class);
+    bootstrap.addCommand(new NameableDbCommand(name, migrations, this, klass));
+  }
+
+  public final void run(Environment environment) {
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/mappers/IOExceptionMapper.java

@@ -31,7 +31,9 @@ public class IOExceptionMapper implements ExceptionMapper<IOException> {
 
   @Override
   public Response toResponse(IOException e) {
-    logger.warn("IOExceptionMapper", e);
+    if (!(e.getCause() instanceof java.util.concurrent.TimeoutException)) {
+      logger.warn("IOExceptionMapper", e);
+    }
     return Response.status(503).build();
   }
 }

src/main/java/org/whispersystems/textsecuregcm/mappers/InvalidWebsocketAddressExceptionMapper.java

@@ -0,0 +1,15 @@
+package org.whispersystems.textsecuregcm.mappers;
+
+import org.whispersystems.textsecuregcm.websocket.InvalidWebsocketAddressException;
+
+import javax.ws.rs.core.Response;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
+
+@Provider
+public class InvalidWebsocketAddressExceptionMapper implements ExceptionMapper<InvalidWebsocketAddressException> {
+  @Override
+  public Response toResponse(InvalidWebsocketAddressException exception) {
+    return Response.status(Response.Status.BAD_REQUEST).build();
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/metrics/CpuUsageGauge.java

@@ -1,13 +1,13 @@
 package org.whispersystems.textsecuregcm.metrics;
 
+import com.codahale.metrics.Gauge;
 import com.sun.management.OperatingSystemMXBean;
-import com.yammer.metrics.core.Gauge;
 
 import java.lang.management.ManagementFactory;
 
-public class CpuUsageGauge extends Gauge<Integer> {
+public class CpuUsageGauge implements Gauge<Integer> {
   @Override
-  public Integer value() {
+  public Integer getValue() {
     OperatingSystemMXBean mbean = (com.sun.management.OperatingSystemMXBean)
         ManagementFactory.getOperatingSystemMXBean();
 

src/main/java/org/whispersystems/textsecuregcm/metrics/FreeMemoryGauge.java

@@ -1,17 +1,14 @@
 package org.whispersystems.textsecuregcm.metrics;
 
+import com.codahale.metrics.Gauge;
 import com.sun.management.OperatingSystemMXBean;
-import com.yammer.metrics.core.Gauge;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.lang.management.ManagementFactory;
 
-public class FreeMemoryGauge extends Gauge<Long> {
+public class FreeMemoryGauge implements Gauge<Long> {
 
   @Override
-  public Long value() {
+  public Long getValue() {
     OperatingSystemMXBean mbean = (com.sun.management.OperatingSystemMXBean)
         ManagementFactory.getOperatingSystemMXBean();
 

src/main/java/org/whispersystems/textsecuregcm/metrics/JsonMetricsReporter.java

@@ -1,23 +1,20 @@
 package org.whispersystems.textsecuregcm.metrics;
 
+import com.codahale.metrics.Counter;
+import com.codahale.metrics.Gauge;
+import com.codahale.metrics.Histogram;
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.Metered;
+import com.codahale.metrics.MetricFilter;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.ScheduledReporter;
+import com.codahale.metrics.Snapshot;
+import com.codahale.metrics.Timer;
 import com.fasterxml.jackson.core.JsonEncoding;
 import com.fasterxml.jackson.core.JsonFactory;
 import com.fasterxml.jackson.core.JsonGenerator;
-import com.yammer.metrics.core.Clock;
-import com.yammer.metrics.core.Counter;
-import com.yammer.metrics.core.Gauge;
-import com.yammer.metrics.core.Histogram;
-import com.yammer.metrics.core.Metered;
-import com.yammer.metrics.core.Metric;
-import com.yammer.metrics.core.MetricName;
-import com.yammer.metrics.core.MetricProcessor;
-import com.yammer.metrics.core.MetricsRegistry;
-import com.yammer.metrics.core.Sampling;
-import com.yammer.metrics.core.Summarizable;
-import com.yammer.metrics.core.Timer;
-import com.yammer.metrics.core.VirtualMachineMetrics;
-import com.yammer.metrics.reporting.AbstractPollingReporter;
-import com.yammer.metrics.stats.Snapshot;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -30,295 +27,214 @@ import java.util.SortedMap;
 import java.util.concurrent.TimeUnit;
 import java.util.regex.Pattern;
 
-/**
- * Adapted from MetricsServlet.
- */
-public class JsonMetricsReporter extends AbstractPollingReporter implements MetricProcessor<JsonMetricsReporter.Context> {
-  private final Clock clock = Clock.defaultClock();
-  private final VirtualMachineMetrics vm = VirtualMachineMetrics.getInstance();
-  private final String service;
-  private final MetricsRegistry registry;
-  private final JsonFactory factory = new JsonFactory();
-
-  private final String table;
-  private final String sunnylabsHost;
-  private final String host;
-
-  private final boolean includeVMMetrics;
-
-  public JsonMetricsReporter(String service, MetricsRegistry registry, String token, String sunnylabsHost) throws UnknownHostException {
-    this(service, registry, token, sunnylabsHost, true);
-  }
-
-  public JsonMetricsReporter(String service, MetricsRegistry registry, String token, String sunnylabsHost, boolean includeVMMetrics) throws UnknownHostException {
-    super(registry, "jsonmetrics-reporter");
-    this.service = service;
-    this.registry = registry;
-    this.table = token;
-    this.sunnylabsHost = sunnylabsHost;
-    this.host = InetAddress.getLocalHost().getHostName();
-    this.includeVMMetrics = includeVMMetrics;
-  }
-
-  @Override
-  public void run() {
-    try {
-      URL http = new URL("https", sunnylabsHost, 443, "/report/metrics?t=" + table + "&h=" + host);
-      System.out.println("Reporting started to: " + http);
-      HttpURLConnection urlc = (HttpURLConnection) http.openConnection();
-      urlc.setDoOutput(true);
-      urlc.addRequestProperty("Content-Type", "application/json");
-      OutputStream outputStream = urlc.getOutputStream();
-      writeJson(outputStream);
-      outputStream.close();
-      System.out.println("Reporting complete: " + urlc.getResponseCode());
-    } catch (IOException e) {
-      e.printStackTrace();
-    }
-  }
-
-  static final class Context {
-    final boolean showFullSamples;
-    final JsonGenerator json;
-
-    Context(JsonGenerator json, boolean showFullSamples) {
-      this.json = json;
-      this.showFullSamples = showFullSamples;
-    }
-  }
-
-  public void writeJson(OutputStream out) throws IOException {
-    final JsonGenerator json = factory.createGenerator(out, JsonEncoding.UTF8);
-    json.writeStartObject();
-    if (includeVMMetrics) {
-      writeVmMetrics(json);
-    }
-    writeRegularMetrics(json, false);
-    json.writeEndObject();
-    json.close();
-  }
-
-  private void writeVmMetrics(JsonGenerator json) throws IOException {
-    json.writeFieldName(service);
-    json.writeStartObject();
-    json.writeFieldName("jvm");
-    json.writeStartObject();
-    {
-      json.writeFieldName("vm");
-      json.writeStartObject();
-      {
-        json.writeStringField("name", vm.name());
-        json.writeStringField("version", vm.version());
-      }
-      json.writeEndObject();
-
-      json.writeFieldName("memory");
-      json.writeStartObject();
-      {
-        json.writeNumberField("totalInit", vm.totalInit());
-        json.writeNumberField("totalUsed", vm.totalUsed());
-        json.writeNumberField("totalMax", vm.totalMax());
-        json.writeNumberField("totalCommitted", vm.totalCommitted());
-
-        json.writeNumberField("heapInit", vm.heapInit());
-        json.writeNumberField("heapUsed", vm.heapUsed());
-        json.writeNumberField("heapMax", vm.heapMax());
-        json.writeNumberField("heapCommitted", vm.heapCommitted());
-
-        json.writeNumberField("heap_usage", vm.heapUsage());
-        json.writeNumberField("non_heap_usage", vm.nonHeapUsage());
-        json.writeFieldName("memory_pool_usages");
-        json.writeStartObject();
-        {
-          for (Map.Entry<String, Double> pool : vm.memoryPoolUsage().entrySet()) {
-            json.writeNumberField(pool.getKey(), pool.getValue());
-          }
-        }
-        json.writeEndObject();
-      }
-      json.writeEndObject();
-
-      final Map<String, VirtualMachineMetrics.BufferPoolStats> bufferPoolStats = vm.getBufferPoolStats();
-      if (!bufferPoolStats.isEmpty()) {
-        json.writeFieldName("buffers");
-        json.writeStartObject();
-        {
-          json.writeFieldName("direct");
-          json.writeStartObject();
-          {
-            json.writeNumberField("count", bufferPoolStats.get("direct").getCount());
-            json.writeNumberField("memoryUsed", bufferPoolStats.get("direct").getMemoryUsed());
-            json.writeNumberField("totalCapacity", bufferPoolStats.get("direct").getTotalCapacity());
-          }
-          json.writeEndObject();
-
-          json.writeFieldName("mapped");
-          json.writeStartObject();
-          {
-            json.writeNumberField("count", bufferPoolStats.get("mapped").getCount());
-            json.writeNumberField("memoryUsed", bufferPoolStats.get("mapped").getMemoryUsed());
-            json.writeNumberField("totalCapacity", bufferPoolStats.get("mapped").getTotalCapacity());
-          }
-          json.writeEndObject();
-        }
-        json.writeEndObject();
-      }
-
-
-      json.writeNumberField("daemon_thread_count", vm.daemonThreadCount());
-      json.writeNumberField("thread_count", vm.threadCount());
-      json.writeNumberField("current_time", clock.time());
-      json.writeNumberField("uptime", vm.uptime());
-      json.writeNumberField("fd_usage", vm.fileDescriptorUsage());
-
-      json.writeFieldName("thread-states");
-      json.writeStartObject();
-      {
-        for (Map.Entry<Thread.State, Double> entry : vm.threadStatePercentages()
-                                                       .entrySet()) {
-          json.writeNumberField(entry.getKey().toString().toLowerCase(),
-                                entry.getValue());
-        }
-      }
-      json.writeEndObject();
-
-      json.writeFieldName("garbage-collectors");
-      json.writeStartObject();
-      {
-        for (Map.Entry<String, VirtualMachineMetrics.GarbageCollectorStats> entry : vm.garbageCollectors()
-                                                                                      .entrySet()) {
-          json.writeFieldName(entry.getKey());
-          json.writeStartObject();
-          {
-            final VirtualMachineMetrics.GarbageCollectorStats gc = entry.getValue();
-            json.writeNumberField("runs", gc.getRuns());
-            json.writeNumberField("time", gc.getTime(TimeUnit.MILLISECONDS));
-          }
-          json.writeEndObject();
-        }
-      }
-      json.writeEndObject();
-    }
-    json.writeEndObject();
-    json.writeEndObject();
-  }
-
-  public void writeRegularMetrics(JsonGenerator json, boolean showFullSamples) throws IOException {
-    for (Map.Entry<String, SortedMap<MetricName, Metric>> entry : registry.groupedMetrics().entrySet()) {
-      for (Map.Entry<MetricName, Metric> subEntry : entry.getValue().entrySet()) {
-        json.writeFieldName(sanitize(subEntry.getKey()));
-        try {
-          subEntry.getValue()
-                  .processWith(this,
-                               subEntry.getKey(),
-                               new Context(json, showFullSamples));
-        } catch (Exception e) {
-          e.printStackTrace();
-        }
-      }
-    }
-  }
-
-  @Override
-  public void processHistogram(MetricName name, Histogram histogram, Context context) throws Exception {
-    final JsonGenerator json = context.json;
-    json.writeStartObject();
-    {
-      json.writeNumberField("count", histogram.count());
-      writeSummarizable(histogram, json);
-      writeSampling(histogram, json);
-      if (context.showFullSamples) {
-        json.writeObjectField("values", histogram.getSnapshot().getValues());
-      }
-      histogram.clear();
-    }
-    json.writeEndObject();
-  }
-
-  @Override
-  public void processCounter(MetricName name, Counter counter, Context context) throws Exception {
-    final JsonGenerator json = context.json;
-    json.writeNumber(counter.count());
-  }
-
-  @Override
-  public void processGauge(MetricName name, Gauge<?> gauge, Context context) throws Exception {
-    final JsonGenerator json = context.json;
-    json.writeObject(evaluateGauge(gauge));
-  }
-
-  @Override
-  public void processMeter(MetricName name, Metered meter, Context context) throws Exception {
-    final JsonGenerator json = context.json;
-    json.writeStartObject();
-    {
-      writeMeteredFields(meter, json);
-    }
-    json.writeEndObject();
-  }
-
-  @Override
-  public void processTimer(MetricName name, Timer timer, Context context) throws Exception {
-    final JsonGenerator json = context.json;
-    json.writeStartObject();
-    {
-      json.writeFieldName("duration");
-      json.writeStartObject();
-      {
-        json.writeStringField("unit", timer.durationUnit().toString().toLowerCase());
-        writeSummarizable(timer, json);
-        writeSampling(timer, json);
-        if (context.showFullSamples) {
-          json.writeObjectField("values", timer.getSnapshot().getValues());
-        }
-      }
-      json.writeEndObject();
-
-      json.writeFieldName("rate");
-      json.writeStartObject();
-      {
-        writeMeteredFields(timer, json);
-      }
-      json.writeEndObject();
-    }
-    json.writeEndObject();
-  }
-
-  private static Object evaluateGauge(Gauge<?> gauge) {
-    try {
-      return gauge.value();
-    } catch (RuntimeException e) {
-      return "error reading gauge: " + e.getMessage();
-    }
-  }
-
-  private static void writeSummarizable(Summarizable metric, JsonGenerator json) throws IOException {
-    json.writeNumberField("min", metric.min());
-    json.writeNumberField("max", metric.max());
-    json.writeNumberField("mean", metric.mean());
-  }
-
-  private static void writeSampling(Sampling metric, JsonGenerator json) throws IOException {
-    final Snapshot snapshot = metric.getSnapshot();
-    json.writeNumberField("median", snapshot.getMedian());
-    json.writeNumberField("p75", snapshot.get75thPercentile());
-    json.writeNumberField("p95", snapshot.get95thPercentile());
-    json.writeNumberField("p99", snapshot.get99thPercentile());
-    json.writeNumberField("p999", snapshot.get999thPercentile());
-  }
-
-  private static void writeMeteredFields(Metered metered, JsonGenerator json) throws IOException {
-    json.writeNumberField("count", metered.count());
-    json.writeNumberField("mean", metered.meanRate());
-    json.writeNumberField("m1", metered.oneMinuteRate());
-    json.writeNumberField("m5", metered.fiveMinuteRate());
-    json.writeNumberField("m15", metered.fifteenMinuteRate());
-  }
+public class JsonMetricsReporter extends ScheduledReporter {
 
   private static final Pattern SIMPLE_NAMES = Pattern.compile("[^a-zA-Z0-9_.\\-~]");
 
-  private String sanitize(MetricName metricName) {
-    return SIMPLE_NAMES.matcher(metricName.getGroup() + "." + metricName.getName()).replaceAll("_");
+  private final Logger logger  = LoggerFactory.getLogger(JsonMetricsReporter.class);
+  private final JsonFactory factory = new JsonFactory();
+
+  private final String token;
+  private final String hostname;
+  private final String host;
+
+  public JsonMetricsReporter(MetricRegistry registry, String token, String hostname,
+                             MetricFilter filter, TimeUnit rateUnit, TimeUnit durationUnit)
+      throws UnknownHostException
+  {
+    super(registry, "json-reporter", filter, rateUnit, durationUnit);
+    this.token    = token;
+    this.hostname = hostname;
+    this.host     = InetAddress.getLocalHost().getHostName();
   }
 
+  @Override
+  public void report(SortedMap<String, Gauge>     stringGaugeSortedMap,
+                     SortedMap<String, Counter>   stringCounterSortedMap,
+                     SortedMap<String, Histogram> stringHistogramSortedMap,
+                     SortedMap<String, Meter>     stringMeterSortedMap,
+                     SortedMap<String, Timer>     stringTimerSortedMap)
+  {
+    try {
+      logger.debug("Reporting metrics...");
+      URL url = new URL("https", hostname, 443, String.format("/report/metrics?t=%s&h=%s", token, host));
+      HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+
+      connection.setDoOutput(true);
+      connection.addRequestProperty("Content-Type", "application/json");
+
+      OutputStream  outputStream = connection.getOutputStream();
+      JsonGenerator json         = factory.createGenerator(outputStream, JsonEncoding.UTF8);
+
+      json.writeStartObject();
+
+      for (Map.Entry<String, Gauge> gauge : stringGaugeSortedMap.entrySet()) {
+        reportGauge(json, gauge.getKey(), gauge.getValue());
+      }
+
+      for (Map.Entry<String, Counter> counter : stringCounterSortedMap.entrySet()) {
+        reportCounter(json, counter.getKey(), counter.getValue());
+      }
+
+      for (Map.Entry<String, Histogram> histogram : stringHistogramSortedMap.entrySet()) {
+        reportHistogram(json, histogram.getKey(), histogram.getValue());
+      }
+
+      for (Map.Entry<String, Meter> meter : stringMeterSortedMap.entrySet()) {
+        reportMeter(json, meter.getKey(), meter.getValue());
+      }
+
+      for (Map.Entry<String, Timer> timer : stringTimerSortedMap.entrySet()) {
+        reportTimer(json, timer.getKey(), timer.getValue());
+      }
+
+      json.writeEndObject();
+      json.close();
+
+      outputStream.close();
+
+      logger.debug("Metrics server response: " + connection.getResponseCode());
+    } catch (IOException e) {
+      logger.warn("Error sending metrics", e);
+    } catch (Exception e) {
+      logger.warn("error", e);
+    }
+  }
+
+  private void reportGauge(JsonGenerator json, String name, Gauge gauge) throws IOException {
+    Object gaugeValue = evaluateGauge(gauge);
+
+    if (gaugeValue instanceof Number) {
+      json.writeFieldName(sanitize(name));
+      json.writeObject(gaugeValue);
+    }
+  }
+
+  private void reportCounter(JsonGenerator json, String name, Counter counter) throws IOException {
+    json.writeFieldName(sanitize(name));
+    json.writeNumber(counter.getCount());
+  }
+
+  private void reportHistogram(JsonGenerator json, String name, Histogram histogram) throws IOException {
+    Snapshot snapshot = histogram.getSnapshot();
+    json.writeFieldName(sanitize(name));
+    json.writeStartObject();
+    json.writeNumberField("count", histogram.getCount());
+    writeSnapshot(json, snapshot);
+    json.writeEndObject();
+  }
+
+  private void reportMeter(JsonGenerator json, String name, Meter meter) throws IOException {
+    json.writeFieldName(sanitize(name));
+    json.writeStartObject();
+    writeMetered(json, meter);
+    json.writeEndObject();
+  }
+
+  private void reportTimer(JsonGenerator json, String name, Timer timer) throws IOException {
+    json.writeFieldName(sanitize(name));
+    json.writeStartObject();
+    json.writeFieldName("rate");
+    json.writeStartObject();
+    writeMetered(json, timer);
+    json.writeEndObject();
+    json.writeFieldName("duration");
+    json.writeStartObject();
+    writeSnapshot(json, timer.getSnapshot());
+    json.writeEndObject();
+    json.writeEndObject();
+  }
+
+  private Object evaluateGauge(Gauge gauge) {
+    try {
+      return gauge.getValue();
+    } catch (RuntimeException e) {
+      logger.warn("Error reading gauge", e);
+      return "error reading gauge";
+    }
+  }
+
+  private void writeSnapshot(JsonGenerator json, Snapshot snapshot) throws IOException {
+    json.writeNumberField("max", convertDuration(snapshot.getMax()));
+    json.writeNumberField("mean", convertDuration(snapshot.getMean()));
+    json.writeNumberField("min", convertDuration(snapshot.getMin()));
+    json.writeNumberField("stddev", convertDuration(snapshot.getStdDev()));
+    json.writeNumberField("median", convertDuration(snapshot.getMedian()));
+    json.writeNumberField("p75", convertDuration(snapshot.get75thPercentile()));
+    json.writeNumberField("p95", convertDuration(snapshot.get95thPercentile()));
+    json.writeNumberField("p98", convertDuration(snapshot.get98thPercentile()));
+    json.writeNumberField("p99", convertDuration(snapshot.get99thPercentile()));
+    json.writeNumberField("p999", convertDuration(snapshot.get999thPercentile()));
+  }
+
+  private void writeMetered(JsonGenerator json, Metered meter) throws IOException {
+    json.writeNumberField("count", convertRate(meter.getCount()));
+    json.writeNumberField("mean", convertRate(meter.getMeanRate()));
+    json.writeNumberField("m1", convertRate(meter.getOneMinuteRate()));
+    json.writeNumberField("m5", convertRate(meter.getFiveMinuteRate()));
+    json.writeNumberField("m15", convertRate(meter.getFifteenMinuteRate()));
+  }
+
+
+  private String sanitize(String metricName) {
+    return SIMPLE_NAMES.matcher(metricName).replaceAll("_");
+  }
+
+  public static Builder forRegistry(MetricRegistry registry) {
+    return new Builder(registry);
+  }
+
+  public static class Builder {
+
+    private final MetricRegistry registry;
+    private       MetricFilter   filter       = MetricFilter.ALL;
+    private       TimeUnit       rateUnit     = TimeUnit.SECONDS;
+    private       TimeUnit       durationUnit = TimeUnit.MILLISECONDS;
+    private       String         token;
+    private       String         hostname;
+
+    private Builder(MetricRegistry registry) {
+      this.registry     = registry;
+      this.rateUnit     = TimeUnit.SECONDS;
+      this.durationUnit = TimeUnit.MILLISECONDS;
+      this.filter       = MetricFilter.ALL;
+    }
+
+    public Builder convertRatesTo(TimeUnit rateUnit) {
+      this.rateUnit = rateUnit;
+      return this;
+    }
+
+    public Builder convertDurationsTo(TimeUnit durationUnit) {
+      this.durationUnit = durationUnit;
+      return this;
+    }
+
+    public Builder filter(MetricFilter filter) {
+      this.filter = filter;
+      return this;
+    }
+
+    public Builder withToken(String token) {
+      this.token = token;
+      return this;
+    }
+
+    public Builder withHostname(String hostname) {
+      this.hostname = hostname;
+      return this;
+    }
+
+    public JsonMetricsReporter build() throws UnknownHostException {
+      if (hostname == null) {
+        throw new IllegalArgumentException("No hostname specified!");
+      }
+
+      if (token == null) {
+        throw new IllegalArgumentException("No token specified!");
+      }
+
+      return new JsonMetricsReporter(registry, token, hostname, filter, rateUnit, durationUnit);
+    }
+  }
 }

src/main/java/org/whispersystems/textsecuregcm/metrics/JsonMetricsReporterFactory.java

@@ -0,0 +1,38 @@
+package org.whispersystems.textsecuregcm.metrics;
+
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.ScheduledReporter;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonTypeName;
+
+import javax.validation.constraints.NotNull;
+import java.net.UnknownHostException;
+
+import io.dropwizard.metrics.BaseReporterFactory;
+
+@JsonTypeName("json")
+public class JsonMetricsReporterFactory extends BaseReporterFactory {
+
+  @JsonProperty
+  @NotNull
+  private String hostname;
+
+  @JsonProperty
+  @NotNull
+  private String token;
+
+  @Override
+  public ScheduledReporter build(MetricRegistry metricRegistry) {
+    try {
+      return JsonMetricsReporter.forRegistry(metricRegistry)
+                                .withHostname(hostname)
+                                .withToken(token)
+                                .convertRatesTo(getRateUnit())
+                                .convertDurationsTo(getDurationUnit())
+                                .filter(getFilter())
+                                .build();
+    } catch (UnknownHostException e) {
+      throw new IllegalArgumentException(e);
+    }
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/metrics/NetworkGauge.java

@@ -1,16 +1,15 @@
 package org.whispersystems.textsecuregcm.metrics;
 
 
-import com.yammer.metrics.core.Gauge;
+import com.codahale.metrics.Gauge;
 import org.whispersystems.textsecuregcm.util.Pair;
 
 import java.io.BufferedReader;
 import java.io.File;
-import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 
-public abstract class NetworkGauge extends Gauge<Long> {
+public abstract class NetworkGauge implements Gauge<Long> {
 
   protected Pair<Long, Long> getSentReceived() throws IOException {
     File           proc          = new File("/proc/net/dev");

src/main/java/org/whispersystems/textsecuregcm/metrics/NetworkReceivedGauge.java

@@ -14,7 +14,7 @@ public class NetworkReceivedGauge extends NetworkGauge {
   private long lastReceived;
 
   @Override
-  public Long value() {
+  public Long getValue() {
     try {
       long             timestamp       = System.currentTimeMillis();
       Pair<Long, Long> sentAndReceived = getSentReceived();

src/main/java/org/whispersystems/textsecuregcm/metrics/NetworkSentGauge.java

@@ -14,7 +14,7 @@ public class NetworkSentGauge extends NetworkGauge {
   private long lastSent;
 
   @Override
-  public Long value() {
+  public Long getValue() {
     try {
       long             timestamp       = System.currentTimeMillis();
       Pair<Long, Long> sentAndReceived = getSentReceived();

src/main/java/org/whispersystems/textsecuregcm/providers/MemcacheHealthCheck.java

@@ -1,53 +0,0 @@
-/**
- * Copyright (C) 2013 Open WhisperSystems
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-package org.whispersystems.textsecuregcm.providers;
-
-import com.yammer.metrics.core.HealthCheck;
-import com.yammer.metrics.core.HealthCheck.Result;
-import net.spy.memcached.MemcachedClient;
-
-import java.security.SecureRandom;
-
-public class MemcacheHealthCheck extends HealthCheck {
-
-  private final MemcachedClient client;
-
-  public MemcacheHealthCheck(MemcachedClient client) {
-    super("memcached");
-    this.client = client;
-  }
-
-  @Override
-  protected Result check() throws Exception {
-    if (client == null) {
-      return Result.unhealthy("not configured");
-    }
-
-    int random = SecureRandom.getInstance("SHA1PRNG").nextInt();
-    int value  = SecureRandom.getInstance("SHA1PRNG").nextInt();
-
-    this.client.set("HEALTH" + random, 2000, String.valueOf(value));
-    String result = (String)this.client.get("HEALTH" + random);
-
-    if (result == null || Integer.parseInt(result) != value) {
-      return Result.unhealthy("Fetch failed");
-    }
-
-    return Result.healthy();
-  }
-
-}

src/main/java/org/whispersystems/textsecuregcm/providers/MemcachedClientFactory.java

@@ -1,54 +0,0 @@
-/**
- * Copyright (C) 2013 Open WhisperSystems
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-package org.whispersystems.textsecuregcm.providers;
-
-import net.spy.memcached.AddrUtil;
-import net.spy.memcached.ConnectionFactoryBuilder;
-import net.spy.memcached.MemcachedClient;
-import net.spy.memcached.auth.AuthDescriptor;
-import net.spy.memcached.auth.PlainCallbackHandler;
-import org.whispersystems.textsecuregcm.configuration.MemcacheConfiguration;
-import org.whispersystems.textsecuregcm.util.Util;
-
-import java.io.IOException;
-
-public class MemcachedClientFactory {
-
-  private final MemcachedClient client;
-
-  public MemcachedClientFactory(MemcacheConfiguration config) throws IOException {
-    ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder();
-    builder.setProtocol(ConnectionFactoryBuilder.Protocol.BINARY);
-
-    if (!Util.isEmpty(config.getUser())) {
-      AuthDescriptor ad = new AuthDescriptor(new String[] { "PLAIN" },
-                                             new PlainCallbackHandler(config.getUser(),
-                                                                      config.getPassword()));
-
-      builder.setAuthDescriptor(ad);
-    }
-
-
-    this.client = new MemcachedClient(builder.build(),
-                                      AddrUtil.getAddresses(config.getServers()));
-  }
-
-
-  public MemcachedClient getClient() {
-    return client;
-  }
-}

src/main/java/org/whispersystems/textsecuregcm/providers/RedisClientFactory.java

@@ -16,7 +16,6 @@
  */
 package org.whispersystems.textsecuregcm.providers;
 
-import org.whispersystems.textsecuregcm.configuration.RedisConfiguration;
 import org.whispersystems.textsecuregcm.util.Util;
 
 import java.net.URI;
@@ -30,11 +29,11 @@ public class RedisClientFactory {
 
   private final JedisPool jedisPool;
 
-  public RedisClientFactory(RedisConfiguration redisConfig) throws URISyntaxException {
+  public RedisClientFactory(String url) throws URISyntaxException {
     JedisPoolConfig poolConfig = new JedisPoolConfig();
     poolConfig.setTestOnBorrow(true);
 
-    URI    redisURI      = new URI(redisConfig.getUrl());
+    URI    redisURI      = new URI(url);
     String redisHost     = redisURI.getHost();
     int    redisPort     = redisURI.getPort();
     String redisPassword = null;

src/main/java/org/whispersystems/textsecuregcm/providers/RedisHealthCheck.java

@@ -16,7 +16,7 @@
  */
 package org.whispersystems.textsecuregcm.providers;
 
-import com.yammer.metrics.core.HealthCheck;
+import com.codahale.metrics.health.HealthCheck;
 
 import redis.clients.jedis.Jedis;
 import redis.clients.jedis.JedisPool;
@@ -26,7 +26,6 @@ public class RedisHealthCheck extends HealthCheck {
   private final JedisPool clientPool;
 
   public RedisHealthCheck(JedisPool clientPool) {
-    super("redis");
     this.clientPool = clientPool;
   }
 

src/main/java/org/whispersystems/textsecuregcm/providers/TimeProvider.java

@@ -0,0 +1,7 @@
+package org.whispersystems.textsecuregcm.providers;
+
+public class TimeProvider {
+  public long getCurrentTimeMillis() {
+    return System.currentTimeMillis();
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/push/APNSender.java

@@ -1,116 +0,0 @@
-/**
- * Copyright (C) 2013 Open WhisperSystems
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-package org.whispersystems.textsecuregcm.push;
-
-import com.google.common.base.Optional;
-import com.notnoop.apns.APNS;
-import com.notnoop.apns.ApnsService;
-import com.notnoop.exceptions.NetworkIOException;
-import com.yammer.metrics.Metrics;
-import com.yammer.metrics.core.Meter;
-import org.bouncycastle.openssl.PEMReader;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.whispersystems.textsecuregcm.entities.CryptoEncodingException;
-import org.whispersystems.textsecuregcm.entities.EncryptedOutgoingMessage;
-import org.whispersystems.textsecuregcm.util.Util;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.security.KeyPair;
-import java.security.KeyStore;
-import java.security.KeyStoreException;
-import java.security.NoSuchAlgorithmException;
-import java.security.cert.Certificate;
-import java.security.cert.CertificateException;
-import java.security.cert.X509Certificate;
-import java.util.concurrent.TimeUnit;
-
-public class APNSender {
-
-  private final Meter  success = Metrics.newMeter(APNSender.class, "sent", "success", TimeUnit.MINUTES);
-  private final Meter  failure = Metrics.newMeter(APNSender.class, "sent", "failure", TimeUnit.MINUTES);
-  private final Logger logger  = LoggerFactory.getLogger(APNSender.class);
-
-  private static final String MESSAGE_BODY = "m";
-
-  private final Optional<ApnsService> apnService;
-
-  public APNSender(String apnCertificate, String apnKey)
-      throws CertificateException, NoSuchAlgorithmException, KeyStoreException, IOException
-  {
-    if (!Util.isEmpty(apnCertificate) && !Util.isEmpty(apnKey)) {
-      byte[] keyStore = initializeKeyStore(apnCertificate, apnKey);
-      this.apnService = Optional.of(APNS.newService()
-                                        .withCert(new ByteArrayInputStream(keyStore), "insecure")
-                                        .withSandboxDestination().build());
-    } else {
-      this.apnService = Optional.absent();
-    }
-  }
-
-  public void sendMessage(String registrationId, EncryptedOutgoingMessage message)
-      throws TransientPushFailureException, NotPushRegisteredException
-  {
-    try {
-      if (!apnService.isPresent()) {
-        failure.mark();
-        throw new TransientPushFailureException("APN access not configured!");
-      }
-
-      String payload = APNS.newPayload()
-                           .alertBody("Message!")
-                           .customField(MESSAGE_BODY, message.serialize())
-                           .build();
-
-      logger.debug("APN Payload: " + payload);
-
-      apnService.get().push(registrationId, payload);
-      success.mark();
-    } catch (NetworkIOException nioe) {
-      logger.warn("Network Error", nioe);
-      failure.mark();
-      throw new TransientPushFailureException(nioe);
-    } catch (CryptoEncodingException e) {
-      throw new NotPushRegisteredException(e);
-    }
-  }
-
-  private static byte[] initializeKeyStore(String pemCertificate, String pemKey)
-      throws KeyStoreException, CertificateException, NoSuchAlgorithmException, IOException
-  {
-    PEMReader       reader           = new PEMReader(new InputStreamReader(new ByteArrayInputStream(pemCertificate.getBytes())));
-    X509Certificate certificate      = (X509Certificate) reader.readObject();
-    Certificate[]   certificateChain = {certificate};
-
-    reader            = new PEMReader(new InputStreamReader(new ByteArrayInputStream(pemKey.getBytes())));
-    KeyPair keyPair = (KeyPair) reader.readObject();
-
-    KeyStore keyStore = KeyStore.getInstance("pkcs12");
-    keyStore.load(null);
-    keyStore.setEntry("apn",
-                      new KeyStore.PrivateKeyEntry(keyPair.getPrivate(), certificateChain),
-                      new KeyStore.PasswordProtection("insecure".toCharArray()));
-
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    keyStore.store(baos, "insecure".toCharArray());
-
-    return baos.toByteArray();
-  }
-}

src/main/java/org/whispersystems/textsecuregcm/push/FeedbackHandler.java

@@ -0,0 +1,109 @@
+package org.whispersystems.textsecuregcm.push;
+
+import com.google.common.base.Optional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.whispersystems.textsecuregcm.entities.UnregisteredEvent;
+import org.whispersystems.textsecuregcm.storage.Account;
+import org.whispersystems.textsecuregcm.storage.AccountsManager;
+import org.whispersystems.textsecuregcm.storage.Device;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import io.dropwizard.lifecycle.Managed;
+
+public class FeedbackHandler implements Managed, Runnable {
+
+  private final Logger logger = LoggerFactory.getLogger(PushServiceClient.class);
+
+  private final PushServiceClient client;
+  private final AccountsManager   accountsManager;
+
+  private ScheduledExecutorService executor;
+
+  public FeedbackHandler(PushServiceClient client, AccountsManager accountsManager) {
+    this.client          = client;
+    this.accountsManager = accountsManager;
+  }
+
+  @Override
+  public void start() throws Exception {
+    this.executor = Executors.newSingleThreadScheduledExecutor();
+    this.executor.scheduleAtFixedRate(this, 0, 1, TimeUnit.MINUTES);
+  }
+
+  @Override
+  public void stop() throws Exception {
+    if (this.executor != null) {
+      this.executor.shutdown();
+    }
+  }
+
+  @Override
+  public void run() {
+    try {
+      List<UnregisteredEvent> gcmFeedback = client.getGcmFeedback();
+      List<UnregisteredEvent> apnFeedback = client.getApnFeedback();
+
+      for (UnregisteredEvent gcmEvent : gcmFeedback) {
+        handleGcmUnregistered(gcmEvent);
+      }
+
+      for (UnregisteredEvent apnEvent : apnFeedback) {
+        handleApnUnregistered(apnEvent);
+      }
+    } catch (IOException e) {
+      logger.warn("Error retrieving feedback: ", e);
+    }
+  }
+
+  private void handleGcmUnregistered(UnregisteredEvent event) {
+    logger.info("Got GCM Unregistered: " + event.getNumber() + "," + event.getDeviceId());
+
+    Optional<Account> account = accountsManager.get(event.getNumber());
+
+    if (account.isPresent()) {
+      Optional<Device> device = account.get().getDevice(event.getDeviceId());
+
+      if (device.isPresent()) {
+        if (event.getRegistrationId().equals(device.get().getGcmId())) {
+          logger.info("GCM Unregister GCM ID matches!");
+          if (device.get().getPushTimestamp() == 0 ||
+              event.getTimestamp() > device.get().getPushTimestamp())
+          {
+            logger.info("GCM Unregister Timestamp matches!");
+            device.get().setGcmId(null);
+            accountsManager.update(account.get());
+          }
+        }
+      }
+    }
+  }
+
+  private void handleApnUnregistered(UnregisteredEvent event) {
+    logger.info("Got APN Unregistered: " + event.getNumber() + "," + event.getDeviceId());
+
+    Optional<Account> account = accountsManager.get(event.getNumber());
+
+    if (account.isPresent()) {
+      Optional<Device> device = account.get().getDevice(event.getDeviceId());
+
+      if (device.isPresent()) {
+        if (event.getRegistrationId().equals(device.get().getApnId())) {
+          logger.info("APN Unregister APN ID matches!");
+          if (device.get().getPushTimestamp() == 0 ||
+              event.getTimestamp() > device.get().getPushTimestamp())
+          {
+            logger.info("APN Unregister timestamp matches!");
+            device.get().setApnId(null);
+            accountsManager.update(account.get());
+          }
+        }
+      }
+    }
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/push/GCMSender.java

@@ -1,69 +0,0 @@
-/**
- * Copyright (C) 2013 Open WhisperSystems
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-package org.whispersystems.textsecuregcm.push;
-
-import com.google.android.gcm.server.Constants;
-import com.google.android.gcm.server.Message;
-import com.google.android.gcm.server.Result;
-import com.google.android.gcm.server.Sender;
-import com.yammer.metrics.Metrics;
-import com.yammer.metrics.core.Meter;
-import org.whispersystems.textsecuregcm.entities.CryptoEncodingException;
-import org.whispersystems.textsecuregcm.entities.EncryptedOutgoingMessage;
-
-import java.io.IOException;
-import java.util.concurrent.TimeUnit;
-
-public class GCMSender {
-
-  private final Meter success = Metrics.newMeter(GCMSender.class, "sent", "success", TimeUnit.MINUTES);
-  private final Meter failure = Metrics.newMeter(GCMSender.class, "sent", "failure", TimeUnit.MINUTES);
-
-  private final Sender sender;
-
-  public GCMSender(String apiKey) {
-    this.sender = new Sender(apiKey);
-  }
-
-  public String sendMessage(String gcmRegistrationId, EncryptedOutgoingMessage outgoingMessage)
-      throws NotPushRegisteredException, TransientPushFailureException
-  {
-    try {
-      Message gcmMessage = new Message.Builder().addData("type", "message")
-                                                .addData("message", outgoingMessage.serialize())
-                                                .build();
-
-      Result  result = sender.send(gcmMessage, gcmRegistrationId, 5);
-
-      if (result.getMessageId() != null) {
-        success.mark();
-        return result.getCanonicalRegistrationId();
-      } else {
-        failure.mark();
-        if (result.getErrorCodeName().equals(Constants.ERROR_NOT_REGISTERED)) {
-          throw new NotPushRegisteredException("Device no longer registered with GCM.");
-        } else {
-          throw new TransientPushFailureException("GCM Failed: " + result.getErrorCodeName());
-        }
-      }
-    } catch (IOException e) {
-      throw new TransientPushFailureException(e);
-    } catch (CryptoEncodingException e) {
-      throw new NotPushRegisteredException(e);
-    }
-  }
-}

src/main/java/org/whispersystems/textsecuregcm/push/PushSender.java

@@ -18,92 +18,95 @@ package org.whispersystems.textsecuregcm.push;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.whispersystems.textsecuregcm.configuration.ApnConfiguration;
-import org.whispersystems.textsecuregcm.configuration.GcmConfiguration;
+import org.whispersystems.textsecuregcm.entities.ApnMessage;
 import org.whispersystems.textsecuregcm.entities.CryptoEncodingException;
 import org.whispersystems.textsecuregcm.entities.EncryptedOutgoingMessage;
-import org.whispersystems.textsecuregcm.entities.MessageProtos;
+import org.whispersystems.textsecuregcm.entities.GcmMessage;
+import org.whispersystems.textsecuregcm.push.WebsocketSender.DeliveryStatus;
 import org.whispersystems.textsecuregcm.storage.Account;
-import org.whispersystems.textsecuregcm.storage.AccountsManager;
 import org.whispersystems.textsecuregcm.storage.Device;
-import org.whispersystems.textsecuregcm.storage.StoredMessageManager;
 
-import java.io.IOException;
-import java.security.KeyStoreException;
-import java.security.NoSuchAlgorithmException;
-import java.security.cert.CertificateException;
+import static org.whispersystems.textsecuregcm.entities.MessageProtos.OutgoingMessageSignal;
 
 public class PushSender {
 
   private final Logger logger = LoggerFactory.getLogger(PushSender.class);
 
-  private final AccountsManager      accounts;
-  private final GCMSender            gcmSender;
-  private final APNSender            apnSender;
-  private final StoredMessageManager storedMessageManager;
+  private static final String APN_PAYLOAD = "{\"aps\":{\"sound\":\"default\",\"badge\":%d,\"alert\":{\"loc-key\":\"APN_Message\"}}}";
 
-  public PushSender(GcmConfiguration gcmConfiguration,
-                    ApnConfiguration apnConfiguration,
-                    StoredMessageManager storedMessageManager,
-                    AccountsManager accounts)
-      throws CertificateException, NoSuchAlgorithmException, KeyStoreException, IOException
-  {
-    this.accounts             = accounts;
-    this.storedMessageManager = storedMessageManager;
-    this.gcmSender            = new GCMSender(gcmConfiguration.getApiKey());
-    this.apnSender            = new APNSender(apnConfiguration.getCertificate(), apnConfiguration.getKey());
+  private final PushServiceClient pushServiceClient;
+  private final WebsocketSender   webSocketSender;
+
+  public PushSender(PushServiceClient pushServiceClient, WebsocketSender websocketSender) {
+    this.pushServiceClient = pushServiceClient;
+    this.webSocketSender   = websocketSender;
   }
 
-  public void sendMessage(Account account, Device device, MessageProtos.OutgoingMessageSignal outgoingMessage)
+  public void sendMessage(Account account, Device device, OutgoingMessageSignal message)
       throws NotPushRegisteredException, TransientPushFailureException
   {
-    String                   signalingKey = device.getSignalingKey();
-    EncryptedOutgoingMessage message      = new EncryptedOutgoingMessage(outgoingMessage, signalingKey);
-
     if      (device.getGcmId() != null)   sendGcmMessage(account, device, message);
     else if (device.getApnId() != null)   sendApnMessage(account, device, message);
-    else if (device.getFetchesMessages()) storeFetchedMessage(account, device, message);
+    else if (device.getFetchesMessages()) sendWebSocketMessage(account, device, message);
     else                                  throw new NotPushRegisteredException("No delivery possible!");
   }
 
-  private void sendGcmMessage(Account account, Device device, EncryptedOutgoingMessage outgoingMessage)
-      throws NotPushRegisteredException, TransientPushFailureException
-  {
-    try {
-      String canonicalId = gcmSender.sendMessage(device.getGcmId(), outgoingMessage);
-
-      if (canonicalId != null) {
-        device.setGcmId(canonicalId);
-        accounts.update(account);
-      }
-
-    } catch (NotPushRegisteredException e) {
-      logger.debug("No Such User", e);
-      device.setGcmId(null);
-      accounts.update(account);
-      throw new NotPushRegisteredException(e);
-    }
+  public WebsocketSender getWebSocketSender() {
+    return webSocketSender;
   }
 
-  private void sendApnMessage(Account account, Device device, EncryptedOutgoingMessage outgoingMessage)
+  private void sendGcmMessage(Account account, Device device, OutgoingMessageSignal message)
+      throws TransientPushFailureException, NotPushRegisteredException
+  {
+    if (device.getFetchesMessages()) sendNotificationGcmMessage(account, device, message);
+    else                             sendPayloadGcmMessage(account, device, message);
+  }
+
+  private void sendPayloadGcmMessage(Account account, Device device, OutgoingMessageSignal message)
       throws TransientPushFailureException, NotPushRegisteredException
   {
     try {
-      apnSender.sendMessage(device.getApnId(), outgoingMessage);
-    } catch (NotPushRegisteredException e) {
-      device.setApnId(null);
-      accounts.update(account);
-      throw new NotPushRegisteredException(e);
-    }
-  }
+      String                   number           = account.getNumber();
+      long                     deviceId         = device.getId();
+      String                   registrationId   = device.getGcmId();
+      boolean                  isReceipt        = message.getType() == OutgoingMessageSignal.Type.RECEIPT_VALUE;
+      EncryptedOutgoingMessage encryptedMessage = new EncryptedOutgoingMessage(message, device.getSignalingKey());
+      GcmMessage               gcmMessage       = new GcmMessage(registrationId, number, (int) deviceId,
+                                                                 encryptedMessage.toEncodedString(), isReceipt, false);
 
-  private void storeFetchedMessage(Account account, Device device, EncryptedOutgoingMessage outgoingMessage)
-      throws NotPushRegisteredException
-  {
-    try {
-      storedMessageManager.storeMessage(account, device, outgoingMessage);
+      pushServiceClient.send(gcmMessage);
     } catch (CryptoEncodingException e) {
       throw new NotPushRegisteredException(e);
     }
   }
+
+  private void sendNotificationGcmMessage(Account account, Device device, OutgoingMessageSignal message)
+      throws TransientPushFailureException
+  {
+    DeliveryStatus deliveryStatus = webSocketSender.sendMessage(account, device, message, WebsocketSender.Type.GCM);
+
+    if (!deliveryStatus.isDelivered()) {
+      GcmMessage gcmMessage = new GcmMessage(device.getGcmId(), account.getNumber(),
+                                             (int)device.getId(), "", false, true);
+
+      pushServiceClient.send(gcmMessage);
+    }
+  }
+
+  private void sendApnMessage(Account account, Device device, OutgoingMessageSignal outgoingMessage)
+      throws TransientPushFailureException
+  {
+    DeliveryStatus deliveryStatus = webSocketSender.sendMessage(account, device, outgoingMessage, WebsocketSender.Type.APN);
+
+    if (!deliveryStatus.isDelivered() && outgoingMessage.getType() != OutgoingMessageSignal.Type.RECEIPT_VALUE) {
+      ApnMessage apnMessage = new ApnMessage(device.getApnId(), account.getNumber(), (int)device.getId(),
+                                             String.format(APN_PAYLOAD, deliveryStatus.getMessageQueueDepth()));
+      pushServiceClient.send(apnMessage);
+    }
+  }
+
+  private void sendWebSocketMessage(Account account, Device device, OutgoingMessageSignal outgoingMessage)
+  {
+    webSocketSender.sendMessage(account, device, outgoingMessage, WebsocketSender.Type.WEB);
+  }
 }

src/main/java/org/whispersystems/textsecuregcm/push/PushServiceClient.java

@@ -0,0 +1,91 @@
+package org.whispersystems.textsecuregcm.push;
+
+import com.sun.jersey.api.client.Client;
+import com.sun.jersey.api.client.ClientHandlerException;
+import com.sun.jersey.api.client.ClientResponse;
+import com.sun.jersey.api.client.UniformInterfaceException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.whispersystems.textsecuregcm.configuration.PushConfiguration;
+import org.whispersystems.textsecuregcm.entities.ApnMessage;
+import org.whispersystems.textsecuregcm.entities.GcmMessage;
+import org.whispersystems.textsecuregcm.entities.UnregisteredEvent;
+import org.whispersystems.textsecuregcm.entities.UnregisteredEventList;
+import org.whispersystems.textsecuregcm.util.Base64;
+
+import javax.ws.rs.core.MediaType;
+import java.io.IOException;
+import java.util.List;
+
+public class PushServiceClient {
+
+  private static final String PUSH_GCM_PATH     = "/api/v1/push/gcm";
+  private static final String PUSH_APN_PATH     = "/api/v1/push/apn";
+
+  private static final String APN_FEEDBACK_PATH = "/api/v1/feedback/apn";
+  private static final String GCM_FEEDBACK_PATH = "/api/v1/feedback/gcm";
+
+  private final Logger logger = LoggerFactory.getLogger(PushServiceClient.class);
+
+  private final Client client;
+  private final String host;
+  private final int    port;
+  private final String authorization;
+
+  public PushServiceClient(Client client, PushConfiguration config) {
+    this.client        = client;
+    this.host          = config.getHost();
+    this.port          = config.getPort();
+    this.authorization = getAuthorizationHeader(config.getUsername(), config.getPassword());
+  }
+
+  public void send(GcmMessage message) throws TransientPushFailureException {
+    sendPush(PUSH_GCM_PATH, message);
+  }
+
+  public void send(ApnMessage message) throws TransientPushFailureException {
+    sendPush(PUSH_APN_PATH, message);
+  }
+
+  public List<UnregisteredEvent> getGcmFeedback() throws IOException {
+    return getFeedback(GCM_FEEDBACK_PATH);
+  }
+
+  public List<UnregisteredEvent> getApnFeedback() throws IOException {
+    return getFeedback(APN_FEEDBACK_PATH);
+  }
+
+  private void sendPush(String path, Object entity) throws TransientPushFailureException {
+    try {
+      ClientResponse response = client.resource("http://" + host + ":" + port + path)
+                                      .header("Authorization", authorization)
+                                      .entity(entity, MediaType.APPLICATION_JSON)
+                                      .put(ClientResponse.class);
+
+      if (response.getStatus() != 204 && response.getStatus() != 200) {
+        logger.warn("PushServer response: " + response.getStatus() + " " + response.getStatusInfo().getReasonPhrase());
+        throw new TransientPushFailureException("Bad response: " + response.getStatus());
+      }
+    } catch (UniformInterfaceException | ClientHandlerException e) {
+      logger.warn("Push error: ", e);
+      throw new TransientPushFailureException(e);
+    }
+  }
+
+  private List<UnregisteredEvent> getFeedback(String path) throws IOException {
+    try {
+      UnregisteredEventList unregisteredEvents = client.resource("http://" + host + ":" + port + path)
+                                                       .header("Authorization", authorization)
+                                                       .get(UnregisteredEventList.class);
+
+      return unregisteredEvents.getDevices();
+    } catch (UniformInterfaceException | ClientHandlerException e) {
+      logger.warn("Request error:", e);
+      throw new IOException(e);
+    }
+  }
+
+  private String getAuthorizationHeader(String username, String password) {
+    return "Basic " + Base64.encodeBytes((username + ":" + password).getBytes());
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/push/WebsocketSender.java

@@ -0,0 +1,129 @@
+/**
+ * Copyright (C) 2014 Open WhisperSystems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.push;
+
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.SharedMetricRegistries;
+import com.google.protobuf.ByteString;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.whispersystems.textsecuregcm.storage.Account;
+import org.whispersystems.textsecuregcm.storage.Device;
+import org.whispersystems.textsecuregcm.storage.MessagesManager;
+import org.whispersystems.textsecuregcm.storage.PubSubManager;
+import org.whispersystems.textsecuregcm.util.Constants;
+import org.whispersystems.textsecuregcm.websocket.ProvisioningAddress;
+import org.whispersystems.textsecuregcm.websocket.WebsocketAddress;
+
+import static com.codahale.metrics.MetricRegistry.name;
+import static org.whispersystems.textsecuregcm.entities.MessageProtos.OutgoingMessageSignal;
+import static org.whispersystems.textsecuregcm.storage.PubSubProtos.PubSubMessage;
+
+public class WebsocketSender {
+
+  public static enum Type {
+    APN,
+    GCM,
+    WEB
+  }
+
+  private static final Logger logger = LoggerFactory.getLogger(WebsocketSender.class);
+
+  private final MetricRegistry metricRegistry = SharedMetricRegistries.getOrCreate(Constants.METRICS_NAME);
+
+  private final Meter websocketOnlineMeter  = metricRegistry.meter(name(getClass(), "ws_online"  ));
+  private final Meter websocketOfflineMeter = metricRegistry.meter(name(getClass(), "ws_offline" ));
+
+  private final Meter apnOnlineMeter        = metricRegistry.meter(name(getClass(), "apn_online" ));
+  private final Meter apnOfflineMeter       = metricRegistry.meter(name(getClass(), "apn_offline"));
+
+  private final Meter gcmOnlineMeter        = metricRegistry.meter(name(getClass(), "gcm_online" ));
+  private final Meter gcmOfflineMeter       = metricRegistry.meter(name(getClass(), "gcm_offline"));
+
+  private final Meter provisioningOnlineMeter  = metricRegistry.meter(name(getClass(), "provisioning_online" ));
+  private final Meter provisioningOfflineMeter = metricRegistry.meter(name(getClass(), "provisioning_offline"));
+
+  private final MessagesManager messagesManager;
+  private final PubSubManager   pubSubManager;
+
+  public WebsocketSender(MessagesManager messagesManager, PubSubManager pubSubManager) {
+    this.messagesManager = messagesManager;
+    this.pubSubManager   = pubSubManager;
+  }
+
+  public DeliveryStatus sendMessage(Account account, Device device, OutgoingMessageSignal message, Type channel) {
+    WebsocketAddress address       = new WebsocketAddress(account.getNumber(), device.getId());
+    PubSubMessage    pubSubMessage = PubSubMessage.newBuilder()
+                                                  .setType(PubSubMessage.Type.DELIVER)
+                                                  .setContent(message.toByteString())
+                                                  .build();
+
+    if (pubSubManager.publish(address, pubSubMessage)) {
+      if      (channel == Type.APN) apnOnlineMeter.mark();
+      else if (channel == Type.GCM) gcmOnlineMeter.mark();
+      else                          websocketOnlineMeter.mark();
+
+      return new DeliveryStatus(true, 0);
+    } else {
+      if      (channel == Type.APN) apnOfflineMeter.mark();
+      else if (channel == Type.GCM) gcmOfflineMeter.mark();
+      else                          websocketOfflineMeter.mark();
+
+      int queueDepth = messagesManager.insert(account.getNumber(), device.getId(), message);
+      pubSubManager.publish(address, PubSubMessage.newBuilder()
+                                                  .setType(PubSubMessage.Type.QUERY_DB)
+                                                  .build());
+
+      return new DeliveryStatus(false, queueDepth);
+    }
+  }
+
+  public boolean sendProvisioningMessage(ProvisioningAddress address, byte[] body) {
+    PubSubMessage    pubSubMessage = PubSubMessage.newBuilder()
+                                                  .setType(PubSubMessage.Type.DELIVER)
+                                                  .setContent(ByteString.copyFrom(body))
+                                                  .build();
+
+    if (pubSubManager.publish(address, pubSubMessage)) {
+      provisioningOnlineMeter.mark();
+      return true;
+    } else {
+      provisioningOfflineMeter.mark();
+      return false;
+    }
+  }
+
+  public static class DeliveryStatus {
+
+    private final boolean delivered;
+    private final int     messageQueueDepth;
+
+    public DeliveryStatus(boolean delivered, int messageQueueDepth) {
+      this.delivered = delivered;
+      this.messageQueueDepth = messageQueueDepth;
+    }
+
+    public boolean isDelivered() {
+      return delivered;
+    }
+
+    public int getMessageQueueDepth() {
+      return messageQueueDepth;
+    }
+  }
+}

src/main/java/org/whispersystems/textsecuregcm/sms/NexmoSmsSender.java

@@ -16,11 +16,13 @@
  */
 package org.whispersystems.textsecuregcm.sms;
 
-import com.yammer.metrics.Metrics;
-import com.yammer.metrics.core.Meter;
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.SharedMetricRegistries;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.configuration.NexmoConfiguration;
+import org.whispersystems.textsecuregcm.util.Constants;
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -28,13 +30,15 @@ import java.io.InputStreamReader;
 import java.net.URL;
 import java.net.URLConnection;
 import java.net.URLEncoder;
-import java.util.concurrent.TimeUnit;
+
+import static com.codahale.metrics.MetricRegistry.name;
 
 public class NexmoSmsSender {
 
-  private final Meter  smsMeter = Metrics.newMeter(NexmoSmsSender.class, "sms", "delivered", TimeUnit.MINUTES);
-  private final Meter  voxMeter = Metrics.newMeter(NexmoSmsSender.class, "vox", "delivered", TimeUnit.MINUTES);
-  private final Logger logger   = LoggerFactory.getLogger(NexmoSmsSender.class);
+  private final MetricRegistry metricRegistry = SharedMetricRegistries.getOrCreate(Constants.METRICS_NAME);
+  private final Meter          smsMeter       = metricRegistry.meter(name(getClass(), "sms", "delivered"));
+  private final Meter          voxMeter       = metricRegistry.meter(name(getClass(), "vox", "delivered"));
+  private final Logger         logger         = LoggerFactory.getLogger(NexmoSmsSender.class);
 
   private static final String NEXMO_SMS_URL =
       "https://rest.nexmo.com/sms/json?api_key=%s&api_secret=%s&from=%s&to=%s&text=%s";

src/main/java/org/whispersystems/textsecuregcm/sms/SmsSender.java

@@ -53,7 +53,7 @@ public class SmsSender {
       try {
         twilioSender.deliverSmsVerification(destination, verificationCode);
       } catch (TwilioRestException e) {
-        logger.info("Twilio SMS Fallback", e);
+        logger.info("Twilio SMS Failed: " + e.getErrorMessage());
         if (nexmoSender.isPresent()) {
           nexmoSender.get().deliverSmsVerification(destination, verificationCode);
         }
@@ -70,7 +70,7 @@ public class SmsSender {
       try {
         twilioSender.deliverVoxVerification(destination, verificationCode);
       } catch (TwilioRestException e) {
-        logger.info("Twilio Vox Fallback", e);
+        logger.info("Twilio Vox Failed: " + e.getErrorMessage());
         if (nexmoSender.isPresent()) {
           nexmoSender.get().deliverVoxVerification(destination, verificationCode);
         }

src/main/java/org/whispersystems/textsecuregcm/sms/TwilioSmsSender.java

@@ -16,32 +16,36 @@
  */
 package org.whispersystems.textsecuregcm.sms;
 
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.SharedMetricRegistries;
 import com.twilio.sdk.TwilioRestClient;
 import com.twilio.sdk.TwilioRestException;
 import com.twilio.sdk.resource.factory.CallFactory;
 import com.twilio.sdk.resource.factory.MessageFactory;
-import com.yammer.metrics.Metrics;
-import com.yammer.metrics.core.Meter;
 import org.apache.http.NameValuePair;
 import org.apache.http.message.BasicNameValuePair;
 import org.whispersystems.textsecuregcm.configuration.TwilioConfiguration;
+import org.whispersystems.textsecuregcm.util.Constants;
 
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
+
+import static com.codahale.metrics.MetricRegistry.name;
 
 public class TwilioSmsSender {
 
   public static final String SAY_TWIML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
                                          "<Response>\n" +
-                                         "    <Say voice=\"woman\" language=\"en\">" + SmsSender.VOX_VERIFICATION_TEXT + "%s</Say>\n" +
+                                         "    <Say voice=\"woman\" language=\"en\" loop=\"3\">" + SmsSender.VOX_VERIFICATION_TEXT + "%s.</Say>\n" +
                                          "</Response>";
 
-  private final Meter smsMeter = Metrics.newMeter(TwilioSmsSender.class, "sms", "delivered", TimeUnit.MINUTES);
-  private final Meter voxMeter = Metrics.newMeter(TwilioSmsSender.class, "vox", "delivered", TimeUnit.MINUTES);
+  private final MetricRegistry metricRegistry = SharedMetricRegistries.getOrCreate(Constants.METRICS_NAME);
+  private final Meter          smsMeter       = metricRegistry.meter(name(getClass(), "sms", "delivered"));
+  private final Meter          voxMeter       = metricRegistry.meter(name(getClass(), "vox", "delivered"));
 
   private final String accountId;
   private final String accountToken;

src/main/java/org/whispersystems/textsecuregcm/storage/Account.java

@@ -22,16 +22,12 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Optional;
 
-import java.io.Serializable;
-import java.util.LinkedList;
-import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
 
-public class Account implements Serializable {
+public class Account {
 
-  public static final int MEMCACHE_VERION = 3;
-
-  @JsonIgnore
-  private long id;
+  public static final int MEMCACHE_VERION = 5;
 
   @JsonProperty
   private String number;
@@ -40,37 +36,29 @@ public class Account implements Serializable {
   private boolean supportsSms;
 
   @JsonProperty
-  private List<Device> devices = new LinkedList<>();
+  private Set<Device> devices = new HashSet<>();
 
   @JsonProperty
   private String identityKey;
 
   @JsonIgnore
-  private Optional<Device> authenticatedDevice;
+  private Device authenticatedDevice;
 
   public Account() {}
 
   @VisibleForTesting
-  public Account(String number, boolean supportsSms, List<Device> devices) {
+  public Account(String number, boolean supportsSms, Set<Device> devices) {
     this.number      = number;
     this.supportsSms = supportsSms;
     this.devices     = devices;
   }
 
-  public long getId() {
-    return id;
-  }
-
-  public void setId(long id) {
-    this.id = id;
-  }
-
   public Optional<Device> getAuthenticatedDevice() {
-    return authenticatedDevice;
+    return Optional.fromNullable(authenticatedDevice);
   }
 
   public void setAuthenticatedDevice(Device device) {
-    this.authenticatedDevice = Optional.of(device);
+    this.authenticatedDevice = device;
   }
 
   public void setNumber(String number) {
@@ -90,14 +78,11 @@ public class Account implements Serializable {
   }
 
   public void addDevice(Device device) {
+    this.devices.remove(device);
     this.devices.add(device);
   }
 
-  public void setDevices(List<Device> devices) {
-    this.devices = devices;
-  }
-
-  public List<Device> getDevices() {
+  public Set<Device> getDevices() {
     return devices;
   }
 
@@ -125,7 +110,9 @@ public class Account implements Serializable {
     long highestDevice = Device.MASTER_ID;
 
     for (Device device : devices) {
-      if (device.getId() > highestDevice) {
+      if (!device.isActive()) {
+        return device.getId();
+      } else if (device.getId() > highestDevice) {
         highestDevice = device.getId();
       }
     }
@@ -133,6 +120,16 @@ public class Account implements Serializable {
     return highestDevice + 1;
   }
 
+  public int getActiveDeviceCount() {
+    int count = 0;
+
+    for (Device device : devices) {
+      if (device.isActive()) count++;
+    }
+
+    return count;
+  }
+
   public boolean isRateLimited() {
     return true;
   }

src/main/java/org/whispersystems/textsecuregcm/storage/Accounts.java

@@ -33,6 +33,7 @@ import org.skife.jdbi.v2.sqlobject.SqlUpdate;
 import org.skife.jdbi.v2.sqlobject.Transaction;
 import org.skife.jdbi.v2.sqlobject.customizers.Mapper;
 import org.skife.jdbi.v2.tweak.ResultSetMapper;
+import org.whispersystems.textsecuregcm.util.SystemMapper;
 
 import java.io.IOException;
 import java.lang.annotation.Annotation;
@@ -51,12 +52,7 @@ public abstract class Accounts {
   private static final String NUMBER = "number";
   private static final String DATA   = "data";
 
-  private static final ObjectMapper mapper = new ObjectMapper();
-
-  static {
-    mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE);
-    mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
-  }
+  private static final ObjectMapper mapper = SystemMapper.getMapper();
 
   @SqlUpdate("INSERT INTO accounts (" + NUMBER + ", " + DATA + ") VALUES (:number, CAST(:data AS json))")
   @GetGeneratedKeys
@@ -89,6 +85,9 @@ public abstract class Accounts {
     return insertStep(account);
   }
 
+  @SqlUpdate("VACUUM accounts")
+  public abstract void vacuum();
+
   public static class AccountMapper implements ResultSetMapper<Account> {
     @Override
     public Account map(int i, ResultSet resultSet, StatementContext statementContext)
@@ -96,7 +95,7 @@ public abstract class Accounts {
     {
       try {
         Account account = mapper.readValue(resultSet.getString(DATA), Account.class);
-        account.setId(resultSet.getLong(ID));
+//        account.setId(resultSet.getLong(ID));
 
         return account;
       } catch (IOException e) {

src/main/java/org/whispersystems/textsecuregcm/storage/AccountsManager.java

@@ -17,27 +17,39 @@
 package org.whispersystems.textsecuregcm.storage;
 
 
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.base.Optional;
-import net.spy.memcached.MemcachedClient;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.entities.ClientContact;
+import org.whispersystems.textsecuregcm.util.SystemMapper;
 import org.whispersystems.textsecuregcm.util.Util;
 
+import java.io.IOException;
 import java.util.Iterator;
 import java.util.List;
 
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPool;
+
 public class AccountsManager {
 
+  private final Logger logger = LoggerFactory.getLogger(AccountsManager.class);
+
   private final Accounts         accounts;
-  private final MemcachedClient  memcachedClient;
+  private final JedisPool        cacheClient;
   private final DirectoryManager directory;
+  private final ObjectMapper     mapper;
 
   public AccountsManager(Accounts accounts,
                          DirectoryManager directory,
-                         MemcachedClient memcachedClient)
+                         JedisPool cacheClient)
   {
-    this.accounts        = accounts;
-    this.directory       = directory;
-    this.memcachedClient = memcachedClient;
+    this.accounts    = accounts;
+    this.directory   = directory;
+    this.cacheClient = cacheClient;
+    this.mapper      = SystemMapper.getMapper();
   }
 
   public long getCount() {
@@ -54,40 +66,28 @@ public class AccountsManager {
 
   public void create(Account account) {
     accounts.create(account);
-
-    if (memcachedClient != null) {
-      memcachedClient.set(getKey(account.getNumber()), 0, account);
-    }
-
+    memcacheSet(account.getNumber(), account);
     updateDirectory(account);
   }
 
   public void update(Account account) {
-    if (memcachedClient != null) {
-      memcachedClient.set(getKey(account.getNumber()), 0, account);
-    }
-
+    memcacheSet(account.getNumber(), account);
     accounts.update(account);
     updateDirectory(account);
   }
 
   public Optional<Account> get(String number) {
-    Account account = null;
+    Optional<Account> account = memcacheGet(number);
 
-    if (memcachedClient != null) {
-      account = (Account)memcachedClient.get(getKey(number));
-    }
+    if (!account.isPresent()) {
+      account = Optional.fromNullable(accounts.get(number));
 
-    if (account == null) {
-      account = accounts.get(number);
-
-      if (account != null && memcachedClient != null) {
-        memcachedClient.set(getKey(number), 0, account);
+      if (account.isPresent()) {
+        memcacheSet(number, account.get());
       }
     }
 
-    if (account != null) return Optional.of(account);
-    else                 return Optional.absent();
+    return account;
   }
 
   public boolean isRelayListed(String number) {
@@ -111,4 +111,24 @@ public class AccountsManager {
     return Account.class.getSimpleName() + Account.MEMCACHE_VERION + number;
   }
 
+  private void memcacheSet(String number, Account account) {
+    try (Jedis jedis = cacheClient.getResource()) {
+      jedis.set(getKey(number), mapper.writeValueAsString(account));
+    } catch (JsonProcessingException e) {
+      throw new IllegalArgumentException(e);
+    }
+  }
+
+  private Optional<Account> memcacheGet(String number) {
+    try (Jedis jedis = cacheClient.getResource()) {
+      String json = jedis.get(getKey(number));
+
+      if (json != null) return Optional.of(mapper.readValue(json, Account.class));
+      else              return Optional.absent();
+    } catch (IOException e) {
+      logger.warn("AccountsManager", "Deserialization error", e);
+      return Optional.absent();
+    }
+  }
+
 }

src/main/java/org/whispersystems/textsecuregcm/storage/Device.java

@@ -19,11 +19,12 @@ package org.whispersystems.textsecuregcm.storage;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import org.whispersystems.textsecuregcm.auth.AuthenticationCredentials;
+import org.whispersystems.textsecuregcm.entities.SignedPreKey;
 import org.whispersystems.textsecuregcm.util.Util;
 
-import java.io.Serializable;
+import java.util.concurrent.TimeUnit;
 
-public class Device implements Serializable {
+public class Device {
 
   public static final long MASTER_ID = 1;
 
@@ -45,17 +46,27 @@ public class Device implements Serializable {
   @JsonProperty
   private String  apnId;
 
+  @JsonProperty
+  private long pushTimestamp;
+
   @JsonProperty
   private boolean fetchesMessages;
 
   @JsonProperty
   private int registrationId;
 
+  @JsonProperty
+  private SignedPreKey signedPreKey;
+
+  @JsonProperty
+  private long lastSeen;
+
   public Device() {}
 
   public Device(long id, String authToken, String salt,
                 String signalingKey, String gcmId, String apnId,
-                boolean fetchesMessages, int registrationId)
+                boolean fetchesMessages, int registrationId,
+                SignedPreKey signedPreKey, long lastSeen)
   {
     this.id              = id;
     this.authToken       = authToken;
@@ -65,6 +76,8 @@ public class Device implements Serializable {
     this.apnId           = apnId;
     this.fetchesMessages = fetchesMessages;
     this.registrationId  = registrationId;
+    this.signedPreKey    = signedPreKey;
+    this.lastSeen        = lastSeen;
   }
 
   public String getApnId() {
@@ -73,6 +86,18 @@ public class Device implements Serializable {
 
   public void setApnId(String apnId) {
     this.apnId = apnId;
+
+    if (apnId != null) {
+      this.pushTimestamp = System.currentTimeMillis();
+    }
+  }
+
+  public void setLastSeen(long lastSeen) {
+    this.lastSeen = lastSeen;
+  }
+
+  public long getLastSeen() {
+    return lastSeen;
   }
 
   public String getGcmId() {
@@ -81,6 +106,10 @@ public class Device implements Serializable {
 
   public void setGcmId(String gcmId) {
     this.gcmId = gcmId;
+
+    if (gcmId != null) {
+      this.pushTimestamp = System.currentTimeMillis();
+    }
   }
 
   public long getId() {
@@ -109,7 +138,10 @@ public class Device implements Serializable {
   }
 
   public boolean isActive() {
-    return fetchesMessages || !Util.isEmpty(getApnId()) || !Util.isEmpty(getGcmId());
+    boolean hasChannel = fetchesMessages || !Util.isEmpty(getApnId()) || !Util.isEmpty(getGcmId());
+
+    return (id == MASTER_ID && hasChannel) ||
+           (id != MASTER_ID && hasChannel && signedPreKey != null && lastSeen > (System.currentTimeMillis() - TimeUnit.DAYS.toMillis(30)));
   }
 
   public boolean getFetchesMessages() {
@@ -131,4 +163,29 @@ public class Device implements Serializable {
   public void setRegistrationId(int registrationId) {
     this.registrationId = registrationId;
   }
+
+  public SignedPreKey getSignedPreKey() {
+    return signedPreKey;
+  }
+
+  public void setSignedPreKey(SignedPreKey signedPreKey) {
+    this.signedPreKey = signedPreKey;
+  }
+
+  public long getPushTimestamp() {
+    return pushTimestamp;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (other == null || !(other instanceof Device)) return false;
+
+    Device that = (Device)other;
+    return this.id == that.id;
+  }
+
+  @Override
+  public int hashCode() {
+    return (int)this.id;
+  }
 }

src/main/java/org/whispersystems/textsecuregcm/storage/DirectoryManager.java

@@ -16,14 +16,19 @@
  */
 package org.whispersystems.textsecuregcm.storage;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.base.Optional;
-import com.google.gson.Gson;
-import com.google.gson.annotations.SerializedName;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.entities.ClientContact;
 import org.whispersystems.textsecuregcm.util.IterablePair;
 import org.whispersystems.textsecuregcm.util.Pair;
 import org.whispersystems.textsecuregcm.util.Util;
 
+import java.io.IOException;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -34,12 +39,17 @@ import redis.clients.jedis.Response;
 
 public class DirectoryManager {
 
+  private final Logger logger = LoggerFactory.getLogger(DirectoryManager.class);
+
   private static final byte[] DIRECTORY_KEY = {'d', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y'};
 
+  private final ObjectMapper objectMapper;
   private final JedisPool redisPool;
 
   public DirectoryManager(JedisPool redisPool) {
-    this.redisPool = redisPool;
+    this.redisPool    = redisPool;
+    this.objectMapper = new ObjectMapper();
+    this.objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
   }
 
   public void remove(String number) {
@@ -63,40 +73,48 @@ public class DirectoryManager {
 
   public void add(ClientContact contact) {
     TokenValue tokenValue = new TokenValue(contact.getRelay(), contact.isSupportsSms());
-    Jedis      jedis      = redisPool.getResource();
 
-    jedis.hset(DIRECTORY_KEY, contact.getToken(), new Gson().toJson(tokenValue).getBytes());
-    redisPool.returnResource(jedis);
+    try (Jedis jedis = redisPool.getResource()) {
+      jedis.hset(DIRECTORY_KEY, contact.getToken(), objectMapper.writeValueAsBytes(tokenValue));
+    } catch (JsonProcessingException e) {
+      logger.warn("JSON Serialization", e);
+    }
   }
 
   public void add(BatchOperationHandle handle, ClientContact contact) {
-    Pipeline   pipeline   = handle.pipeline;
-    TokenValue tokenValue = new TokenValue(contact.getRelay(), contact.isSupportsSms());
+    try {
+      Pipeline   pipeline   = handle.pipeline;
+      TokenValue tokenValue = new TokenValue(contact.getRelay(), contact.isSupportsSms());
 
-    pipeline.hset(DIRECTORY_KEY, contact.getToken(), new Gson().toJson(tokenValue).getBytes());
+      pipeline.hset(DIRECTORY_KEY, contact.getToken(), objectMapper.writeValueAsBytes(tokenValue));
+    } catch (JsonProcessingException e) {
+      logger.warn("JSON Serialization", e);
+    }
+  }
+
+  public PendingClientContact get(BatchOperationHandle handle, byte[] token) {
+    Pipeline pipeline = handle.pipeline;
+    return new PendingClientContact(objectMapper, token, pipeline.hget(DIRECTORY_KEY, token));
   }
 
   public Optional<ClientContact> get(byte[] token) {
-    Jedis jedis = redisPool.getResource();
-
-    try {
+    try (Jedis jedis = redisPool.getResource()) {
       byte[] result = jedis.hget(DIRECTORY_KEY, token);
 
       if (result == null) {
         return Optional.absent();
       }
 
-      TokenValue tokenValue = new Gson().fromJson(new String(result), TokenValue.class);
+      TokenValue tokenValue = objectMapper.readValue(result, TokenValue.class);
       return Optional.of(new ClientContact(token, tokenValue.relay, tokenValue.supportsSms));
-    } finally {
-      redisPool.returnResource(jedis);
+    } catch (IOException e) {
+      logger.warn("JSON Error", e);
+      return Optional.absent();
     }
   }
 
   public List<ClientContact> get(List<byte[]> tokens) {
-    Jedis jedis = redisPool.getResource();
-
-    try {
+    try (Jedis jedis = redisPool.getResource()) {
       Pipeline               pipeline = jedis.pipelined();
       List<Response<byte[]>> futures  = new LinkedList<>();
       List<ClientContact>    results  = new LinkedList<>();
@@ -112,17 +130,19 @@ public class DirectoryManager {
       IterablePair<byte[], Response<byte[]>> lists = new IterablePair<>(tokens, futures);
 
       for (Pair<byte[], Response<byte[]>> pair : lists) {
-        if (pair.second().get() != null) {
-          TokenValue    tokenValue    = new Gson().fromJson(new String(pair.second().get()), TokenValue.class);
-          ClientContact clientContact = new ClientContact(pair.first(), tokenValue.relay, tokenValue.supportsSms);
+        try {
+          if (pair.second().get() != null) {
+            TokenValue    tokenValue    = objectMapper.readValue(pair.second().get(), TokenValue.class);
+            ClientContact clientContact = new ClientContact(pair.first(), tokenValue.relay, tokenValue.supportsSms);
 
-          results.add(clientContact);
+            results.add(clientContact);
+          }
+        } catch (IOException e) {
+          logger.warn("Deserialization Problem: ", e);
         }
       }
 
       return results;
-    } finally {
-      redisPool.returnResource(jedis);
     }
   }
 
@@ -151,15 +171,42 @@ public class DirectoryManager {
   }
 
   private static class TokenValue {
-    @SerializedName("r")
+
+    @JsonProperty(value = "r")
     private String  relay;
 
-    @SerializedName("s")
+    @JsonProperty(value = "s")
     private boolean supportsSms;
 
+    public TokenValue() {}
+
     public TokenValue(String relay, boolean supportsSms) {
       this.relay       = relay;
       this.supportsSms = supportsSms;
     }
   }
+
+  public static class PendingClientContact {
+    private final ObjectMapper     objectMapper;
+    private final byte[]           token;
+    private final Response<byte[]> response;
+
+    PendingClientContact(ObjectMapper objectMapper, byte[] token, Response<byte[]> response) {
+      this.objectMapper = objectMapper;
+      this.token        = token;
+      this.response     = response;
+    }
+
+    public Optional<ClientContact> get() throws IOException {
+      byte[] result = response.get();
+
+      if (result == null) {
+        return Optional.absent();
+      }
+
+      TokenValue tokenValue = objectMapper.readValue(result, TokenValue.class);
+      return Optional.of(new ClientContact(token, tokenValue.relay, tokenValue.supportsSms));
+    }
+
+  }
 }