Esempio n. 1
0
  @Override
  public RayoNode getNode(String rayoNode) {

    log.debug("Getting node with id: [%s]", rayoNode);
    RayoNode node = null;
    try {
      Selector selector = Pelops.createSelector(schemaName);
      Map<String, List<SuperColumn>> rows =
          selector.getSuperColumnsFromRowsUtf8Keys(
              "nodes",
              Selector.newKeyRange("", "", 100), // 100 platforms limit should be enough :)
              Selector.newColumnsPredicate(rayoNode),
              ConsistencyLevel.ONE);

      Iterator<Entry<String, List<SuperColumn>>> it = rows.entrySet().iterator();
      while (it.hasNext()) {
        Entry<String, List<SuperColumn>> element = it.next();
        String currPlatform = element.getKey();
        List<SuperColumn> platformOccurrences = element.getValue();
        for (SuperColumn column : platformOccurrences) {
          if (node == null) {
            node = new RayoNode();
            node = buildNode(column.getColumns());
            node.setHostname(rayoNode);
          }
          node.addPlatform(currPlatform);
        }
      }
    } catch (PelopsException pe) {
      log.error(pe.getMessage(), pe);
      return null;
    }
    return node;
  }
Esempio n. 2
0
  @SuppressWarnings("unchecked")
  public List<RayoNode> getRayoNodesForPlatform(String platformId) {

    try {
      log.debug("Finding rayo nodes for platform: [%s]", platformId);
      Set<String> platforms = new HashSet<String>();
      platforms.add(platformId);

      List<RayoNode> nodes = new ArrayList<RayoNode>();
      Selector selector = Pelops.createSelector(schemaName);
      List<SuperColumn> columns =
          selector.getSuperColumnsFromRow("nodes", platformId, false, ConsistencyLevel.ONE);
      for (SuperColumn column : columns) {
        String id = Bytes.toUTF8(column.getName());
        RayoNode rayoNode = buildNode(column.getColumns());
        rayoNode.setHostname(id);
        rayoNode.setPlatforms(platforms);
        nodes.add(rayoNode);
      }

      return nodes;
    } catch (PelopsException pe) {
      log.error(pe.getMessage(), pe);
      return Collections.EMPTY_LIST;
    }
  }
Esempio n. 3
0
  public int compareTo(SuperColumn other) {
    if (!getClass().equals(other.getClass())) {
      return getClass().getName().compareTo(other.getClass().getName());
    }

    int lastComparison = 0;
    SuperColumn typedOther = (SuperColumn) other;

    lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetName()) {
      lastComparison = TBaseHelper.compareTo(this.name, typedOther.name);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetColumns()) {
      lastComparison = TBaseHelper.compareTo(this.columns, typedOther.columns);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    return 0;
  }
