jib源码分析之Step实现

class RetrieveRegistryCredentialsStep implements AsyncStep<Credential>, Callable<Credential> {
  	public Credential call() throws CredentialRetrievalException {
  		...
  		Optional<Credential> optionalCredential = credentialRetriever.retrieve();
  		...
  	}	
}

@FunctionalInterface
public interface CredentialRetriever {
  	Optional<Credential> retrieve() throws CredentialRetrievalException;
}

public class RegistryImage implements SourceImage, TargetImage {
	public RegistryImage addCredential(String username, String password) {
    	addCredentialRetriever(() -> Optional.of(Credential.basic(username, password)));
    	return this;
  	}
}

public class Credential {
	private final String username;
  		private final String password;
}

public class Authorization {
  	private final String scheme;
  	private final String token;
}

public ImmutableList<PullAndCacheBaseImageLayerStep> call() {
    BaseImageWithAuthorization pullBaseImageStepResult = NonBlockingSteps.get(pullBaseImageStep);
    ImmutableList<Layer> baseImageLayers = pullBaseImageStepResult.getBaseImage().getLayers();
    ...
  	ImmutableList.Builder<PullAndCacheBaseImageLayerStep> pullAndCacheBaseImageLayerStepsBuilder =
      	ImmutableList.builderWithExpectedSize(baseImageLayers.size());
  	for (Layer layer : baseImageLayers) {
    	pullAndCacheBaseImageLayerStepsBuilder.add(
        	new PullAndCacheBaseImageLayerStep(...,
            	layer.getBlobDescriptor().getDigest(),
            	pullBaseImageStepResult.getBaseImageAuthorization()));
  	}
  return pullAndCacheBaseImageLayerStepsBuilder.build();
  	}

  	...
    try (...) {
      	Cache cache = buildConfiguration.getBaseImageLayersCache();
      	// Checks if the layer already exists in the cache.
      	Optional<CachedLayer> optionalCachedLayer = cache.retrieve(layerDigest);
      	if (optionalCachedLayer.isPresent()) {
        	buildConfiguration.getEventDispatcher().dispatch(new ProgressEvent(progressAllocation, 1));
        	return optionalCachedLayer.get();
      	}
      	RegistryClient registryClient = ...
      	CachedLayer cachedLayer = cache.writeCompressedLayer(registryClient.pullBlob(layerDigest));
      	...
      	return cachedLayer;
    }
  	}

public ImmutableList<AsyncStep<PushBlobStep>> call() throws ExecutionException {
    try (...) {
        ImmutableList<? extends AsyncStep<? extends CachedLayer>> cachedLayer =
            NonBlockingSteps.get(cachedLayerStep);
        // Constructs a PushBlobStep for each layer.
        ImmutableList.Builder<AsyncStep<PushBlobStep>> pushBlobStepsBuilder = ImmutableList.builder();
        for (AsyncStep<? extends CachedLayer> cachedLayerStep : cachedLayer) {
          ListenableFuture<PushBlobStep> pushBlobStepFuture =
              Futures.whenAllSucceed(cachedLayerStep.getFuture())
                  .call(() -> makePushBlobStep(cachedLayerStep), listeningExecutorService);
          pushBlobStepsBuilder.add(() -> pushBlobStepFuture);
        }
        return pushBlobStepsBuilder.build();
    }
}

Jib.from("busybox")
   .addLayer(Arrays.asList(Paths.get("helloworld.sh")), AbsoluteUnixPath.get("/")) 
   .setEntrypoint("sh", "/helloworld.sh")
   .containerize(
       Containerizer.to(RegistryImage.named("gcr.io/my-project/hello-from-jib")
                                     .addCredential("myusername", "mypassword")));

public CachedLayer call() throws IOException, CacheCorruptedException {
    ...
    try (...) {
        Cache cache = buildConfiguration.getApplicationLayersCache();
        // Don't build the layer if it exists already.
        Optional<CachedLayer> optionalCachedLayer = cache.retrieve(layerConfiguration.getLayerEntries());
        if (optionalCachedLayer.isPresent()) {
        	return optionalCachedLayer.get();
        }
        Blob layerBlob = new ReproducibleLayerBuilder(layerConfiguration.getLayerEntries()).build();
        CachedLayer cachedLayer =
          cache.writeUncompressedLayer(layerBlob, layerConfiguration.getLayerEntries());
        ...
        return cachedLayer;
    }
}

private PushBlobStep afterBuildConfigurationFutureFuture()throws ExecutionException, IOException {
	...
    Image<Layer> image = NonBlockingSteps.get(NonBlockingSteps.get(buildImageStep));
    Blob containerConfigurationBlob = new ImageToJsonTranslator(image).getContainerConfigurationBlob();
    BlobDescriptor blobDescriptor = containerConfigurationBlob.writeTo(ByteStreams.nullOutputStream());
    return new PushBlobStep(
      	...
      	authenticatePushStep,
      	blobDescriptor,
      	containerConfigurationBlob);
}

public BlobDescriptor call() throws IOException, RegistryException, ExecutionException {
	...
 	RegistryClient registryClient = ...
    // check if the BLOB is available
    if (registryClient.checkBlob(blobDescriptor.getDigest()) != null) {			// 如果 registry 已经存在该blob，便直接返回
      	return blobDescriptor;
    }
	// todo: leverage cross-repository mounts
    registryClient.pushBlob(blobDescriptor.getDigest(), blob, null);
    ...
    return blobDescriptor;  
}

private ListenableFuture<BuildResult> afterAllPushed() throws ExecutionException, IOException {
    RegistryClient registryClient = xx
    Image<Layer> image = NonBlockingSteps.get(NonBlockingSteps.get(buildImageStep));
    // Constructs the image.
    ImageToJsonTranslator imageToJsonTranslator =
        new ImageToJsonTranslator(image);
    / Gets the image manifest to push.
    BlobDescriptor containerConfigurationBlobDescriptor =
        NonBlockingSteps.get(NonBlockingSteps.get(NonBlockingSteps.get(pushContainerConfigurationStep)));
    BuildableManifestTemplate manifestTemplate =
          imageToJsonTranslator.getManifestTemplate(
              buildConfiguration.getTargetFormat(), containerConfigurationBlobDescriptor);
    // Pushes to all target image tags.
    List<ListenableFuture<Void>> pushAllTagsFutures = new ArrayList<>();
    for (String tag : buildConfiguration.getAllTargetImageTags()) {
        pushAllTagsFutures.add(
            listeningExecutorService.submit(
                () -> {
                  ...
                  // Pushes the image manifest for a specific tag
                  registryClient.pushManifest(manifestTemplate, tag);
                  return null;
                }));
    }
    DescriptorDigest imageDigest =
        JsonTemplateMapper.toBlob(manifestTemplate)
              .writeTo(ByteStreams.nullOutputStream())
              .getDigest();
    DescriptorDigest imageId = containerConfigurationBlobDescriptor.getDigest();
    BuildResult result = new BuildResult(imageDigest, imageId);
    Futures.whenAllSucceed(pushAllTagsFutures)
    return result;
}