import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
@Transactional(retryOn = { ONeedRetryException.class })
@Override
public void createSnapshot(String id, SnapshotComponentSelector selector) throws IOException {
  StorageTx tx = UnitOfWork.currentTx();
  StorageFacet storageFacet = facet(StorageFacet.class);
  Bucket bucket = tx.findBucket(getRepository());
  Component component = tx.createComponent(bucket, getRepository().getFormat()).name(id);
  tx.saveComponent(component);
  for (SnapshotItem item : collectSnapshotItems(selector)) {
    String assetName = createAssetPath(id, item.specifier.path);
    Asset asset = tx.createAsset(bucket, component).name(assetName);
    try (final TempBlob streamSupplier = storageFacet.createTempBlob(item.content.openInputStream(), FacetHelper.hashAlgorithms)) {
      AssetBlob blob = tx.createBlob(item.specifier.path, streamSupplier, FacetHelper.hashAlgorithms, null,
          FacetHelper.determineContentType(item), true);
      tx.attachBlob(asset, blob);
    }
    finally {
      item.content.close();
    }
    tx.saveAsset(asset);
  }
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
@Transactional(retryOn = { ONeedRetryException.class })
@Override
public Content getSnapshotFile(String id, String path) throws IOException {
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());
  Component component = tx.findComponentWithProperty(P_NAME, id, bucket);
  if (component == null) {
    return null;
  }

  final Asset asset = tx.findAssetWithProperty(P_NAME, createAssetPath(id, path), component);
  if (asset == null) {
    return null;
  }
  if (asset.markAsDownloaded()) {
    tx.saveAsset(asset);
  }

  final Blob blob = tx.requireBlob(asset.requireBlobRef());
  return FacetHelper.toContent(asset, blob);
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
/**
 * Execute operation within transaction and propagate/translate exceptions.
 */
private <T> T execute(final Operation<T> operation) throws JobPersistenceException {
  try {
    synchronized (monitor) {
      return inTx(databaseInstance)
          .retryOn(ONeedRetryException.class, ORecordNotFoundException.class)
          .throwing(JobPersistenceException.class)
          .call(operation::execute);
    }
  }
  catch (Exception e) {
    log.warn("Execution failed", e);
    Throwables.propagateIfPossible(e, JobPersistenceException.class);
    throw new JobPersistenceException(e.toString(), e);
  }
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
@Override
public List<OperableTrigger> acquireNextTriggers(final long noLaterThan,
                                                 final int maxCount,
                                                 final long timeWindow)
    throws JobPersistenceException
{
  try {
    synchronized (monitor) {
      return inTx(databaseInstance)
          .retryOn(ONeedRetryException.class, ORecordNotFoundException.class)
          .call(db -> doAcquireNextTriggers(db, noLaterThan, maxCount, timeWindow));
    }
  }
  catch (RuntimeException e) {
    acquireNextTriggersSummarizer.log("Problem acquiring next triggers", e);
    try {
      Thread.sleep(10); // introduce small delay, otherwise quartz will immediately try again
    }
    catch (InterruptedException ignore) { // NOSONAR
      // ignored
    }
    throw new JobPersistenceException(e.toString(), e);
  }
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
/**
 * Update the status of task.status to newStatus. Update will be applied to database and the task object. 
 * @param newStatus
 * @param task
 * @return
 * @throws ObjectNotFoundException
 * @throws NdexException
 */
public Task updateTaskStatus(Status newStatus, Task task) throws ObjectNotFoundException, NdexException {
	ODocument doc = this.getRecordByUUID(task.getExternalId(), NdexClasses.Task);
	Status s = Status.valueOf((String)doc.field(NdexClasses.Task_P_status));
	if ( s != newStatus ) {
   		for	(int retry = 0;	retry <	NdexDatabase.maxRetries;	++retry)	{
   			try	{
   	    		doc.fields(NdexClasses.Task_P_status, newStatus,
     				   NdexClasses.ExternalObj_mTime, new Date()).save();
  				break;
   			} catch(ONeedRetryException	e)	{
   				doc.reload();
   			}
   		}
	}
	task.setStatus(newStatus);
	return task;
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
public int purgeTask (UUID taskID) throws ObjectNotFoundException, NdexException {
    ODocument d = this.getRecordByUUID(taskID, NdexClasses.Task);
    boolean isDeleted = d.field(NdexClasses.ExternalObj_isDeleted);
 
    if ( isDeleted ) {
        OrientVertex v = graph.getVertex(d);
			   
 		for	(int retry = 0;	retry <	NdexDatabase.maxRetries;	++retry)	{
 			try	{
	   			v.remove();
	   			break;
 			} catch(ONeedRetryException	e)	{
 				logger.warning("Write conflict when deleting task. Error: " + e.getMessage() +
					"\nRetry ("+ retry + ") deleting task " + taskID.toString() );
 				v.reload();
 			}
 		}
	
 		return 1;
    } 
    
    throw new NdexException ("Only deleted tasks can be purged.");
    
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
/** 
 * Delete up to CLEANUP_BATCH_SIZE vertices in a network. This function is for cleaning up a logically 
 * deleted network in the database. 
 * @param uuid
 * @return Number of vertices being deleted. If the returned number is negative, it means the elements
 * of the network are not completely deleted yet, and the number of vertices deleted are abs(returned number).
 * @throws ObjectNotFoundException
 * @throws NdexException
 */
public int cleanupDeleteNetwork(String uuid) throws ObjectNotFoundException, NdexException {
	ODocument networkDoc = getRecordByUUID(UUID.fromString(uuid), NdexClasses.Network);
	
	int count = cleanupNetworkElements(networkDoc);
	if ( count >= CLEANUP_BATCH_SIZE) {
		return (-1) * count;
	}
	
	// remove the network node.
	networkDoc.reload();
	
	for	(int retry = 0;	retry <	NdexDatabase.maxRetries;	++retry)	{
		try	{
			graph.removeVertex(graph.getVertex(networkDoc));
			break;
		} catch(ONeedRetryException	e)	{
			logger.warning("Retry: "+ e.getMessage());
			networkDoc.reload();
		}
	}
	
	return count++;
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
private int cleanupElement(ODocument doc, int currentCount) {
	int counter = currentCount;
	doc.reload();

	for	(int retry = 0;	retry <	NdexDatabase.maxRetries;	++retry)	{
		try	{
			graph.removeVertex(graph.getVertex(doc));
			break;
		} catch(ONeedRetryException	e)	{
			logger.warning("Retry: "+ e.getMessage());
			doc.reload();
		}
	}
	counter ++;
	if ( counter % 2000 == 0 ) {
		graph.commit();
		if (counter % 10000 == 0 ) {
			logger.info("Deleted " + counter + " vertexes from network during cleanup.");
		}
	}
	return counter;
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
public void doInTXWithRetry(DBOperation operation, int maxRetries) throws Exception {
    OrientGraph graph = graph();
    for (int retry = 0; retry < maxRetries; ++retry) {
        try {
            operation.execute(graph);
            graph.commit();
            break;
        } catch (ONeedRetryException e) {
            // SOMEONE HAVE UPDATE THE INVOICE VERTEX AT THE SAME TIME, RETRY IT
        }
    }
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
@Transactional(retryOn = { ONeedRetryException.class })
protected void doIndicateVerified(Content content, CacheInfo cacheInfo, String assetPath) {
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());

  Asset asset = Content.findAsset(tx, bucket, content);
  if (asset == null) {
    asset = tx.findAssetWithProperty(P_NAME, assetPath, bucket);
  }
  if (asset == null) {
    return;
  }
  CacheInfo.applyToAsset(asset, cacheInfo);
  tx.saveAsset(asset);
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
@Transactional(retryOn = { ONeedRetryException.class })
@Override
public void deleteSnapshot(String id) throws IOException {
  StorageTx tx = UnitOfWork.currentTx();
  Bucket bucket = tx.findBucket(getRepository());
  Component component = tx.findComponentWithProperty(P_NAME, id, bucket);
  if (component == null) {
    return;
  }
  tx.deleteComponent(component);
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
@Override
@Guarded(by = STARTED)
public void createComponentNode(final String repositoryName, final List<String> path, final Component component) {
  inTxRetry(databaseInstance)
      // handle case where assets try to create the exact same component-level path at once
      .retryOn(ONeedRetryException.class, ORecordDuplicatedException.class)
      .run(db -> entityAdapter.createComponentNode(db, repositoryName, path, component));
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
@Override
@Guarded(by = STARTED)
public void createAssetNode(final String repositoryName, final List<String> path, final Asset asset) {
  inTxRetry(databaseInstance)
      // handle case where an asset and its component try to create the exact same path at once
      .retryOn(ONeedRetryException.class, ORecordDuplicatedException.class)
      .run(db -> entityAdapter.createAssetNode(db, repositoryName, path, asset));
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
/**
 * Searching for {@link com.orientechnologies.common.concur.ONeedRetryException} in exception hierarchy.
 *
 * @param th thrown exception
 * @return true if retry could be performed
 */
private boolean isRetryException(final Throwable th) {
    Throwable current = th;
    boolean res = false;
    while (current != null) {
        if (current instanceof ONeedRetryException) {
            res = true;
            break;
        }
        current = current.getCause();
    }
    return res;
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
public int deleteTask (UUID taskID) throws ObjectNotFoundException, NdexException {
    ODocument d = this.getRecordByUUID(taskID, NdexClasses.Task);
   
	for	(int retry = 0;	retry <	NdexDatabase.maxRetries;	++retry)	{
		try	{
	        d.fields(NdexClasses.ExternalObj_isDeleted,  true, 
        		 NdexClasses.ExternalObj_mTime, new Date()).save();
		break;
		} catch(ONeedRetryException	e)	{
			d.reload();
		}
	}
	
	return 1;		           
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
private void cleanupElement(ODocument doc) {
		doc.reload();

		for	(int retry = 0;	retry <	NdexDatabase.maxRetries;	++retry)	{
			try	{
				graph.removeVertex(graph.getVertex(doc));
				break;
			} catch(ONeedRetryException	e)	{
//				logger.warning("Retry: "+ e.getMessage());
				doc.reload();
			}
		}
	}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
@Transactional(retryOn = { ONeedRetryException.class })
@Override
protected void indicateVerified(Context context, Content content, CacheInfo cacheInfo) throws IOException {
  doIndicateVerified(content, cacheInfo, assetPath(context));
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
public UUID createTask(String accountName, Task newTask) throws ObjectNotFoundException, NdexException {
	
	if (newTask.getExternalId() == null)
		newTask.setExternalId(NdexUUIDFactory.INSTANCE.createNewNDExUUID());
	
	ODocument taskDoc = new ODocument(NdexClasses.Task)
			.fields(NdexClasses.ExternalObj_ID, newTask.getExternalId().toString(),
				NdexClasses.ExternalObj_cTime, newTask.getCreationTime(),
				NdexClasses.ExternalObj_mTime, newTask.getModificationTime(),
				NdexClasses.Task_P_description, newTask.getDescription(),
				NdexClasses.Task_P_status, newTask.getStatus(),
				NdexClasses.Task_P_priority, newTask.getPriority(),
				NdexClasses.Task_P_progress, newTask.getProgress(),
				NdexClasses.Task_P_taskType, newTask.getTaskType(),
				NdexClasses.Task_P_resource, newTask.getResource(),
				NdexClasses.ExternalObj_isDeleted, false,
				NdexClasses.Task_P_startTime, newTask.getStartTime(),
				NdexClasses.Task_P_endTime, newTask.getFinishTime(),
				NdexClasses.Task_P_message, newTask.getMessage());

	if ( newTask.getFormat() != null) 
		taskDoc = taskDoc.field(NdexClasses.Task_P_fileFormat, newTask.getFormat());
	
	if ( newTask.getAttributes() != null ) {
		taskDoc = taskDoc.field(NdexClasses.Task_P_attributes, newTask.getAttributes());
	}
	
	taskDoc = taskDoc.save();
	
	if ( accountName != null) {
		ODocument userDoc = getRecordByAccountName(accountName, NdexClasses.User);
		
		String userUUID = userDoc.field(NdexClasses.ExternalObj_ID);

		taskDoc = taskDoc.field("ownerUUID", userUUID).save();
		
		OrientVertex taskV = graph.getVertex(taskDoc);
		
		OrientVertex userV = this.graph.getVertex(userDoc.reload());
		for	(int retry = 0;	retry <	NdexDatabase.maxRetries;	++retry)	{
			try	{
				taskV.addEdge(NdexClasses.Task_E_owner, userV );

				break;
			} catch(ONeedRetryException	e)	{
				logger.warning("Retry creating task add edge.");
				taskV.reload();
				taskV.getRecord().removeField("out_"+ NdexClasses.Task_E_owner);
				userV.reload();
			}
		}
		newTask.setTaskOwnerId(UUID.fromString(userUUID));
		graph.commit();
		NdexServerQueue.INSTANCE.addUserTask(newTask);
	}
	
	return newTask.getExternalId();
	
}
 

import com.orientechnologies.common.concur.ONeedRetryException; //导入依赖的package包/类
public int revokePrivilege(String networkUUID, String accountUUID) throws NdexException, SolrServerException, IOException {
  	// check if the edge exists?

  	Permissions p = Helper.getNetworkPermissionByAccout(this.db,networkUUID, accountUUID);

      if ( p ==null ) {
      	logger.info("Permission doesn't exists between account " + accountUUID + 
      			 " and network " + networkUUID + ". Igore revoke request."); 
      	return 0;
      }
      
      //check if this network has other admins
      if ( p == Permissions.ADMIN && !Helper.canRemoveAdmin(this.db, networkUUID, accountUUID)) {
      	
      	throw new NdexException ("Privilege revoke failed. Network " + networkUUID +" only has account " + accountUUID
      			+ " as the administrator.");
      }
      
      ODocument networkdoc = this.getNetworkDocByUUID(UUID.fromString(networkUUID));
      ODocument accountdoc = this.getRecordByUUID(UUID.fromString(accountUUID), null);
      
      String className = accountdoc.getClassName();
      String accountName = accountdoc.field(NdexClasses.account_P_accountName);
      OrientVertex networkV = graph.getVertex(networkdoc);
      OrientVertex accountV = graph.getVertex(accountdoc);
      
      for ( com.tinkerpop.blueprints.Edge e : accountV.getEdges(networkV, Direction.OUT)) { 
      	
  		for	(int retry = 0;	retry <	NdexDatabase.maxRetries;	++retry)	{
  			try	{
  	          	graph.removeEdge(e);
  				break;
  			} catch(ONeedRetryException	ex)	{
  				logger.warning("Retry removing edge between account and network: " + ex.getMessage());
  		       networkV.reload();
  		       accountV.reload();
  			}
  		}
        	break;
      }

//update solr index
NetworkGlobalIndexManager networkIdx = new NetworkGlobalIndexManager();
networkIdx.revokeNetworkPermission(networkUUID, accountName, p, 
		className.equals(NdexClasses.User));
      
      
  	return 1;
  }