List of usage examples for org.hibernate.criterion Restrictions lt
public static SimpleExpression lt(String propertyName, Object value)
From source file:com.eucalyptus.objectstorage.metadata.DbMpuPartMetadataManagerImpl.java
License:Open Source License
/** * Returns the ObjectEntities that are in 'creating' for too long and * thus should be considered failed/*from w ww . j a v a 2 s . c o m*/ */ @Override public List<PartEntity> lookupFailedParts() throws MetadataOperationFailureException { // Return the latest version based on the created date. try (TransactionResource trans = Entities.transactionFor(PartEntity.class)) { PartEntity searchExample = new PartEntity().withState(ObjectState.creating); Criteria search = Entities.createCriteria(PartEntity.class); List<PartEntity> results = search.add(Example.create(searchExample)) .add(Restrictions.lt("creationExpiration", System.currentTimeMillis())).list(); trans.commit(); return results; } catch (NoSuchElementException e) { // Swallow this exception return new ArrayList(0); } catch (Exception e) { LOG.warn("Error fetching failed or deleted object records"); throw new MetadataOperationFailureException(e); } }
From source file:com.eucalyptus.objectstorage.metadata.DbObjectMetadataManagerImpl.java
License:Open Source License
@Override public List<ObjectEntity> lookupObjectsForReaping(Bucket bucket, String objectKeyPrefix, Date age) { List<ObjectEntity> results; try (TransactionResource tran = Entities.transactionFor(ObjectEntity.class)) { // setup example and criteria ObjectEntity example = new ObjectEntity().withState(ObjectState.extant).withBucket(bucket); Criteria search = Entities.createCriteria(ObjectEntity.class).add(Example.create(example)); search.add(Restrictions.and(Restrictions.like("objectKey", objectKeyPrefix, MatchMode.START), Restrictions.lt("creationTimestamp", age))); search = getSearchByBucket(search, bucket); results = search.list();//from w w w . j a va2 s .c o m tran.commit(); } catch (Exception ex) { LOG.error("exception caught while retrieving objects prefix with " + objectKeyPrefix + " from bucket " + bucket.getBucketName() + ", error message - " + ex.getMessage()); return Collections.EMPTY_LIST; } return results; }
From source file:com.eucalyptus.objectstorage.metadata.DbObjectMetadataManagerImpl.java
License:Open Source License
/** * Returns the ObjectEntities that are in 'creating' for too long and * thus should be considered failed//from ww w . j a v a 2 s . c o m */ @Override public List<ObjectEntity> lookupFailedObjects() throws MetadataOperationFailureException { // Return the latest version based on the created date. try (TransactionResource trans = Entities.transactionFor(ObjectEntity.class)) { ObjectEntity searchExample = new ObjectEntity().withState(ObjectState.creating); Criteria search = Entities.createCriteria(ObjectEntity.class); List<ObjectEntity> results = search.add(Example.create(searchExample)) .add(Restrictions.lt("creationExpiration", System.currentTimeMillis())).list(); trans.commit(); return results; } catch (NoSuchElementException e) { // Swallow this exception return new ArrayList(0); } catch (Exception e) { LOG.warn("Error fetching failed or deleted object records"); throw new MetadataOperationFailureException(e); } }
From source file:com.eucalyptus.objectstorage.metadata.DbObjectMetadataManagerImpl.java
License:Open Source License
@Override public PaginatedResult<ObjectEntity> listVersionsPaginated(final Bucket bucket, int maxEntries, String prefix, String delimiter, String fromKeyMarker, String fromVersionId, boolean latestOnly) throws Exception { EntityTransaction db = Entities.get(ObjectEntity.class); try {//w w w. j a v a2 s. co m PaginatedResult<ObjectEntity> result = new PaginatedResult<ObjectEntity>(); HashSet<String> commonPrefixes = new HashSet<String>(); // Include zero since 'istruncated' is still valid if (maxEntries >= 0) { final int queryStrideSize = maxEntries + 1; ObjectEntity searchObj = new ObjectEntity().withBucket(bucket).withState(ObjectState.extant); // Return latest version, so exclude delete markers as well. // This makes listVersion act like listObjects if (latestOnly) { searchObj.setIsLatest(true); searchObj.setIsDeleteMarker(false); } Criteria objCriteria = Entities.createCriteria(ObjectEntity.class); objCriteria.setReadOnly(true); objCriteria.setFetchSize(queryStrideSize); objCriteria.add(Example.create(searchObj)); objCriteria.addOrder(Order.asc("objectKey")); objCriteria.addOrder(Order.desc("objectModifiedTimestamp")); objCriteria.setMaxResults(queryStrideSize); if (!Strings.isNullOrEmpty(fromKeyMarker)) { if (!Strings.isNullOrEmpty(fromVersionId)) { // Look for the key that matches the key-marker and version-id-marker ObjectEntity searchObject = new ObjectEntity(bucket, fromKeyMarker, fromVersionId); ObjectEntity matchingObject = null; try { matchingObject = Entities.uniqueResult(searchObject); if (matchingObject == null || matchingObject.getObjectModifiedTimestamp() == null) { throw new NoSuchKeyException(bucket.getBucketName() + "/" + fromKeyMarker + "?versionId=" + fromVersionId); } } catch (Exception e) { LOG.warn("No matching object found for key-marker=" + fromKeyMarker + " and version-id-marker=" + fromVersionId); throw new NoSuchKeyException( bucket.getBucketName() + "/" + fromKeyMarker + "?versionId=" + fromVersionId); } // The result set should be exclusive of the key with the key-marker version-id-marker pair. Look for keys that chronologically // follow the version-id-marker for the given key-marker and also the keys that follow the key-marker. objCriteria.add(Restrictions.or( Restrictions.and(Restrictions.eq("objectKey", fromKeyMarker), Restrictions.lt("objectModifiedTimestamp", matchingObject.getObjectModifiedTimestamp())), Restrictions.gt("objectKey", fromKeyMarker))); } else { // No version-id-marker, just set the criteria the key-marker objCriteria.add(Restrictions.gt("objectKey", fromKeyMarker)); } } else { // No criteria to be set } if (!Strings.isNullOrEmpty(prefix)) { objCriteria.add(Restrictions.like("objectKey", prefix, MatchMode.START)); } else { prefix = ""; } objCriteria = getSearchByBucket(objCriteria, bucket); // Ensure not null. if (Strings.isNullOrEmpty(delimiter)) { delimiter = ""; } List<ObjectEntity> objectInfos = null; int resultKeyCount = 0; String[] parts = null; String prefixString = null; boolean useDelimiter = !Strings.isNullOrEmpty(delimiter); int pages = 0; // Iterate over result sets of size maxkeys + 1 since // commonPrefixes collapse the list, we may examine many more // records than maxkeys + 1 do { parts = null; prefixString = null; // Skip ahead the next page of 'queryStrideSize' results. objCriteria.setFirstResult(pages++ * queryStrideSize); objectInfos = (List<ObjectEntity>) objCriteria.list(); if (objectInfos == null) { // nothing to do. break; } for (ObjectEntity objectRecord : objectInfos) { if (useDelimiter) { // Check if it will get aggregated as a commonprefix parts = objectRecord.getObjectKey().substring(prefix.length()).split(delimiter); if (parts.length > 1) { prefixString = prefix + parts[0] + delimiter; if (!prefixString.equals(fromKeyMarker) && !commonPrefixes.contains(prefixString)) { if (resultKeyCount == maxEntries) { // This is a new record, so we know // we're truncating if this is true result.setIsTruncated(true); resultKeyCount++; break; } else { // Add it to the common prefix set commonPrefixes.add(prefixString); result.setLastEntry(prefixString); // count the unique commonprefix as a // single return entry resultKeyCount++; } } else { // Already have this prefix, so skip } continue; } } if (resultKeyCount == maxEntries) { // This is a new (non-commonprefix) record, so // we know we're truncating result.setIsTruncated(true); resultKeyCount++; break; } result.getEntityList().add(objectRecord); result.setLastEntry(objectRecord); resultKeyCount++; } if (resultKeyCount <= maxEntries && objectInfos.size() <= maxEntries) { break; } } while (resultKeyCount <= maxEntries); // Sort the prefixes from the hashtable and add to the reply if (commonPrefixes != null) { result.getCommonPrefixes().addAll(commonPrefixes); Collections.sort(result.getCommonPrefixes()); } } else { throw new IllegalArgumentException("MaxKeys must be positive integer"); } return result; } catch (Exception e) { LOG.error("Error generating paginated object list of bucket " + bucket.getBucketName(), e); throw e; } finally { db.rollback(); } }
From source file:com.eucalyptus.objectstorage.WalrusManager.java
License:Open Source License
public ListVersionsResponseType listVersions(ListVersionsType request) throws EucalyptusCloudException { ListVersionsResponseType reply = (ListVersionsResponseType) request.getReply(); EntityWrapper<BucketInfo> db = EntityWrapper.get(BucketInfo.class); try {//w w w . j a v a 2s . c om String bucketName = request.getBucket(); BucketInfo bucketInfo = new BucketInfo(bucketName); bucketInfo.setHidden(false); List<BucketInfo> bucketList = db.queryEscape(bucketInfo); Context ctx = Contexts.lookup(); Account account = ctx.getAccount(); int maxKeys = -1; String maxKeysString = request.getMaxKeys(); if (maxKeysString != null) { maxKeys = Integer.parseInt(maxKeysString); if (maxKeys < 0) { throw new InvalidArgumentException("max-keys", "Argument max-keys must be an integer between 0 and " + Integer.MAX_VALUE); } } else { maxKeys = WalrusProperties.MAX_KEYS; } if (bucketList.size() > 0) { BucketInfo bucket = bucketList.get(0); BucketLogData logData = bucket.getLoggingEnabled() ? request.getLogData() : null; if (ctx.hasAdministrativePrivileges() || (bucket.canRead(account.getAccountNumber()) && (bucket.isGlobalRead() || Lookups.checkPrivilege(PolicySpec.S3_LISTBUCKETVERSIONS, PolicySpec.VENDOR_S3, PolicySpec.S3_RESOURCE_BUCKET, bucketName, null)))) { if (logData != null) { updateLogData(bucket, logData); reply.setLogData(logData); } if (Contexts.lookup().hasAdministrativePrivileges()) { try { if (bucketHasSnapshots(bucketName)) { db.rollback(); throw new NoSuchBucketException(bucketName); } } catch (Exception e) { db.rollback(); throw new EucalyptusCloudException(e); } } String prefix = request.getPrefix(); String keyMarker = request.getKeyMarker(); String versionMarker = request.getVersionIdMarker(); String delimiter = request.getDelimiter(); reply.setName(bucketName); reply.setIsTruncated(false); reply.setPrefix(prefix); reply.setMaxKeys(maxKeys); reply.setDelimiter(delimiter); reply.setKeyMarker(keyMarker); reply.setVersionIdMarker(versionMarker); if (bucket.isVersioningDisabled()) { db.commit(); return reply; } if (maxKeys == 0) { // No keys requested, so just return reply.setKeyEntries(new ArrayList<KeyEntry>()); reply.setCommonPrefixesList(new ArrayList<CommonPrefixesEntry>()); db.commit(); return reply; } final int queryStrideSize = maxKeys + 1; EntityWrapper<ObjectInfo> dbObject = db.recast(ObjectInfo.class); ObjectInfo searchObj = new ObjectInfo(); searchObj.setBucketName(bucketName); Criteria objCriteria = dbObject.createCriteria(ObjectInfo.class); objCriteria.add(Example.create(searchObj)); objCriteria.addOrder(Order.asc("objectKey")); objCriteria.addOrder(Order.desc("lastModified")); objCriteria.setMaxResults(queryStrideSize); // add one to, hopefully, indicate truncation in one call // Ensure these aren't null keyMarker = (Strings.isNullOrEmpty(keyMarker) ? "" : keyMarker); prefix = (Strings.isNullOrEmpty(prefix) ? "" : prefix); versionMarker = (Strings.isNullOrEmpty(versionMarker) ? "" : versionMarker); if (!Strings.isNullOrEmpty(keyMarker)) { if (!Strings.isNullOrEmpty(versionMarker)) { Date resumeDate = null; try { ObjectInfo markerObj = new ObjectInfo(); markerObj.setBucketName(bucketName); markerObj.setVersionId(versionMarker); markerObj.setObjectKey(keyMarker); ObjectInfo lastFromPrevObj = dbObject.uniqueResultEscape(markerObj); if (lastFromPrevObj != null && lastFromPrevObj.getLastModified() != null) { resumeDate = lastFromPrevObj.getLastModified(); } else { dbObject.rollback(); throw new NoSuchEntityException("VersionIDMarker " + versionMarker + " does not match an existing object version"); } } catch (TransactionException e) { LOG.error(e); dbObject.rollback(); throw new EucalyptusCloudException( "Next-Key-Marker or Next-Version-Id marker invalid"); } // The result set should be exclusive of the key with the key-marker version-id-marker pair. Look for keys that lexicographically // follow the version-id-marker for a given key-marker and also the keys that follow the key-marker. objCriteria.add(Restrictions.or( Restrictions.and(Restrictions.eq("objectKey", keyMarker), Restrictions.lt("lastModified", resumeDate)), Restrictions.gt("objectKey", keyMarker))); } else { // The result set should be exclusive of the key-marker. key-marker could be a common prefix from a previous response. Look for keys // that lexicographically follow the key-marker and don't contain the key-marker as the prefix. objCriteria.add(Restrictions.and(Restrictions.gt("objectKey", keyMarker), Restrictions.not(Restrictions.like("objectKey", keyMarker, MatchMode.START)))); } } if (!Strings.isNullOrEmpty(prefix)) { objCriteria.add(Restrictions.like("objectKey", prefix, MatchMode.START)); } else { prefix = ""; // ensure not null has already been set in the reply, so this is safe } List<ObjectInfo> objectInfos = null; int resultKeyCount = 0; ArrayList<KeyEntry> keyEntries = new ArrayList<KeyEntry>(); String nextKeyMarker = null; String nextVersionIdMarker = null; TreeSet<String> commonPrefixes = new TreeSet<String>(); int firstResult = -1; // Iterate over result sets of size maxkeys + 1 do { // Start listing from the 0th element and increment the first element to be listed by the query size objCriteria.setFirstResult(queryStrideSize * (++firstResult)); objectInfos = (List<ObjectInfo>) objCriteria.list(); if (objectInfos.size() > 0) { for (ObjectInfo objectInfo : objectInfos) { String objectKey = objectInfo.getObjectKey(); // Check if it will get aggregated as a commonprefix if (!Strings.isNullOrEmpty(delimiter)) { String[] parts = objectKey.substring(prefix.length()).split(delimiter); if (parts.length > 1) { String prefixString = prefix + parts[0] + delimiter; if (!commonPrefixes.contains(prefixString)) { if (resultKeyCount == maxKeys) { // This is a new record, so we know we're truncating if this is true reply.setNextKeyMarker(nextKeyMarker); reply.setNextVersionIdMarker(nextVersionIdMarker); reply.setIsTruncated(true); resultKeyCount++; break; } commonPrefixes.add(prefixString); resultKeyCount++; // count the unique commonprefix as a single return entry // If max keys have been collected, set the next-key-marker. It might be needed for the response if the list is // truncated // If the common prefixes hit the limit set by max-keys, next-key-marker is the last common prefix and there is no // version-id-marker if (resultKeyCount == maxKeys) { nextKeyMarker = prefixString; nextVersionIdMarker = null; } } continue; } } if (resultKeyCount == maxKeys) { // This is a new (non-commonprefix) record, so we know we're truncating reply.setNextKeyMarker(nextKeyMarker); reply.setNextVersionIdMarker(nextVersionIdMarker); reply.setIsTruncated(true); resultKeyCount++; break; } // This is either a version entry or a delete marker KeyEntry keyEntry = null; if (!objectInfo.getDeleted()) { keyEntry = new VersionEntry(); ((VersionEntry) keyEntry).setEtag(objectInfo.getEtag()); ((VersionEntry) keyEntry).setSize(objectInfo.getSize()); ((VersionEntry) keyEntry).setStorageClass(objectInfo.getStorageClass()); } else { keyEntry = new DeleteMarkerEntry(); } keyEntry.setKey(objectKey); keyEntry.setVersionId(objectInfo.getVersionId()); keyEntry.setIsLatest(objectInfo.getLast()); keyEntry.setLastModified(DateUtils.format(objectInfo.getLastModified().getTime(), DateUtils.ALT_ISO8601_DATE_PATTERN)); try { Account ownerAccount = Accounts.lookupAccountById(objectInfo.getOwnerId()); keyEntry.setOwner(new CanonicalUserType(ownerAccount.getCanonicalId(), ownerAccount.getName())); } catch (AuthException e) { db.rollback(); throw new AccessDeniedException("Bucket", bucketName, logData); } keyEntries.add(keyEntry); resultKeyCount++; // If max keys have been collected, set the next- markers. They might be needed for the response if the list is truncated if (resultKeyCount == maxKeys) { nextKeyMarker = objectKey; nextVersionIdMarker = objectInfo.getVersionId(); } } } if (resultKeyCount <= maxKeys && objectInfos.size() <= maxKeys) { break; } } while (resultKeyCount <= maxKeys); reply.setKeyEntries(keyEntries); // Prefixes are already sorted, add them to the proper data structures and populate the reply if (!commonPrefixes.isEmpty()) { ArrayList<CommonPrefixesEntry> commonPrefixesList = new ArrayList<CommonPrefixesEntry>(); for (String prefixEntry : commonPrefixes) { commonPrefixesList.add(new CommonPrefixesEntry().add(new PrefixEntry(prefixEntry))); } reply.setCommonPrefixesList(commonPrefixesList); } } else { db.rollback(); throw new AccessDeniedException("Bucket", bucketName, logData); } } else { db.rollback(); throw new NoSuchBucketException(bucketName); } db.commit(); return reply; } finally { if (db.isActive()) { db.rollback(); } } }
From source file:com.eucalyptus.reporting.art.generator.AbstractArtGenerator.java
License:Open Source License
protected Criterion before(final Long endExclusive) { return Restrictions.lt(TIMESTAMP_MS, endExclusive); }
From source file:com.eucalyptus.reporting.export.Export.java
License:Open Source License
public static ReportingExport export(final Date startDate, final Date endDate, final boolean includeDependencies) { final ReportingExport export = new ReportingExport(); final Conjunction criterion = Restrictions.conjunction(); if (startDate != null) { criterion.add(Restrictions.ge(CREATION_TIMESTAMP, startDate)); }/* w w w .ja va 2 s. c o m*/ if (endDate != null) { criterion.add(Restrictions.lt(CREATION_TIMESTAMP, endDate)); } final List<ReportingEventSupport> actions = Lists.newArrayList(); export.addUsage( Iterables.filter( Iterables.transform( iterableExporter(criterion, getUsageClasses(), Collections.<ReportingEventSupport>emptyList(), includeDependencies), ExportUtils.toExportUsage(includeDependencies ? actions : null)), Predicates.notNull())); export.addActions( Iterables .transform( Iterables.concat(actions, iterableExporter(criterion, getEventClasses(), actions, includeDependencies)), Functions.compose(userAccountDecorator(), ExportUtils.toExportAction()))); return export; }
From source file:com.eucalyptus.simpleworkflow.persist.PersistenceActivityTasks.java
License:Open Source License
public <T> List<T> listTimedOut(final Function<? super ActivityTask, T> transform) throws SwfMetadataException { return listByExample(ActivityTask.exampleWithOwner(null), Predicates.alwaysTrue(), Restrictions.lt("timeoutTimestamp", new Date()), Collections.<String, String>emptyMap(), transform); }
From source file:com.eucalyptus.simpleworkflow.persist.PersistenceActivityTypes.java
License:Open Source License
public <T> List<T> listDeprecatedExpired(final long time, final Function<? super ActivityType, T> transform) throws SwfMetadataException { return listByExample(ActivityType.exampleWithOwner(null), Predicates.alwaysTrue(), Restrictions.lt("deprecationTimestamp", new Date(time - getDeprecatedActivityTypeRetentionDurationMillis())), Collections.<String, String>emptyMap(), transform); }
From source file:com.eucalyptus.simpleworkflow.persist.PersistenceDomains.java
License:Open Source License
public <T> List<T> listDeprecatedExpired(final long time, final Function<? super Domain, T> transform) throws SwfMetadataException { return listByExample(Domain.exampleWithStatus(Domain.Status.Deprecated), Predicates.alwaysTrue(), Restrictions.conjunction().add(Restrictions.isEmpty("workflowTypes")) .add(Restrictions.lt("lastUpdateTimestamp", new Date(time - getDeprecatedDomainRetentionDurationMillis()))), Collections.<String, String>emptyMap(), transform); }