Bump version to 0.7

pom.xml

@@ -9,7 +9,7 @@
 
     <groupId>org.whispersystems.textsecure</groupId>
     <artifactId>TextSecureServer</artifactId>
-    <version>0.4</version>
+    <version>0.7</version>
 
     <dependencies>
         <dependency>

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

@@ -135,6 +135,10 @@ public class AccountController {
         throw new WebApplicationException(Response.status(403).build());
       }
 
+      if (accounts.isRelayListed(number)) {
+        throw new WebApplicationException(Response.status(417).build());
+      }
+
       Device device = new Device();
       device.setId(Device.MASTER_ID);
       device.setAuthenticationCredentials(new AuthenticationCredentials(password));

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

@@ -76,7 +76,7 @@ public class FederationController {
                                               @PathParam("attachmentId") long attachmentId)
       throws IOException
   {
-    return attachmentController.redirectToAttachment(new NonLimitedAccount("Unknown", peer.getName()),
+    return attachmentController.redirectToAttachment(new NonLimitedAccount("Unknown", -1, peer.getName()),
                                                      attachmentId, Optional.<String>absent());
   }
 
@@ -89,7 +89,7 @@ public class FederationController {
       throws IOException
   {
     try {
-      return keysController.get(new NonLimitedAccount("Unknown", peer.getName()), number, Optional.<String>absent());
+      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);
@@ -106,7 +106,7 @@ public class FederationController {
       throws IOException
   {
     try {
-      return keysController.getDeviceKey(new NonLimitedAccount("Unknown", peer.getName()),
+      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);
@@ -116,16 +116,17 @@ public class FederationController {
 
   @Timed
   @PUT
-  @Path("/messages/{source}/{destination}")
-  public void sendMessages(@Auth                     FederatedPeer peer,
-                           @PathParam("source")      String source,
-                           @PathParam("destination") String destination,
-                           @Valid                    IncomingMessageList messages)
+  @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, peer.getName()), destination, messages);
+      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);

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

@@ -23,6 +23,7 @@ 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.federation.FederatedClientManager;
 import org.whispersystems.textsecuregcm.federation.NoSuchPeerException;
@@ -73,6 +74,20 @@ public class KeysController {
     keys.store(account.getNumber(), device.getId(), preKeys.getKeys(), preKeys.getLastResortKey());
   }
 
+  @Timed
+  @GET
+  @Path("/")
+  @Produces(MediaType.APPLICATION_JSON)
+  public PreKeyStatus getStatus(@Auth Account account) {
+    int count = keys.getCount(account.getNumber(), account.getAuthenticatedDevice().get().getId());
+
+    if (count > 0) {
+      count = count - 1;
+    }
+
+    return new PreKeyStatus(count);
+  }
+
   @Timed
   @GET
   @Path("/{number}/{device_id}")

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

@@ -186,7 +186,8 @@ public class MessageController {
   {
     try {
       FederatedClient client = federatedClientManager.getClient(messages.getRelay());
-      client.sendMessages(source.getNumber(), destinationName, messages);
+      client.sendMessages(source.getNumber(), source.getAuthenticatedDevice().get().getId(),
+                          destinationName, messages);
     } catch (NoSuchPeerException e) {
       throw new NoSuchUserException(e);
     }

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

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

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

@@ -64,7 +64,7 @@ public class FederatedClient {
 
   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/%s";
+  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";
 
@@ -155,11 +155,11 @@ public class FederatedClient {
     }
   }
 
-  public void sendMessages(String source, String destination, IncomingMessageList messages)
+  public void sendMessages(String source, long sourceDeviceId, String destination, IncomingMessageList messages)
       throws IOException
   {
     try {
-      WebResource    resource = client.resource(peer.getUrl()).path(String.format(RELAY_MESSAGE_PATH, source, destination));
+      WebResource    resource = client.resource(peer.getUrl()).path(String.format(RELAY_MESSAGE_PATH, source, sourceDeviceId, destination));
       ClientResponse response = resource.type(MediaType.APPLICATION_JSON)
                                         .header("Authorization", authorizationHeader)
                                         .entity(messages)

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

@@ -4,6 +4,7 @@ package org.whispersystems.textsecuregcm.federation;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.google.common.base.Optional;
 import org.whispersystems.textsecuregcm.storage.Account;
+import org.whispersystems.textsecuregcm.storage.Device;
 
 public class NonLimitedAccount extends Account {
 
@@ -13,20 +14,32 @@ public class NonLimitedAccount extends Account {
   @JsonIgnore
   private final String relay;
 
-  public NonLimitedAccount(String number, String relay) {
-    this.number = number;
-    this.relay  = relay;
+  @JsonIgnore
+  private final long deviceId;
+
+  public NonLimitedAccount(String number, long deviceId, String relay) {
+    this.number   = number;
+    this.deviceId = deviceId;
+    this.relay    = relay;
   }
 
+  @Override
   public String getNumber() {
     return number;
   }
 
+  @Override
   public boolean isRateLimited() {
     return false;
   }
 
+  @Override
   public Optional<String> getRelay() {
     return Optional.of(relay);
   }
+
+  @Override
+  public Optional<Device> getAuthenticatedDevice() {
+    return Optional.of(new Device(deviceId, null, null, null, null, null, false, 0));
+  }
 }

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

@@ -90,6 +90,13 @@ public class AccountsManager {
     else                 return Optional.absent();
   }
 
+  public boolean isRelayListed(String number) {
+    byte[]                  token   = Util.getContactToken(number);
+    Optional<ClientContact> contact = directory.get(token);
+
+    return contact.isPresent() && !Util.isEmpty(contact.get().getRelay());
+  }
+
   private void updateDirectory(Account account) {
     if (account.isActive()) {
       byte[]        token         = Util.getContactToken(account.getNumber());

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

@@ -40,7 +40,6 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.util.LinkedList;
 import java.util.List;
 
 public abstract class Keys {
@@ -67,6 +66,9 @@ public abstract class Keys {
   @Mapper(PreKeyMapper.class)
   abstract List<PreKey> retrieveFirst(@Bind("number") String number);
 
+  @SqlQuery("SELECT COUNT(*) FROM keys WHERE number = :number AND device_id = :device_id")
+  public abstract int getCount(@Bind("number") String number, @Bind("device_id") long deviceId);
+
   @Transaction(TransactionIsolationLevel.SERIALIZABLE)
   public void store(String number, long deviceId, List<PreKey> keys, PreKey lastResortKey) {
     for (PreKey key : keys) {

src/main/java/org/whispersystems/textsecuregcm/workers/DirectoryCommand.java

@@ -26,6 +26,8 @@ import com.yammer.dropwizard.jdbi.args.OptionalArgumentFactory;
 import net.sourceforge.argparse4j.inf.Namespace;
 import net.spy.memcached.MemcachedClient;
 import org.skife.jdbi.v2.DBI;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.WhisperServerConfiguration;
 import org.whispersystems.textsecuregcm.federation.FederatedClientManager;
 import org.whispersystems.textsecuregcm.providers.MemcachedClientFactory;
@@ -38,6 +40,8 @@ import redis.clients.jedis.JedisPool;
 
 public class DirectoryCommand extends ConfiguredCommand<WhisperServerConfiguration> {
 
+  private final Logger logger = LoggerFactory.getLogger(DirectoryCommand.class);
+
   public DirectoryCommand() {
     super("directory", "Update directory from DB and peers.");
   }
@@ -68,6 +72,9 @@ public class DirectoryCommand extends ConfiguredCommand<WhisperServerConfigurati
 
       update.updateFromLocalDatabase();
       update.updateFromPeers();
+    } catch (Exception ex) {
+      logger.warn("Directory Exception", ex);
+      throw new RuntimeException(ex);
     } finally {
       Thread.sleep(3000);
       System.exit(0);

src/main/java/org/whispersystems/textsecuregcm/workers/DirectoryUpdater.java

@@ -27,6 +27,7 @@ import org.whispersystems.textsecuregcm.storage.AccountsManager;
 import org.whispersystems.textsecuregcm.storage.DirectoryManager;
 import org.whispersystems.textsecuregcm.storage.DirectoryManager.BatchOperationHandle;
 import org.whispersystems.textsecuregcm.util.Base64;
+import org.whispersystems.textsecuregcm.util.Hex;
 import org.whispersystems.textsecuregcm.util.Util;
 
 import java.util.Iterator;
@@ -85,7 +86,7 @@ public class DirectoryUpdater {
 
     for (FederatedClient client : clients) {
       logger.info("Updating directory from peer: " + client.getPeerName());
-      BatchOperationHandle handle = directory.startBatchOperation();
+//      BatchOperationHandle handle = directory.startBatchOperation();
 
       try {
         int userCount = client.getUserCount();
@@ -94,31 +95,38 @@ public class DirectoryUpdater {
         logger.info("Remote peer user count: " + userCount);
 
         while (retrieved < userCount) {
+          logger.info("Retrieving remote tokens...");
           List<ClientContact> clientContacts = client.getUserTokens(retrieved);
 
-          if (clientContacts == null)
+          if (clientContacts == null) {
+            logger.info("Remote tokens empty, ending...");
             break;
+          } else {
+            logger.info("Retrieved " + clientContacts.size() + " remote tokens...");
+          }
 
           for (ClientContact clientContact : clientContacts) {
             clientContact.setRelay(client.getPeerName());
 
             Optional<ClientContact> existing = directory.get(clientContact.getToken());
 
-            if (!clientContact.isInactive() && (!existing.isPresent() || existing.get().getRelay().equals(client.getPeerName()))) {
-              directory.add(handle, clientContact);
+            if (!clientContact.isInactive() && (!existing.isPresent() || client.getPeerName().equals(existing.get().getRelay()))) {
+//              directory.add(handle, clientContact);
+              directory.add(clientContact);
             } else {
-              if (existing != null && client.getPeerName().equals(existing.get().getRelay())) {
+              if (existing.isPresent() && client.getPeerName().equals(existing.get().getRelay())) {
                 directory.remove(clientContact.getToken());
               }
             }
           }
 
           retrieved += clientContacts.size();
+          logger.info("Processed: " + retrieved + " remote tokens.");
         }
 
         logger.info("Update from peer complete.");
       } finally {
-        directory.stopBatchOperation(handle);
+//        directory.stopBatchOperation(handle);
       }
     }
 

src/test/java/org/whispersystems/textsecuregcm/tests/controllers/FederatedControllerTest.java

@@ -0,0 +1,89 @@
+package org.whispersystems.textsecuregcm.tests.controllers;
+
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Optional;
+import com.sun.jersey.api.client.ClientResponse;
+import com.yammer.dropwizard.testing.ResourceTest;
+import org.junit.Test;
+import org.whispersystems.textsecuregcm.controllers.FederationController;
+import org.whispersystems.textsecuregcm.controllers.MessageController;
+import org.whispersystems.textsecuregcm.entities.IncomingMessageList;
+import org.whispersystems.textsecuregcm.entities.MessageProtos;
+import org.whispersystems.textsecuregcm.federation.FederatedClientManager;
+import org.whispersystems.textsecuregcm.limits.RateLimiter;
+import org.whispersystems.textsecuregcm.limits.RateLimiters;
+import org.whispersystems.textsecuregcm.push.PushSender;
+import org.whispersystems.textsecuregcm.storage.Account;
+import org.whispersystems.textsecuregcm.storage.AccountsManager;
+import org.whispersystems.textsecuregcm.storage.Device;
+import org.whispersystems.textsecuregcm.tests.util.AuthHelper;
+
+import javax.ws.rs.core.MediaType;
+import java.util.LinkedList;
+import java.util.List;
+
+import static com.yammer.dropwizard.testing.JsonHelpers.jsonFixture;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class FederatedControllerTest extends ResourceTest {
+
+  private static final String SINGLE_DEVICE_RECIPIENT = "+14151111111";
+  private static final String MULTI_DEVICE_RECIPIENT  = "+14152222222";
+
+  private PushSender             pushSender             = mock(PushSender.class            );
+  private FederatedClientManager federatedClientManager = mock(FederatedClientManager.class);
+  private AccountsManager        accountsManager        = mock(AccountsManager.class       );
+  private RateLimiters           rateLimiters           = mock(RateLimiters.class          );
+  private RateLimiter            rateLimiter            = mock(RateLimiter.class           );
+
+  private final ObjectMapper mapper = new ObjectMapper();
+
+  @Override
+  protected void setUpResources() throws Exception {
+    addProvider(AuthHelper.getAuthenticator());
+
+    List<Device> singleDeviceList = new LinkedList<Device>() {{
+      add(new Device(1, "foo", "bar", "baz", "isgcm", null, false, 111));
+    }};
+
+    List<Device> multiDeviceList = new LinkedList<Device>() {{
+      add(new Device(1, "foo", "bar", "baz", "isgcm", null, false, 222));
+      add(new Device(2, "foo", "bar", "baz", "isgcm", null, false, 333));
+    }};
+
+    Account singleDeviceAccount = new Account(SINGLE_DEVICE_RECIPIENT, false, singleDeviceList);
+    Account multiDeviceAccount  = new Account(MULTI_DEVICE_RECIPIENT, false, multiDeviceList);
+
+    when(accountsManager.get(eq(SINGLE_DEVICE_RECIPIENT))).thenReturn(Optional.of(singleDeviceAccount));
+    when(accountsManager.get(eq(MULTI_DEVICE_RECIPIENT))).thenReturn(Optional.of(multiDeviceAccount));
+
+    when(rateLimiters.getMessagesLimiter()).thenReturn(rateLimiter);
+
+    MessageController messageController = new MessageController(rateLimiters, pushSender, accountsManager, federatedClientManager);
+    addResource(new FederationController(accountsManager, null, null, messageController));
+  }
+
+  @Test
+  public void testSingleDeviceCurrent() throws Exception {
+    ClientResponse response =
+        client().resource(String.format("/v1/federation/messages/+14152223333/1/%s", SINGLE_DEVICE_RECIPIENT))
+            .header("Authorization", AuthHelper.getAuthHeader("cyanogen", "foofoo"))
+            .entity(mapper.readValue(jsonFixture("fixtures/current_message_single_device.json"), IncomingMessageList.class))
+            .type(MediaType.APPLICATION_JSON_TYPE)
+            .put(ClientResponse.class);
+
+    assertThat("Good Response", response.getStatus(), is(equalTo(204)));
+
+    verify(pushSender).sendMessage(any(Account.class), any(Device.class), any(MessageProtos.OutgoingMessageSignal.class));
+  }
+
+
+}

src/test/java/org/whispersystems/textsecuregcm/tests/controllers/KeyControllerTest.java

@@ -6,6 +6,7 @@ import com.yammer.dropwizard.testing.ResourceTest;
 import org.junit.Test;
 import org.whispersystems.textsecuregcm.controllers.KeysController;
 import org.whispersystems.textsecuregcm.entities.PreKey;
+import org.whispersystems.textsecuregcm.entities.PreKeyStatus;
 import org.whispersystems.textsecuregcm.entities.UnstructuredPreKeyList;
 import org.whispersystems.textsecuregcm.limits.RateLimiter;
 import org.whispersystems.textsecuregcm.limits.RateLimiters;
@@ -71,11 +72,25 @@ public class KeyControllerTest extends ResourceTest {
     allKeys.add(SAMPLE_KEY);
     allKeys.add(SAMPLE_KEY2);
     allKeys.add(SAMPLE_KEY3);
+
     when(keys.get(EXISTS_NUMBER)).thenReturn(Optional.of(new UnstructuredPreKeyList(allKeys)));
+    when(keys.getCount(eq(AuthHelper.VALID_NUMBER), eq(1L))).thenReturn(5);
 
     addResource(new KeysController(rateLimiters, keys, accounts, null));
   }
 
+  @Test
+  public void validKeyStatusTest() throws Exception {
+    PreKeyStatus result = client().resource("/v1/keys")
+        .header("Authorization",
+                AuthHelper.getAuthHeader(AuthHelper.VALID_NUMBER, AuthHelper.VALID_PASSWORD))
+        .get(PreKeyStatus.class);
+
+    assertThat(result.getCount() == 4);
+
+    verify(keys).getCount(eq(AuthHelper.VALID_NUMBER), eq(1L));
+  }
+
   @Test
   public void validLegacyRequestTest() throws Exception {
     PreKey result = client().resource(String.format("/v1/keys/%s", EXISTS_NUMBER))

src/test/java/org/whispersystems/textsecuregcm/tests/util/AuthHelper.java

@@ -13,6 +13,8 @@ import org.whispersystems.textsecuregcm.storage.AccountsManager;
 import org.whispersystems.textsecuregcm.util.Base64;
 
 import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
 
 import static org.mockito.Matchers.anyLong;
 import static org.mockito.Mockito.mock;
@@ -40,7 +42,14 @@ public class AuthHelper {
     when(account.getRelay()).thenReturn(Optional.<String>absent());
     when(accounts.get(VALID_NUMBER)).thenReturn(Optional.of(account));
 
-    return new MultiBasicAuthProvider<>(new FederatedPeerAuthenticator(new FederationConfiguration()),
+    List<FederatedPeer> peer = new LinkedList<FederatedPeer>() {{
+      add(new FederatedPeer("cyanogen", "https://foo", "foofoo", "bazzzzz"));
+    }};
+
+    FederationConfiguration federationConfiguration = mock(FederationConfiguration.class);
+    when(federationConfiguration.getPeers()).thenReturn(peer);
+
+    return new MultiBasicAuthProvider<>(new FederatedPeerAuthenticator(federationConfiguration),
                                         FederatedPeer.class,
                                         new AccountAuthenticator(accounts),
                                         Account.class, "WhisperServer");