Java Attribute类代码示例

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
@Override
public ImmutablePair<LifecycleState, Optional<String>> getLifecycleState() throws Exception {

  if (!initialised) {
    throw new IllegalStateException("The lifecycle manager has not been initialised");
  }

  ImmutablePair<Optional<Integer>, Set<Attribute>> lifecycleStateItem = getOptimisticPersister()
      .get(lifecycleItemName);
  Optional<Attribute> stateAttribute = lifecycleStateItem.right.stream()
      .filter(attribute -> attribute.getName().equals("State")).findFirst();
  Optional<Attribute> urlAttribute = lifecycleStateItem.right.stream()
      .filter(attribute -> attribute.getName().equals("Url")).findFirst();
  // If we've not set the lifecycle state yet, then we must be ACTIVE.
  LifecycleState state = stateAttribute.isPresent() ? Enum.valueOf(LifecycleState.class,
      stateAttribute.get().getValue()) : LifecycleState.ACTIVE;
  // Populate url only if in RETIRED state.
  Optional<String> url = (urlAttribute.isPresent() && state.equals(LifecycleState.RETIRED)) ? Optional
      .of(urlAttribute.get().getValue()) : Optional.empty();
  return new ImmutablePair<LifecycleState, Optional<String>>(state, url);
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
private ImmutablePair<Optional<Integer>, List<Booking>> getVersionedBookings(String date)
    throws Exception {
  logger.log("About to get all versioned bookings from database for: " + date);

  // Get existing bookings (and version number), via consistent read:
  ImmutablePair<Optional<Integer>, Set<Attribute>> versionedAttributes = getOptimisticPersister()
      .get(date);

  // Convert attributes to Bookings:
  List<Booking> existingBookings = new ArrayList<>();
  versionedAttributes.right.stream().forEach(attribute -> {
    existingBookings.add(getBookingFromAttribute(attribute, date));
  });

  return new ImmutablePair<>(versionedAttributes.left, existingBookings);
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
@Override
public List<Booking> deleteBooking(Booking bookingToDelete, boolean isSquashServiceUserCall)
    throws Exception {

  if (!initialised) {
    throw new IllegalStateException("The booking manager has not been initialised");
  }

  getLifecycleManager().throwIfOperationInvalidForCurrentLifecycleState(false,
      isSquashServiceUserCall);

  logger.log("About to delete booking from database: " + bookingToDelete.toString());
  Attribute attribute = new Attribute();
  attribute.setName(getAttributeNameFromBooking(bookingToDelete));
  attribute.setValue(bookingToDelete.getName());
  getOptimisticPersister().delete(bookingToDelete.getDate(), attribute);

  logger.log("Deleted booking from database");

  return getVersionedBookings(bookingToDelete.getDate()).right;
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
@Override
public void deleteRule(BookingRule bookingRuleToDelete, boolean isSquashServiceUserCall)
    throws Exception {

  if (!initialised) {
    throw new IllegalStateException("The rule manager has not been initialised");
  }

  lifecycleManager
      .throwIfOperationInvalidForCurrentLifecycleState(false, isSquashServiceUserCall);

  logger.log("About to delete booking rule from simpledb: " + bookingRuleToDelete.toString());

  String attributeName = getAttributeNameFromBookingRule(bookingRuleToDelete);
  String attributeValue = StringUtils.join(bookingRuleToDelete.getDatesToExclude(), ",");
  logger.log("Booking rule attribute name is: " + attributeName);
  logger.log("Booking rule attribute value is: " + attributeValue);
  Attribute attribute = new Attribute();
  attribute.setName(attributeName);
  attribute.setValue(attributeValue);
  optimisticPersister.delete(ruleItemName, attribute);

  logger.log("Deleted booking rule.");
  return;
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
private ImmutablePair<Optional<Integer>, Set<BookingRule>> getVersionedBookingRules()
    throws Exception {
  logger.log("About to get all versioned booking rules from simpledb");

  // Get existing booking rules (and version number), via consistent read:
  ImmutablePair<Optional<Integer>, Set<Attribute>> versionedAttributes = optimisticPersister
      .get(ruleItemName);

  // Convert attributes to BookingRules:
  Set<BookingRule> existingBookingRules = new HashSet<>();
  versionedAttributes.right.stream().forEach(attribute -> {
    existingBookingRules.add(getBookingRuleFromAttribute(attribute));
  });

  return new ImmutablePair<>(versionedAttributes.left, existingBookingRules);
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
private void expectOptimisticPersisterToReturnVersionedAttributes(int expectedVersion,
    List<BookingRule> bookingRules, int numCalls) throws Exception {

  // Set up attributes to be returned from the database's booking rule item
  Set<Attribute> attributes = new HashSet<>();
  for (BookingRule bookingRule : bookingRules) {
    Attribute attribute = new Attribute();
    attribute.setName(getAttributeNameFromBookingRule(bookingRule));
    String[] datesToExclude = bookingRule.getDatesToExclude();
    attribute.setValue(StringUtils.join(datesToExclude, ","));
    attributes.add(attribute);
  }
  mockery.checking(new Expectations() {
    {
      exactly(numCalls).of(mockOptimisticPersister).get(with(equal(ruleItemName)));
      will(returnValue(new ImmutablePair<>(Optional.of(expectedVersion), attributes)));
    }
  });
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
private void expectToDeleteRulesViaOptimisticPersister(List<BookingRule> rulesToDelete)
    throws Exception {

  // Set up attributes to be deleted from the database's booking rule item
  for (BookingRule ruleToDelete : rulesToDelete) {
    Attribute attribute = new Attribute();
    attribute.setName(getAttributeNameFromBookingRule(ruleToDelete));
    String[] datesToExclude = ruleToDelete.getDatesToExclude();
    attribute.setValue(StringUtils.join(datesToExclude, ","));

    mockery.checking(new Expectations() {
      {
        oneOf(mockOptimisticPersister).delete(with(equal(ruleItemName)), with(equal(attribute)));
      }
    });
  }
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
@Test
public void testGetLifecycleStateCorrectlyCallsTheOptimisticPersister() throws Exception {
  // We should always get the lifecycle state item from the persister.

  // ARRANGE
  lifecycleManager.initialise(mockLogger);

  // Set up a test lifecycle-state item - with an arbitrary version number.
  ImmutablePair<Optional<Integer>, Set<Attribute>> testItem = new ImmutablePair<Optional<Integer>, Set<Attribute>>(
      Optional.of(42), new HashSet<Attribute>());

  mockery.checking(new Expectations() {
    {
      exactly(1).of(mockOptimisticPersister).get(with(equal("LifecycleState")));
      will(returnValue(testItem));
    }
  });

  // ACT
  // FIXME verify it returns value got from the persister
  lifecycleManager.getLifecycleState();
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void execute() {
    List<String> attributeNames = new ArrayList<String>();
    attributeNames.add("ATTRIBUTE1");
    exchange.getIn().setHeader(SdbConstants.ATTRIBUTE_NAMES, attributeNames);
    exchange.getIn().setHeader(SdbConstants.ITEM_NAME, "ITEM1");
    
    command.execute();
    
    assertEquals("DOMAIN1", sdbClient.getAttributesRequest.getDomainName());
    assertEquals("ITEM1", sdbClient.getAttributesRequest.getItemName());
    assertEquals(Boolean.TRUE, sdbClient.getAttributesRequest.getConsistentRead());
    assertEquals(attributeNames, sdbClient.getAttributesRequest.getAttributeNames());
    
    List<Attribute> attributes = exchange.getIn().getHeader(SdbConstants.ATTRIBUTES, List.class);
    assertEquals(2, attributes.size());
    assertEquals("AttributeOne", attributes.get(0).getName());
    assertEquals("Value One", attributes.get(0).getValue());
    assertEquals("AttributeTwo", attributes.get(1).getName());
    assertEquals("Value Two", attributes.get(1).getValue());
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
@Test
public void execute() {
    List<Attribute> attributes = new ArrayList<Attribute>();
    attributes.add(new Attribute("NAME1", "VALUE1"));
    exchange.getIn().setHeader(SdbConstants.ATTRIBUTES, attributes);
    exchange.getIn().setHeader(SdbConstants.ITEM_NAME, "ITEM1");
    UpdateCondition condition = new UpdateCondition("Key1", "Value1", true);
    exchange.getIn().setHeader(SdbConstants.UPDATE_CONDITION, condition);
    
    command.execute();
    
    assertEquals("DOMAIN1", sdbClient.deleteAttributesRequest.getDomainName());
    assertEquals("ITEM1", sdbClient.deleteAttributesRequest.getItemName());
    assertEquals(condition, sdbClient.deleteAttributesRequest.getExpected());
    assertEquals(attributes, sdbClient.deleteAttributesRequest.getAttributes());
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
@Test
public void deleteAttributes() {
    final List<Attribute> attributes = Arrays.asList(new Attribute[] {
        new Attribute("NAME1", "VALUE1")});
    final UpdateCondition condition = new UpdateCondition("Key1", "Value1", true);
    
    template.send("direct:start", new Processor() {
        public void process(Exchange exchange) throws Exception {
            exchange.getIn().setHeader(SdbConstants.OPERATION, SdbOperations.DeleteAttributes);
            exchange.getIn().setHeader(SdbConstants.ATTRIBUTES, attributes);
            exchange.getIn().setHeader(SdbConstants.ITEM_NAME, "ITEM1");
            exchange.getIn().setHeader(SdbConstants.UPDATE_CONDITION, condition);
        }
    });
    
    assertEquals("TestDomain", amazonSDBClient.deleteAttributesRequest.getDomainName());
    assertEquals("ITEM1", amazonSDBClient.deleteAttributesRequest.getItemName());
    assertEquals(condition, amazonSDBClient.deleteAttributesRequest.getExpected());
    assertEquals(attributes, amazonSDBClient.deleteAttributesRequest.getAttributes());
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
@VisibleForTesting static CassandraInstance transform(Item item) {
  CassandraInstance.Builder instanceBuilder = new CassandraInstance.Builder();
  for (Attribute attr : item.getAttributes()) {
    if (attr.getName().equals(ID_KEY)) {
      instanceBuilder.id(Integer.parseInt(attr.getValue()));
    } else if (attr.getName().equals(DATACENTER_KEY)) {
      instanceBuilder.dataCenter(attr.getValue());
    } else if (attr.getName().equals(RACK_KEY)) {
      instanceBuilder.rack(attr.getValue());
    } else if (attr.getName().equals(HOSTNAME_KEY)) {
      instanceBuilder.hostName(attr.getValue());
    } else if (attr.getName().equals(PUBLIC_IP_ADDRESS_KEY)) {
      instanceBuilder.publicIpAddress(attr.getValue());
    } else if (attr.getName().equals(FULLY_QUALIFIED_DOMAIN_NAME_KEY)) {
      instanceBuilder.fullyQualifiedDomainName(attr.getValue());
    }
  }
  return instanceBuilder.build();
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
private static void assertAttributes(DeleteAttributesRequest request) {
  assertEquals(6, request.getAttributes().size());
  for (Attribute attr : request.getAttributes()) {
    if (attr.getName().equals(SdbCassandraInstanceDao.ID_KEY)) {
      assertEquals(String.valueOf(ID), attr.getValue());
    } else if (attr.getName().equals(SdbCassandraInstanceDao.DATACENTER_KEY)) {
      assertEquals(DATACENTER, attr.getValue());
    } else if (attr.getName().equals(SdbCassandraInstanceDao.RACK_KEY)) {
      assertEquals(RACK, attr.getValue());
    } else if (attr.getName().equals(SdbCassandraInstanceDao.HOSTNAME_KEY)) {
      assertEquals(HOSTNAME, attr.getValue());
    } else if (attr.getName().endsWith(SdbCassandraInstanceDao.PUBLIC_IP_ADDRESS_KEY)) {
      assertEquals(PUBLIC_IP_ADDRESS, attr.getValue());
    } else if (attr.getName().endsWith(SdbCassandraInstanceDao.FULLY_QUALIFIED_DOMAIN_NAME_KEY)) {
      assertEquals(FULLY_QUALIFIED_DOMAIN_NAME, attr.getValue());
    } else {
      assertDuplicateAttribute(attr.getName(), attr.getValue());
    }
  }
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
@SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
public Set<Entry<String, String>> entrySet() {
    final GetAttributesResult result = this.credentials.aws().getAttributes(
        new GetAttributesRequest()
            .withConsistentRead(true)
            .withDomainName(this.table)
            .withItemName(this.label)
    );
    final Set<Entry<String, String>> entries =
        new HashSet<Entry<String, String>>(0);
    for (final Attribute attr : result.getAttributes()) {
        entries.add(
            new AbstractMap.SimpleImmutableEntry<String, String>(
                attr.getName(), attr.getValue()
            )
        );
    }
    return entries;
}
 

import com.amazonaws.services.simpledb.model.Attribute; //导入依赖的package包/类
private <T> long invokeCountImpl(boolean consistentRead,
		SimpleDbEntityInformation<T, ?> entityInformation,
		final String countQuery) {
	
	LOGGER.debug("Count items for query " + countQuery);
       validateSelectQuery(countQuery);

       final String escapedQuery = getEscapedQuery(countQuery, entityInformation);

       final SelectResult selectResult = invokeFindImpl(consistentRead, escapedQuery);
       for (Item item : selectResult.getItems()) {
           if (item.getName().equals("Domain")) {
               for (Attribute attribute : item.getAttributes()) {
                   if (attribute.getName().equals("Count")) {
                       return Long.parseLong(attribute.getValue());
                   }
               }
           }
       }

       return 0;
}