Esempio n. 4
0
  /** Test insertion of a supercolumn using insert */
  @Test
  public void testInsertSuper()
      throws IllegalArgumentException, NoSuchElementException, IllegalStateException,
          HNotFoundException, Exception {

    // insert value
    ColumnParent columnParent = new ColumnParent("Super1");
    columnParent.setSuper_column(StringSerializer.get().toByteBuffer("testInsertSuper_super"));
    Column column =
        new Column(
            StringSerializer.get().toByteBuffer("testInsertSuper_column"),
            StringSerializer.get().toByteBuffer("testInsertSuper_value"),
            connectionManager.createClock());

    keyspace.insert(
        StringSerializer.get().toByteBuffer("testInsertSuper_key"), columnParent, column);
    column.setName(StringSerializer.get().toByteBuffer("testInsertSuper_column2"));
    keyspace.insert(
        StringSerializer.get().toByteBuffer("testInsertSuper_key"), columnParent, column);

    // get value and assert
    ColumnPath cp2 = new ColumnPath("Super1");
    cp2.setSuper_column(bytes("testInsertSuper_super"));
    SuperColumn sc = keyspace.getSuperColumn("testInsertSuper_key", cp2);
    assertNotNull(sc);
    assertEquals("testInsertSuper_super", string(sc.getName()));
    assertEquals(2, sc.getColumns().size());
    assertEquals("testInsertSuper_value", string(sc.getColumns().get(0).getValue()));

    // remove value
    keyspace.remove("testInsertSuper_super", cp2);
  }
 public List<NotificationEntry> getNotifications(String username, String startId) {
   try {
     byte[] timeUUIDAsBytes = EMPTY_BYTE_ARRAY;
     if (startId != null && startId.length() > 0) {
       UUID uuid = UUIDUtil.fromString(startId);
       final byte[] idAsBytes = UUIDUtil.toBytes(uuid);
       timeUUIDAsBytes = getTimeUUIDFromID(username, idAsBytes);
       if (timeUUIDAsBytes == null) {
         timeUUIDAsBytes = EMPTY_BYTE_ARRAY;
       }
     }
     Selector selector = Pelops.createSelector(TRENDOCEAN_POOL, TRENDOCEAN_KEYSPACE);
     SlicePredicate columnPredicate =
         Selector.newColumnsPredicate(timeUUIDAsBytes, EMPTY_BYTE_ARRAY, true, PAGE_SIZE);
     List<SuperColumn> columns =
         selector.getSuperColumnsFromRow(username, WALL_CF, columnPredicate, ConsistencyLevel.ONE);
     List<NotificationEntry> notificationList = new ArrayList<NotificationEntry>(columns.size());
     for (SuperColumn superColumn : columns) {
       List<Column> wallEntryColumns = superColumn.getColumns();
       String notificationId = null;
       NotificationType notificationType = null;
       String questionId = null;
       String relatedUser = null;
       long answerCount = -1L;
       long time = 0;
       for (Column notificationColumn : wallEntryColumns) {
         String notificationColumnName = toString(notificationColumn.getName());
         if (notificationColumnName.equals("_id")) {
           notificationId = UUIDUtil.toUUID(notificationColumn.getValue()).toString();
           long timeInMicroSeconds = notificationColumn.getTimestamp();
           time = timeInMicroSeconds / 1000L;
         } else if (notificationColumnName.equals("_type")) {
           notificationType = NotificationType.fromId(toByte(notificationColumn));
         } else if (notificationColumnName.equals("questionId")) {
           questionId = toString(notificationColumn);
         } else if (notificationColumnName.equals("relatedUser")) {
           relatedUser = toString(notificationColumn);
         } else if (notificationColumnName.equals("answerCount")) {
           answerCount = toLong(notificationColumn);
         } else {
           logger.warn("Invalid notification column:{}", notificationColumnName);
         }
       }
       NotificationEntry notificationEntry = new NotificationEntry();
       notificationEntry.setId(notificationId);
       notificationEntry.setTime(time);
       notificationEntry.setNotificationType(notificationType);
       notificationEntry.setQuestionId(questionId);
       notificationList.add(notificationEntry);
       notificationEntry.setUsername(relatedUser);
       notificationEntry.setAnswerCount(answerCount);
     }
     return notificationList;
   } catch (NotFoundException ex) {
     return Collections.EMPTY_LIST;
   } catch (Exception ex) {
     logger.error("Can not get time uuid", ex);
     throw new TrendOceanException(ex);
   }
 }
Esempio n. 6
0
 /** Performs a deep copy on <i>other</i>. */
 public SuperColumn(SuperColumn other) {
   if (other.isSetName()) {
     this.name = TBaseHelper.copyBinary(other.name);
     ;
   }
   if (other.isSetColumns()) {
     List<Column> __this__columns = new ArrayList<Column>();
     for (Column other_element : other.columns) {
       __this__columns.add(new Column(other_element));
     }
     this.columns = __this__columns;
   }
 }
 /**
  * Purge expired entries. Expiration entries are stored in a single key (expirationKey) within a
  * specific ColumnFamily (set by configuration). The entries are grouped by expiration timestamp
  * in SuperColumns within which each entry's key is mapped to a column
  */
 @Override
 protected void purgeInternal() throws CacheLoaderException {
   if (trace) log.trace("purgeInternal");
   Cassandra.Client cassandraClient = null;
   try {
     cassandraClient = dataSource.getConnection();
     // We need to get all supercolumns from the beginning of time until
     // now, in SLICE_SIZE chunks
     SlicePredicate predicate = new SlicePredicate();
     predicate.setSlice_range(
         new SliceRange(
             ByteBufferUtil.EMPTY_BYTE_BUFFER,
             ByteBufferUtil.bytes(System.currentTimeMillis()),
             false,
             SLICE_SIZE));
     Map<ByteBuffer, Map<String, List<Mutation>>> mutationMap =
         new HashMap<ByteBuffer, Map<String, List<Mutation>>>();
     for (boolean complete = false; !complete; ) {
       // Get all columns
       List<ColumnOrSuperColumn> slice =
           cassandraClient.get_slice(
               expirationKey, expirationColumnParent, predicate, readConsistencyLevel);
       complete = slice.size() < SLICE_SIZE;
       // Delete all keys returned by the slice
       for (ColumnOrSuperColumn crumb : slice) {
         SuperColumn scol = crumb.getSuper_column();
         for (Iterator<Column> i = scol.getColumnsIterator(); i.hasNext(); ) {
           Column col = i.next();
           // Remove the entry row
           remove0(ByteBuffer.wrap(col.getName()), mutationMap);
         }
         // Remove the expiration supercolumn
         addMutation(
             mutationMap,
             expirationKey,
             config.expirationColumnFamily,
             ByteBuffer.wrap(scol.getName()),
             null,
             null);
       }
     }
     cassandraClient.batch_mutate(mutationMap, writeConsistencyLevel);
   } catch (Exception e) {
     throw new CacheLoaderException(e);
   } finally {
     dataSource.releaseConnection(cassandraClient);
   }
 }
