Java StoredObject.delete方法代码示例

import org.javaswift.joss.model.StoredObject; //导入方法依赖的package包/类
@Override
public boolean delete(String hostName, Path path, boolean recursive) throws IOException {
  String obj = path.toString();
  if (path.toString().startsWith(hostName)) {
    obj = getObjName(hostName, path);
  }
  LOG.debug("Object name to delete {}. Path {}", obj, path.toString());
  try {
    StoredObject so = mJossAccount.getAccount().getContainer(container)
        .getObject(obj);
    if (so.exists()) {
      so.delete();
      objectCache.remove(obj);
    }
  } catch (Exception e) {
    LOG.warn(e.getMessage());
    LOG.warn("Delete on {} resulted in FileNotFound exception", path);
    return false;
  }
  return true;
}
 

import org.javaswift.joss.model.StoredObject; //导入方法依赖的package包/类
/**
 * {@inheritDoc}.
 */
@Override
public synchronized void emptyContainer(Container container, StopRequester stopRequester, SwiftCallback callback) {
	
	CheckAccount () ;
	
	try
	{
     for (StoredObject so : eagerFetchStoredObjects(container)) 
     {
     	if (!keepGoing (stopRequester, callback))
     		return ;
     	
     	if (so.exists())
     		so.delete();
         callback.onNumberOfCalls(account.getNumberOfCalls());
     }
     logger.info(String.format("Container %s has been emptied", container.getName()));
	}
	finally
	{
     reloadContainer(container, callback);
     callback.onNumberOfCalls(account.getNumberOfCalls());
	}
    
}
 

import org.javaswift.joss.model.StoredObject; //导入方法依赖的package包/类
/**
 * {@inheritDoc}.
 */
@Override
public synchronized void purgeContainer(Container container, StopRequester stopRequester, SwiftCallback callback) {
	
	CheckAccount () ;
	
	try
	{
     for (StoredObject so : eagerFetchStoredObjects(container)) 
     {
     	if (!keepGoing (stopRequester, callback))
     		return ;
     	
     	if (so.exists())
     		so.delete();
         callback.onNumberOfCalls(account.getNumberOfCalls());
     }
     container.delete();
     logger.info(String.format("Container %s has been removed", container.getName()));
	}
	finally
	{
     callback.onUpdateContainers(eagerFetchContainers(account));
     callback.onNumberOfCalls(account.getNumberOfCalls());
	}
}
 

import org.javaswift.joss.model.StoredObject; //导入方法依赖的package包/类
@Test
  public void shouldCleanUpExtraSegments() 
  {
  	uploadAndCheckSegmentedFile () ;
  	
  	StoredObject manifest = container.getObject(objName);
  	int initialSegmentCount = largeObjectManager.getSegmentsList(manifest).size() ;
  
  	// we delete the manifest only (so that the segments remain)
  	manifest.delete();
  	assertFalse (manifest.exists()) ;
  	
  	// We reduce the file size so that less segments are required
  	long newFileSize = fileSize / 2 ;
largeFile = null ;
  	uploadAndCheckSegmentedFile (newFileSize, segmentSize) ;
  	
  	// we verify that the actual number of segments is coherent
  	int newSegmentCount = largeObjectManager.getSegmentsList(container.getObject(objName)).size() ;
  	assertTrue (initialSegmentCount > newSegmentCount) ;
  	assertTrue (newSegmentCount == TestUtils.getNumberOfSegments (newFileSize, segmentSize)) ;
  }
 

import org.javaswift.joss.model.StoredObject; //导入方法依赖的package包/类
private void cleanUpExtraSegments (AbstractStoredObject obj, Set<StoredObject> toKeep)
{
	List<StoredObject> list =  getSegmentsList (obj) ;
	for (StoredObject so : list)
	{
		if (toKeep != null && toKeep.contains(so))
			continue ;
		logger.info("Delete unused segment ({})", so.getBareName()) ;
		so.delete(); 
	}
}
 

import org.javaswift.joss.model.StoredObject; //导入方法依赖的package包/类
private void deleteStoredObjects(Container container, List<StoredObject> storedObjects, StopRequester stopRequester, boolean notify, SwiftCallback callback) {

       for (StoredObject storedObject : storedObjects) 
       {
       	if (!keepGoing (stopRequester, callback))
       		break ;
       	
		// segmented objects should be deleted as well
		if (largeObjectManager.isSegmented (storedObject))
		{				
			List<StoredObject> segments = largeObjectManager.getSegmentsList (storedObject) ;
			// we delete each segment, starting by the last one, so that if something
			// unexpected happen at the middle of the iteration, the getSegmentsList method
			// will still be able to get the list of the remaining segments. 
            ListIterator<StoredObject> segmentsIter = segments.listIterator(segments.size()) ;
			while (segmentsIter.hasPrevious()) 
			{
				StoredObject segment = segmentsIter.previous() ;
				if (segment == null || !segment.exists())
					continue ;
				logger.info("Deleting segment " + segment.getPath());
				segment.delete();
			}
		}
		if (storedObject.exists())
		{
			storedObject.delete();
			logger.info("Deleted object: " + storedObject.getName());
		}
		else
		{
			logger.debug("Attempt at deleting a non-existing object: " + storedObject.getName());
			continue ;
		}
		if (notify)
			callback.onStoredObjectDeleted(container, storedObject);
       }
       callback.onNumberOfCalls(account.getNumberOfCalls());
}
 

