import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
@Override
public void uploadApplication(String appName, ApplicationArchive archive, UploadStatusCallback callback) throws IOException {
    Assert.notNull(appName, "AppName must not be null");
    Assert.notNull(archive, "Archive must not be null");
    UUID appId = getAppId(appName);

    if (callback == null) {
        callback = UploadStatusCallback.NONE;
    }
    CloudResources knownRemoteResources = getKnownRemoteResources(archive);
    callback.onCheckResources();
    callback.onMatchedFileNames(knownRemoteResources.getFilenames());
    UploadApplicationPayload payload = new UploadApplicationPayload(archive, knownRemoteResources);
    callback.onProcessMatchedResources(payload.getTotalUncompressedSize());
    HttpEntity<?> entity = generatePartialResourceRequest(payload, knownRemoteResources);
    ResponseEntity<Map<String, Object>> responseEntity = getRestTemplate().exchange(getUrl("/v2/apps/{guid}/bits?async=true"),
        HttpMethod.PUT, entity, new ParameterizedTypeReference<Map<String, Object>>() {
        }, appId);
    processAsyncJob(responseEntity.getBody(), callback);
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
@Test
public void shouldPackOnlyMissingResources() throws Exception {
    ZipFile zipFile = new ZipFile(SampleProjects.springTravel());
    try {
        ApplicationArchive archive = new ZipApplicationArchive(zipFile);
        CloudResources allResources = new CloudResources(archive);
        List<CloudResource> resources = new ArrayList<CloudResource>(allResources.asList());
        resources.remove(0);
        CloudResources knownRemoteResources = new CloudResources(resources);
        UploadApplicationPayload payload = new UploadApplicationPayload(archive, knownRemoteResources);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        FileCopyUtils.copy(payload.getInputStream(), bos);
        assertThat(payload.getArchive(), is(archive));
        assertThat(payload.getTotalUncompressedSize(), is(93));
        assertThat(bos.toByteArray().length, is(2451));
    } finally {
        zipFile.close();
    }
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
private CloudResources getKnownRemoteResources(ApplicationArchive archive) throws IOException {
    CloudResources archiveResources = new CloudResources(archive);
    String json = JsonUtil.convertToJson(archiveResources);
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(JsonUtil.JSON_MEDIA_TYPE);
    HttpEntity<String> requestEntity = new HttpEntity<String>(json, headers);
    ResponseEntity<String> responseEntity = getRestTemplate().exchange(getUrl("/v2/resource_match"), HttpMethod.PUT, requestEntity,
        String.class);
    List<CloudResource> cloudResources = JsonUtil.convertJsonToCloudResourceList(responseEntity.getBody());
    return new CloudResources(cloudResources);
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
/**
 * Create a new {@link CloudResources} instance for the specified {@link ApplicationArchive}.
 *
 * @param archive the application archive
 */
public CloudResources(ApplicationArchive archive) throws IOException {
    Assert.notNull(archive, "Archive must not be null");
    this.resources = new ArrayList<CloudResource>();
    for (ApplicationArchive.Entry entry : archive.getEntries()) {
        if (!entry.isDirectory()) {
            String name = entry.getName();
            long size = entry.getSize();
            String sha1 = bytesToHex(entry.getSha1Digest());
            CloudResource resource = new CloudResource(name, size, sha1);
            resources.add(resource);
        }
    }
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
/**
 * Create a new {@link UploadApplicationPayload}.
 *
 * @param archive              the source archive
 * @param knownRemoteResources resources that are already known on the remote server
 * @throws IOException
 */
public UploadApplicationPayload(ApplicationArchive archive, CloudResources knownRemoteResources) throws
        IOException {
    this.archive = archive;
    this.totalUncompressedSize = 0;
    Set<String> matches = knownRemoteResources.getFilenames();
    this.entriesToUpload = new ArrayList<DynamicZipInputStream.Entry>();
    for (ApplicationArchive.Entry entry : archive.getEntries()) {
        if (entry.isDirectory() || !matches.contains(entry.getName())) {
            entriesToUpload.add(new DynamicZipInputStreamEntryAdapter(entry));
            totalUncompressedSize += entry.getSize();
        }
    }
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
@Test
public void shouldGetFromArchive() throws Exception {
    ZipFile zipFile = new ZipFile(SampleProjects.springTravel());
    try {
        ApplicationArchive archive = new ZipApplicationArchive(zipFile);
        CloudResources o = new CloudResources(archive);
        List<CloudResource> l = o.asList();
        assertThat(l.size(), is(96));
        assertThat(l.get(0).getFilename(), is("index.html"));
    } finally {
        zipFile.close();
    }
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
@Override
public Iterable<Entry> getEntries() {
	Iterable<ArchiveEntry> cfEntries = cfArchive.getEntries();
	List<ApplicationArchive.Entry> legacyEntries = new ArrayList<ApplicationArchive.Entry>();
	if (cfEntries != null) {
		for (ArchiveEntry entry : cfEntries) {
			legacyEntries.add(new V1ArchiveEntry(entry));
		}
	}
	return legacyEntries;
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
public Iterable<Entry> getEntries() {
	if (entries == null) {
		entries = new ArrayList<ApplicationArchive.Entry>();
		collectEntriesPriorToDeployment(entries, resources.toArray(new IModuleResource[0]));
	}
	return entries;
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
public ApplicationArchive getApplicationArchive(DockerFoundryApplicationModule module,
		DockerFoundryServer cloudServer, IModuleResource[] moduleResources, IProgressMonitor monitor)
		throws CoreException {
	// No need for application archive, as the CF plugin framework generates
	// .war files for Java Web applications.
	return null;
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
protected ApplicationArchive getIncrementalPublishArchive(final ApplicationDeploymentInfo deploymentInfo,
		IModule[] modules) {
	IModuleResource[] allResources = getResources(modules);
	IModuleResourceDelta[] deltas = getPublishedResourceDelta(modules);
	List<IModuleResource> changedResources = getChangedResources(deltas);
	ApplicationArchive moduleArchive = new CachingApplicationArchive(Arrays.asList(allResources), changedResources,
			modules[0], deploymentInfo.getDeploymentName());

	return moduleArchive;
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
@Override
public void uploadApplication(String appName, ApplicationArchive archive) throws IOException {
    cc.uploadApplication(appName, archive, null);
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
public DynamicZipInputStreamEntryAdapter(ApplicationArchive.Entry entry) {
    this.entry = entry;
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
@Override
public void uploadApplication(String appName, ApplicationArchive archive) throws IOException {
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
public static ApplicationArchive asV1ApplicationArchive(CFApplicationArchive cfArchive) {
	if (cfArchive != null) {
		return new V1ApplicationArchiveAdapter(cfArchive);
	}
	return null;
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
public ApplicationArchive getApplicationArchive(DockerFoundryApplicationModule module,
		IModuleResource[] moduleResources) throws CoreException {
	return new ModuleResourceApplicationArchive(module.getLocalModule(), Arrays.asList(moduleResources));
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
/**
 * 
 * @param descriptor that contains the application information, and that
 * also will be updated with an archive containing the application resources
 * to be deployed to the Cloud Foundry Server
 * @param cloudModule the Cloud Foundry wrapper around the application
 * module to be pushed to the server
 * @param modules list of WTP modules.
 * @param server where app should be pushed to
 * @param
 * @param monitor
 * @throws CoreException if failure occurred while generated an archive file
 * containing the application's payload
 */
protected ApplicationArchive generateApplicationArchiveFile(ApplicationDeploymentInfo deploymentInfo,
		DockerFoundryApplicationModule cloudModule, IModule[] modules, Server server, boolean incrementalPublish,
		IProgressMonitor monitor) throws CoreException {

	// Perform local operations like building an archive file
	// and payload for the application
	// resources prior to pushing it to the server.

	// If the module is not external (meaning that it is
	// mapped to a local, accessible workspace project),
	// create an
	// archive file containing changes to the
	// application's
	// resources. Use incremental publishing if
	// possible.

	AbstractApplicationDelegate delegate = ApplicationRegistry.getApplicationDelegate(cloudModule.getLocalModule());

	ApplicationArchive archive = null;
	if (delegate != null && delegate.providesApplicationArchive(cloudModule.getLocalModule())) {
		IModuleResource[] resources = getResources(modules);

		archive = getApplicationArchive(cloudModule, monitor, delegate, resources);
	}

	// If no application archive was provided,then attempt an incremental
	// publish. Incremental publish is only supported for apps without child
	// modules.
	if (archive == null && incrementalPublish && !hasChildModules(modules)) {
		// Determine if an incremental publish
		// should
		// occur
		// For the time being support incremental
		// publish
		// only if the app does not have child
		// modules
		// To compute incremental deltas locally,
		// modules must be provided
		// Computes deltas locally before publishing
		// to
		// the server.
		// Potentially more efficient. Should be
		// used
		// only on incremental
		// builds

		archive = getIncrementalPublishArchive(deploymentInfo, modules);
	}
	return archive;

}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
private ApplicationArchive getApplicationArchive(DockerFoundryApplicationModule cloudModule,
		IProgressMonitor monitor, AbstractApplicationDelegate delegate, IModuleResource[] resources)
		throws CoreException {
	return delegate.getApplicationArchive(cloudModule, getCloudFoundryServer(), resources, monitor);
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
/**
 * Upload an application to Cloud Foundry.
 *
 * @param appName the application name
 * @param archive the application archive
 * @throws java.io.IOException
 */
void uploadApplication(String appName, ApplicationArchive archive) throws IOException;
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
/**
 * Returns the source archive.
 *
 * @return the archive
 */
public ApplicationArchive getArchive() {
    return archive;
}
 

import org.cloudfoundry.client.lib.archive.ApplicationArchive; //导入依赖的package包/类
@Override
public void uploadApplication(String appName, ApplicationArchive archive) throws IOException {

}