List of usage examples for com.amazonaws.services.simpledb.model ReplaceableAttribute getValue
public String getValue()
From source file:org.grails.datastore.mapping.simpledb.engine.SimpleDBEntityPersister.java
License:Apache License
@Override protected Object storeEntry(final PersistentEntity persistentEntity, final EntityAccess entityAccess, final Object storeId, final SimpleDBNativeItem entry) { String id = storeId.toString(); String domain = domainResolver.resolveDomain(id); //for non-null values we should call putAttributes, for nulls we should just do nothing during creation List<ReplaceableAttribute> allAttributes = entry.createReplaceableItem().getAttributes(); List<ReplaceableAttribute> puts = new LinkedList<ReplaceableAttribute>(); for (ReplaceableAttribute attribute : allAttributes) { if (attribute.getValue() != null) { puts.add(attribute);// w w w . j av a 2 s . c om } } simpleDBTemplate.putAttributes(domain, id, puts); return storeId; //todo should we return string id here? }
From source file:org.grails.datastore.mapping.simpledb.engine.SimpleDBEntityPersister.java
License:Apache License
@Override public void updateEntry(final PersistentEntity persistentEntity, final EntityAccess ea, final Object key, final SimpleDBNativeItem entry) { String id = key.toString();/*from w ww . j a va 2 s .c om*/ String domain = domainResolver.resolveDomain(id); //for non-null values we should call putAttributes, for nulls we should call delete attributes List<ReplaceableAttribute> allAttributes = entry.createReplaceableItem().getAttributes(); List<ReplaceableAttribute> puts = new LinkedList<ReplaceableAttribute>(); List<Attribute> deletes = new LinkedList<Attribute>(); //we have to put *new* (incremented) version as part of the 'version' value and use the old version value in the conditional update. //if the update fails we have to restore the version to the old value Object currentVersion = null; String stringCurrentVersion = null; if (isVersioned(ea)) { currentVersion = ea.getProperty("version"); stringCurrentVersion = convertVersionToString(currentVersion); incrementVersion(ea); //increment version now before we save it } for (ReplaceableAttribute attribute : allAttributes) { if ("version".equals(attribute.getName())) { //ignore it, it will be explicitly added later right before the insert by taking incrementing and taking new one } else { if (attribute.getValue() != null) { puts.add(attribute); } else { deletes.add(new Attribute(attribute.getName(), null)); } } } if (isVersioned(ea)) { puts.add(createAttributeForVersion(ea)); //update the version try { simpleDBTemplate.deleteAttributesVersioned(domain, id, deletes, stringCurrentVersion, persistentEntity); simpleDBTemplate.putAttributesVersioned(domain, id, puts, stringCurrentVersion, persistentEntity); } catch (DataAccessException e) { //we need to restore version to what it was before the attempt to update ea.setProperty("version", currentVersion); throw e; } } else { simpleDBTemplate.deleteAttributes(domain, id, deletes); simpleDBTemplate.putAttributes(domain, id, puts); } }
From source file:squash.booking.lambdas.core.OptimisticPersister.java
License:Apache License
@Override public int put(String itemName, Optional<Integer> version, ReplaceableAttribute attribute) throws Exception { if (!initialised) { throw new IllegalStateException("The optimistic persister has not been initialised"); }/* w w w . j a va 2s .c o m*/ logger.log("About to add attrbutes to simpledb item: " + itemName); AmazonSimpleDB client = getSimpleDBClient(); // Check the put will not take us over the maximum number of attributes: // N.B. if (replace == true) then this check could be over-eager, but not // worth refining it, since this effectively just alters the limit by one. ImmutablePair<Optional<Integer>, Set<Attribute>> versionedAttributes = get(itemName); if (versionedAttributes.left.isPresent()) { logger.log("Retrieved versioned attributes(Count: " + versionedAttributes.right.size() + ") have version number: " + versionedAttributes.left.get()); } else { // There should be no attributes in this case. logger.log("Retrieved versioned attributes(Count: " + versionedAttributes.right.size() + ") have no version number"); } Boolean tooManyAttributes = versionedAttributes.right.size() >= maxNumberOfAttributes; if (tooManyAttributes && !attribute.getValue().startsWith("Inactive")) { // We allow puts to inactivate attributes even when on the limit - // otherwise we could never delete when we're on the limit. logger.log("Cannot create attribute - the maximum number of attributes already exists (" + maxNumberOfAttributes + ") so throwing a 'Database put failed - too many attributes' exception"); throw new Exception("Database put failed - too many attributes"); } // Do a conditional put - so we don't overwrite someone else's attributes UpdateCondition updateCondition = new UpdateCondition(); updateCondition.setName(versionAttributeName); ReplaceableAttribute versionAttribute = new ReplaceableAttribute(); versionAttribute.setName(versionAttributeName); versionAttribute.setReplace(true); // Update will proceed unless the version number has changed if (version.isPresent()) { // A version number attribute exists - so it should be unchanged updateCondition.setValue(Integer.toString(version.get())); // Bump up our version number attribute versionAttribute.setValue(Integer.toString(version.get() + 1)); } else { // A version number attribute did not exist - so it still should not updateCondition.setExists(false); // Set initial value for our version number attribute versionAttribute.setValue("0"); } List<ReplaceableAttribute> replaceableAttributes = new ArrayList<>(); replaceableAttributes.add(versionAttribute); // Add the new attribute replaceableAttributes.add(attribute); PutAttributesRequest simpleDBPutRequest = new PutAttributesRequest(simpleDbDomainName, itemName, replaceableAttributes, updateCondition); try { client.putAttributes(simpleDBPutRequest); } catch (AmazonServiceException ase) { if (ase.getErrorCode().contains("ConditionalCheckFailed")) { // Someone else has mutated an attribute since we read them. This is // likely to be rare, and a retry should almost always succeed. However, // we leave it to clients of this class to retry the call if they wish, // as the new mutation may mean they no longer want to do the put. logger.log("Caught AmazonServiceException for ConditionalCheckFailed whilst creating" + " attribute(s) so throwing as 'Database put failed' instead"); throw new Exception("Database put failed - conditional check failed"); } throw ase; } logger.log("Created attribute(s) in simpledb"); return Integer.parseInt(versionAttribute.getValue()); }
From source file:squash.booking.lambdas.core.OptimisticPersister.java
License:Apache License
@Override public void delete(String itemName, Attribute attribute) throws Exception { if (!initialised) { throw new IllegalStateException("The optimistic persister has not been initialised"); }/*from w ww . jav a 2 s. c om*/ logger.log("About to delete attribute from simpledb item: " + itemName); AmazonSimpleDB client = getSimpleDBClient(); // We retry the delete if necessary if we get a // ConditionalCheckFailed exception, i.e. if someone else modifies the // database between us reading and writing it. RetryHelper.DoWithRetries(() -> { try { // Get existing attributes (and version number), via consistent // read: ImmutablePair<Optional<Integer>, Set<Attribute>> versionedAttributes = get(itemName); if (!versionedAttributes.left.isPresent()) { logger.log( "A version number attribute did not exist - this means no attributes exist, so we have nothing to delete."); return null; } if (!versionedAttributes.right.contains(attribute)) { logger.log("The attribute did not exist - so we have nothing to delete."); return null; } // Since it seems impossible to update the version number while // deleting an attribute, we first mark the attribute as inactive, // and then delete it. ReplaceableAttribute inactiveAttribute = new ReplaceableAttribute(); inactiveAttribute.setName(attribute.getName()); inactiveAttribute.setValue("Inactive" + attribute.getValue()); inactiveAttribute.setReplace(true); put(itemName, versionedAttributes.left, inactiveAttribute); // Now we can safely delete the attribute, as other readers will now // ignore it. UpdateCondition updateCondition = new UpdateCondition(); updateCondition.setName(inactiveAttribute.getName()); updateCondition.setValue(inactiveAttribute.getValue()); // Update will proceed unless the attribute no longer exists updateCondition.setExists(true); Attribute attributeToDelete = new Attribute(); attributeToDelete.setName(inactiveAttribute.getName()); attributeToDelete.setValue(inactiveAttribute.getValue()); List<Attribute> attributesToDelete = new ArrayList<>(); attributesToDelete.add(attributeToDelete); DeleteAttributesRequest simpleDBDeleteRequest = new DeleteAttributesRequest(simpleDbDomainName, itemName, attributesToDelete, updateCondition); client.deleteAttributes(simpleDBDeleteRequest); logger.log("Deleted attribute from simpledb"); return null; } catch (AmazonServiceException ase) { if (ase.getErrorCode().contains("AttributeDoesNotExist")) { // Case of trying to delete an attribute that no longer exists - // that's ok - it probably just means more than one person was // trying to delete the attribute at once. So swallow this // exception logger.log( "Caught AmazonServiceException for AttributeDoesNotExist whilst deleting attribute so" + " swallowing and continuing"); return null; } else { throw ase; } } }, Exception.class, Optional.of("Database put failed - conditional check failed"), logger); }