import org.javaswift.joss.model.StoredObject; //导入方法依赖的package包/类
public static void DeleteObject(String username,String passwod,String dataNode, String container, String key)throws Exception {
	try {
		Account client = ViPRSwiftClient(username, passwod, dataNode);
		Container myContainer = client.getContainer(container);
		StoredObject object = myContainer.getObject(key);
		object.delete();

	} catch (Exception e) {
		System.out.println("error during delete " + key);
		e.printStackTrace();
	}
}
 

import org.javaswift.joss.model.StoredObject; //导入方法依赖的package包/类
public static void DeleteObject(String username,String passwod,String dataNode, String container, String key)throws Exception
{
	
	Account client= ViPRSwiftClient(username, passwod, dataNode);
	Container myContainer=client.getContainer(container);
	StoredObject object = myContainer.getObject(key);
    object.delete();
}
 

import org.javaswift.joss.model.StoredObject; //导入方法依赖的package包/类
@Override
public boolean delete(String contentUrl) {
	StoredObject object = this.container.getObject(contentUrl);
	object.delete();
	return true;
}
 

import org.javaswift.joss.model.StoredObject; //导入方法依赖的package包/类
private static void example() {
  // Create a Connection
  AccountConfig config = new AccountConfig();
  config.setUsername(username);
  config.setPassword(password);
  config.setAuthUrl(authUrl);
  config.setAuthenticationMethod(AuthenticationMethod.BASIC);
  Account account = new AccountFactory(config).createAccount();

  // Create a Container
  Container container = account.getContainer("my-new-container");
  container.create();

  // Create an Object
  StoredObject object = container.getObject("foo.txt");
  object.uploadObject(new File("src/test/resources/foo.txt"));

  // Add/Update Object Metadata
  Map<String, Object> metadata = new TreeMap<String, Object>();
  metadata.put("key", "value");
  object.setMetadata(metadata);

  // List Owned Containers
  Collection<Container> containers = account.list();
  for (Container currentContainer : containers) {
    System.out.println(currentContainer.getName());
  }

  // List a Container's Content
  Collection<StoredObject> objects = container.list();
  for (StoredObject currentObject : objects) {
    System.out.println(currentObject.getName());
  }

  // Retrieve an Object's Metadata
  Map<String, Object> returnedMetadata = object.getMetadata();
  for (String name : returnedMetadata.keySet()) {
    System.out.println("META / " + name + ": " + returnedMetadata.get(name));
  }

  // Retrieve an Object
  object.downloadObject(new File("/tmp/outfile.txt"));

  // Delete an Object
  object.delete();

  // Delete a Container
  container.delete();
}
 

import org.javaswift.joss.model.StoredObject; //导入方法依赖的package包/类
public void shouldFindFilesDifferences (FindFilesDifferencesTestScenario scenario)
  {
  	Container container = account.getContainer("x").create() ;
  	final String fileName = "myFile" ;
try 
{
	File local = TestUtils.getTestFile(tmpFolder, fileName, 100) ;
	ops.uploadFiles(container, null, new File[]{local} , true, stopRequester, callback);
	StoredObject remote = container.getObject(fileName) ;
	assertTrue (remote.exists()) ;
	
	switch (scenario)
	{
	case MISSING_LOCAL:
		{
			assertTrue (local.delete()) ;
		}
		break;
	case MISSING_REMOTE:
		{
			remote.delete();
			assertFalse (remote.exists()) ;
		}
		break ;
	case MODIFIED_FILE:
		{
			// we modify the file
	    	FileOutputStream out = new FileOutputStream(local);
	      	out.write(new byte[]{'a', 'b', 'c', 'd', 'e'});
	    	out.close();
		}
		break;
	case NO_DIFF:
		break;
       default:
       	throw new IllegalStateException () ;
	}

   	@SuppressWarnings("unchecked")
   	ResultCallback<Collection<Pair<? extends ComparisonItem, ? extends ComparisonItem> > > resultCallback 
   	 	= (ResultCallback<Collection<Pair<? extends ComparisonItem, ? extends ComparisonItem> > >)Mockito.mock(ResultCallback.class) ;
   	
   	@SuppressWarnings({ "unchecked", "rawtypes" })
	ArgumentCaptor<Collection<Pair<? extends ComparisonItem, ? extends ComparisonItem> > > argument = ArgumentCaptor.forClass((Class) ResultCallback.class);
   	
   	ops.findDifferences(container, remote, local, resultCallback, stopRequester, callback);
   	
   	Mockito.verify(resultCallback, Mockito.times(1)).onResult(argument.capture());
   	
   	assertTrue ((scenario == FindFilesDifferencesTestScenario.NO_DIFF) ? (argument.getValue().isEmpty()) : (!argument.getValue().isEmpty())) ;
} 
catch (IOException e) {
      	logger.error ("Error occurred in shouldFindFilesDifferences", e) ;
      	assertFalse(true) ;
}
  }