Esempio n. 8
0
  public boolean equals(SuperColumn that) {
    if (that == null) return false;

    boolean this_present_name = true && this.isSetName();
    boolean that_present_name = true && that.isSetName();
    if (this_present_name || that_present_name) {
      if (!(this_present_name && that_present_name)) return false;
      if (!this.name.equals(that.name)) return false;
    }

    boolean this_present_columns = true && this.isSetColumns();
    boolean that_present_columns = true && that.isSetColumns();
    if (this_present_columns || that_present_columns) {
      if (!(this_present_columns && that_present_columns)) return false;
      if (!this.columns.equals(that.columns)) return false;
    }

    return true;
  }
Esempio n. 9
0
  private void doSlice(String keyspace, String key, String columnFamily, byte[] superColumnName)
      throws InvalidRequestException, UnavailableException, TimedOutException, TException,
          UnsupportedEncodingException, IllegalAccessException, NotFoundException,
          InstantiationException, ClassNotFoundException {
    SliceRange range =
        new SliceRange(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.EMPTY_BYTE_ARRAY, true, 1000000);
    List<ColumnOrSuperColumn> columns =
        thriftClient_.get_slice(
            keyspace,
            key,
            createColumnParent(columnFamily, superColumnName),
            createSlicePredicate(null, range),
            ConsistencyLevel.ONE);
    int size = columns.size();

    // Print out super columns or columns.
    for (ColumnOrSuperColumn cosc : columns) {
      if (cosc.isSetSuper_column()) {
        SuperColumn superColumn = cosc.super_column;

        css_.out.printf(
            "=> (super_column=%s,", formatSuperColumnName(keyspace, columnFamily, superColumn));
        for (Column col : superColumn.getColumns())
          css_.out.printf(
              "\n     (column=%s, value=%s, timestamp=%d)",
              formatSubcolumnName(keyspace, columnFamily, col),
              new String(col.value, "UTF-8"),
              col.timestamp);

        css_.out.println(")");
      } else {
        Column column = cosc.column;
        css_.out.printf(
            "=> (column=%s, value=%s, timestamp=%d)\n",
            formatColumnName(keyspace, columnFamily, column),
            new String(column.value, "UTF-8"),
            column.timestamp);
      }
    }

    css_.out.println("Returned " + size + " results.");
  }
Esempio n. 10
0
  @Override
  public Collection<String> getCalls() {

    log.debug("Getting list with all active calls");

    try {
      Selector selector = Pelops.createSelector(schemaName);
      List<String> calls = new ArrayList<String>();
      List<SuperColumn> cols =
          selector.getSuperColumnsFromRow("jids", "nodes", false, ConsistencyLevel.ONE);
      for (SuperColumn col : cols) {
        List<Column> columns = col.getColumns();
        for (Column column : columns) {
          calls.add(Bytes.toUTF8(column.getValue()));
        }
      }
      return calls;
    } catch (PelopsException pe) {
      log.error(pe.getMessage(), pe);
      return null;
    }
  }
 @Override
 public ByteBuffer getRawName() {
   return ByteBuffer.wrap(column.getName());
 }