/**
   * Fast check to see if a shard has messages to process
   *
   * @param shardName
   * @throws MessageQueueException
   */
  private boolean hasMessages(String shardName) throws MessageQueueException {
    UUID currentTime = TimeUUIDUtils.getUniqueTimeUUIDinMicros();

    try {
      ColumnList<MessageQueueEntry> result =
          keyspace
              .prepareQuery(queueColumnFamily)
              .setConsistencyLevel(consistencyLevel)
              .getKey(shardName)
              .withColumnRange(
                  new RangeBuilder()
                      .setLimit(1) // Read extra messages because of the lock column
                      .setStart(
                          entrySerializer
                              .makeEndpoint(
                                  (byte) MessageQueueEntryType.Message.ordinal(), Equality.EQUAL)
                              .toBytes())
                      .setEnd(
                          entrySerializer
                              .makeEndpoint(
                                  (byte) MessageQueueEntryType.Message.ordinal(), Equality.EQUAL)
                              .append((byte) 0, Equality.EQUAL)
                              .append(currentTime, Equality.LESS_THAN_EQUALS)
                              .toBytes())
                      .build())
              .execute()
              .getResult();
      return !result.isEmpty();
    } catch (ConnectionException e) {
      throw new MessageQueueException("Error checking shard for messages. " + shardName, e);
    }
  }
 private SampleEntity createSampleEntity(String id) {
   Random prng = new Random();
   SampleEntity entity = new SampleEntity();
   entity.setId(id);
   entity.setBooleanPrimitive(prng.nextBoolean());
   entity.setBooleanObject(prng.nextBoolean());
   entity.setBytePrimitive((byte) prng.nextInt(Byte.MAX_VALUE));
   entity.setByteObject((byte) prng.nextInt(Byte.MAX_VALUE));
   entity.setShortPrimitive((short) prng.nextInt(Short.MAX_VALUE));
   entity.setShortObject((short) prng.nextInt(Short.MAX_VALUE));
   entity.setIntPrimitive(prng.nextInt());
   entity.setIntObject(prng.nextInt());
   entity.setLongPrimitive(prng.nextLong());
   entity.setLongObject(prng.nextLong());
   entity.setFloatPrimitive(prng.nextFloat());
   entity.setFloatObject(prng.nextFloat());
   entity.setDoublePrimitive(prng.nextDouble());
   entity.setDoubleObject(prng.nextDouble());
   entity.setString(RandomStringUtils.randomAlphanumeric(16));
   entity.setByteArray(RandomStringUtils.randomAlphanumeric(16).getBytes(Charsets.UTF_8));
   entity.setDate(new Date());
   entity.setUuid(TimeUUIDUtils.getUniqueTimeUUIDinMicros());
   Foo foo = new Foo(prng.nextInt(), RandomStringUtils.randomAlphanumeric(4));
   entity.setFoo(foo);
   BarBar barbar = new BarBar();
   barbar.i = prng.nextInt();
   barbar.s = RandomStringUtils.randomAlphanumeric(4);
   Bar bar = new Bar();
   bar.i = prng.nextInt();
   bar.s = RandomStringUtils.randomAlphanumeric(4);
   bar.barbar = barbar;
   entity.setBar(bar);
   return entity;
 }
 List<MessageContext> readMessagesFromShardUsingLockManager(String shardName, int itemToPop)
     throws MessageQueueException, BusyLockException {
   ShardLock lock = null;
   try {
     lock = queue.lockManager.acquireLock(shardName);
     MutationBatch m =
         queue.keyspace.prepareMutationBatch().setConsistencyLevel(queue.consistencyLevel);
     ColumnListMutation<MessageQueueEntry> rowMutation =
         m.withRow(queue.queueColumnFamily, shardName);
     long curTimeMicros =
         TimeUUIDUtils.getMicrosTimeFromUUID(TimeUUIDUtils.getUniqueTimeUUIDinMicros());
     return readMessagesInternal(shardName, itemToPop, 0, null, rowMutation, m, curTimeMicros);
   } catch (BusyLockException e) {
     queue.stats.incLockContentionCount();
     throw e;
   } catch (Exception e) {
     LOG.error("Error reading shard " + shardName, e);
     throw new MessageQueueException("Error", e);
   } finally {
     queue.lockManager.releaseLock(lock);
   }
 }
Exemple #4
0
  @Test
  public void testMultiRowUniqueness() {
    DedicatedMultiRowUniquenessConstraint<UUID> constraint =
        new DedicatedMultiRowUniquenessConstraint<UUID>(
                keyspace, TimeUUIDUtils.getUniqueTimeUUIDinMicros())
            .withConsistencyLevel(ConsistencyLevel.CL_ONE)
            .withRow(CF_USER_UNIQUE_UUID, "user1")
            .withRow(CF_EMAIL_UNIQUE_UUID, "*****@*****.**");

    DedicatedMultiRowUniquenessConstraint<UUID> constraint2 =
        new DedicatedMultiRowUniquenessConstraint<UUID>(
                keyspace, TimeUUIDUtils.getUniqueTimeUUIDinMicros())
            .withConsistencyLevel(ConsistencyLevel.CL_ONE)
            .withRow(CF_USER_UNIQUE_UUID, "user1")
            .withRow(CF_EMAIL_UNIQUE_UUID, "*****@*****.**");

    try {
      Column<UUID> c = constraint.getUniqueColumn();
      Assert.fail();
    } catch (Exception e) {
      LOG.info(e.getMessage());
    }

    try {
      constraint.acquire();

      Column<UUID> c = constraint.getUniqueColumn();
      LOG.info("Unique column is " + c.getName());

      try {
        constraint2.acquire();
        Assert.fail("Should already be acquired");
      } catch (NotUniqueException e) {

      } catch (Exception e) {
        e.printStackTrace();
        Assert.fail();
      } finally {
        try {
          constraint2.release();
        } catch (Exception e) {
          e.printStackTrace();
          Assert.fail();
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
      Assert.fail();
    } finally {
      try {
        constraint.release();
      } catch (Exception e) {
        e.printStackTrace();
        Assert.fail();
      }
    }

    try {
      constraint2.acquire();
      Column<UUID> c = constraint.getUniqueColumn();
      LOG.info("Unique column is " + c.getName());
    } catch (NotUniqueException e) {
      Assert.fail("Should already be unique");
    } catch (Exception e) {
      e.printStackTrace();
      Assert.fail();
    } finally {
      try {
        constraint2.release();
      } catch (Exception e) {
        e.printStackTrace();
        Assert.fail();
      }
    }
  }