CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-io-fabric8--kubernetes-client-project

Java client for Kubernetes and OpenShift providing access to full REST APIs via a fluent DSL

—

Pending
Overview
Eval results
Files

build-operations.mddocs/

Build Operations

This document covers OpenShift build and build configuration operations, including binary builds, webhook triggers, log streaming, and build management.

Core Imports

import io.fabric8.openshift.client.OpenShiftClient;
import io.fabric8.openshift.api.model.Build;
import io.fabric8.openshift.api.model.BuildList;
import io.fabric8.openshift.api.model.BuildConfig;
import io.fabric8.openshift.api.model.BuildConfigList;
import io.fabric8.openshift.api.model.BuildRequest;
import io.fabric8.openshift.client.dsl.BuildResource;
import io.fabric8.openshift.client.dsl.BuildConfigResource;
import io.fabric8.kubernetes.client.dsl.MixedOperation;

Build Operations

Basic Build Operations

// List all builds in a namespace
BuildList builds = client.builds()
    .inNamespace("my-project")
    .list();

// Get a specific build
Build build = client.builds()
    .inNamespace("my-project")
    .withName("my-app-1")
    .get();

// Delete a build
Boolean deleted = client.builds()
    .inNamespace("my-project")
    .withName("my-app-1")
    .delete();

Build Log Operations

// Get build logs
String buildLog = client.builds()
    .inNamespace("my-project")
    .withName("my-app-1")
    .getLog();

// Get logs with follow mode
String followLogs = client.builds()
    .inNamespace("my-project")
    .withName("my-app-1")
    .getLog(true);  // follow = true

// Get logs for a specific version
String versionLog = client.builds()
    .inNamespace("my-project")
    .withName("my-app-1")
    .withVersion(2)
    .getLog();

Build Filtering and Listing

// List builds with label selector
BuildList labeledBuilds = client.builds()
    .inNamespace("my-project")
    .withLabel("app", "my-application")
    .list();

// List builds with field selector
BuildList completedBuilds = client.builds()
    .inNamespace("my-project")
    .withField("status.phase", "Complete")
    .list();

BuildConfig Operations

Basic BuildConfig Operations

// List all build configurations
BuildConfigList buildConfigs = client.buildConfigs()
    .inNamespace("my-project")
    .list();

// Get a specific build configuration
BuildConfig buildConfig = client.buildConfigs()
    .inNamespace("my-project")
    .withName("my-app")
    .get();

// Create a build configuration
BuildConfig newBuildConfig = new BuildConfigBuilder()
    .withNewMetadata()
        .withName("my-new-app")
        .withNamespace("my-project")
    .endMetadata()
    .withNewSpec()
        // Build config spec details
    .endSpec()
    .build();

BuildConfig created = client.buildConfigs()
    .inNamespace("my-project")
    .create(newBuildConfig);

Build Instantiation

// Instantiate a build from a build config
Build instantiatedBuild = client.buildConfigs()
    .inNamespace("my-project")
    .withName("my-app")
    .instantiate();

// Instantiate with build request
BuildRequest buildRequest = new BuildRequestBuilder()
    .withNewMetadata()
        .withName("my-app")
    .endMetadata()
    .withTriggeredBy(/* trigger causes */)
    .build();

Build requestedBuild = client.buildConfigs()
    .inNamespace("my-project")
    .withName("my-app")
    .instantiate(buildRequest);

Binary Build Operations

// Start binary build from directory
Build binaryBuild = client.buildConfigs()
    .inNamespace("my-project")
    .withName("my-app")
    .instantiateBinary()
    .fromDirectory(new File("/path/to/source"));

// Start binary build from file
Build fileBuild = client.buildConfigs()
    .inNamespace("my-project")
    .withName("my-app")
    .instantiateBinary()
    .fromFile(new File("/path/to/source.tar.gz"));

// Start binary build with input stream
Build streamBuild = client.buildConfigs()
    .inNamespace("my-project")
    .withName("my-app")
    .instantiateBinary()
    .fromInputStream(inputStream);

Webhook Trigger Operations

// Trigger build via webhook
Build webhookBuild = client.buildConfigs()
    .inNamespace("my-project")
    .withName("my-app")
    .trigger()
    .webhookTrigger("secret-here");

// Generic webhook trigger
Build genericBuild = client.buildConfigs()
    .inNamespace("my-project")
    .withName("my-app")
    .trigger()
    .generic("webhook-secret");

// GitHub webhook trigger
Build githubBuild = client.buildConfigs()
    .inNamespace("my-project")
    .withName("my-app")
    .trigger()
    .github("webhook-secret");

Advanced Build Operations

Build Status and Monitoring

// Watch build progress
client.builds()
    .inNamespace("my-project")
    .withName("my-app-1")
    .watch(new Watcher<Build>() {
        @Override
        public void eventReceived(Action action, Build build) {
            System.out.println("Build " + build.getMetadata().getName() + 
                             " phase: " + build.getStatus().getPhase());
        }
        
        @Override
        public void onClose(WatcherException cause) {
            // Handle watch close
        }
    });

// Check if build is complete
Build build = client.builds()
    .inNamespace("my-project")
    .withName("my-app-1")
    .get();

boolean isComplete = "Complete".equals(build.getStatus().getPhase());
boolean isFailed = "Failed".equals(build.getStatus().getPhase());

Build Configuration Updates

// Update build configuration
BuildConfig updated = client.buildConfigs()
    .inNamespace("my-project")
    .withName("my-app")
    .edit(bc -> new BuildConfigBuilder(bc)
        .editSpec()
            .editStrategy()
                .editDockerStrategy()
                    .withFrom(new ObjectReferenceBuilder()
                        .withKind("ImageStreamTag")
                        .withName("nodejs:14-ubi8")
                        .build())
                .endDockerStrategy()
            .endStrategy()
        .endSpec()
        .build());

Build Scaling and Management

// Cancel a running build
Build cancelledBuild = client.builds()
    .inNamespace("my-project")
    .withName("my-app-1")
    .edit(b -> new BuildBuilder(b)
        .editStatus()
            .withPhase("Cancelled")
            .withCancelled(true)
        .endStatus()
        .build());

// Delete all builds for a build config
Boolean allDeleted = client.builds()
    .inNamespace("my-project")
    .withLabel("buildconfig", "my-app")
    .delete();

Usage Examples

Complete Build Workflow Example

import io.fabric8.openshift.client.OpenShiftClient;
import io.fabric8.openshift.api.model.*;

public class BuildWorkflow {
    private final OpenShiftClient client;
    
    public BuildWorkflow(OpenShiftClient client) {
        this.client = client;
    }
    
    public void completeBuildWorkflow(String namespace, String appName) {
        // 1. Create or get build configuration
        BuildConfig buildConfig = getOrCreateBuildConfig(namespace, appName);
        
        // 2. Start a build
        Build build = client.buildConfigs()
            .inNamespace(namespace)
            .withName(appName)
            .instantiate();
        
        // 3. Monitor build progress
        monitorBuild(namespace, build.getMetadata().getName());
        
        // 4. Get build logs after completion
        String logs = client.builds()
            .inNamespace(namespace)
            .withName(build.getMetadata().getName())
            .getLog();
        
        System.out.println("Build completed with logs:\n" + logs);
    }
    
    private BuildConfig getOrCreateBuildConfig(String namespace, String appName) {
        BuildConfig existing = client.buildConfigs()
            .inNamespace(namespace)
            .withName(appName)
            .get();
            
        if (existing != null) {
            return existing;
        }
        
        // Create new build config
        return client.buildConfigs()
            .inNamespace(namespace)
            .create(new BuildConfigBuilder()
                .withNewMetadata()
                    .withName(appName)
                    .withNamespace(namespace)
                    .addToLabels("app", appName)
                .endMetadata()
                .withNewSpec()
                    .withNewSource()
                        .withType("Git")
                        .withNewGit()
                            .withUri("https://github.com/openshift/ruby-ex.git")
                        .endGit()
                    .endSource()
                    .withNewStrategy()
                        .withType("Source")
                        .withNewSourceStrategy()
                            .withNewFrom()
                                .withKind("ImageStreamTag")
                                .withName("ruby:2.7-ubi8")
                                .withNamespace("openshift")
                            .endFrom()
                        .endSourceStrategy()
                    .endStrategy()
                    .withNewOutput()
                        .withNewTo()
                            .withKind("ImageStreamTag")
                            .withName(appName + ":latest")
                        .endTo()
                    .endOutput()
                .endSpec()
                .build());
    }
    
    private void monitorBuild(String namespace, String buildName) {
        client.builds()
            .inNamespace(namespace)
            .withName(buildName)
            .waitUntilCondition(build -> 
                "Complete".equals(build.getStatus().getPhase()) ||
                "Failed".equals(build.getStatus().getPhase()),
                10, TimeUnit.MINUTES);
    }
}

Binary Build Example

public class BinaryBuildExample {
    public void performBinaryBuild(OpenShiftClient client, String namespace, 
                                  String buildConfigName, File sourceDirectory) {
        try {
            // Start binary build from directory
            Build build = client.buildConfigs()
                .inNamespace(namespace)
                .withName(buildConfigName)
                .instantiateBinary()
                .fromDirectory(sourceDirectory);
                
            System.out.println("Started binary build: " + build.getMetadata().getName());
            
            // Monitor progress with logs
            String buildName = build.getMetadata().getName();
            
            // Stream logs in real-time
            client.builds()
                .inNamespace(namespace)
                .withName(buildName)
                .watchLog(System.out);
                
            // Wait for completion
            client.builds()
                .inNamespace(namespace)
                .withName(buildName)
                .waitUntilCondition(b -> 
                    "Complete".equals(b.getStatus().getPhase()) ||
                    "Failed".equals(b.getStatus().getPhase()),
                    15, TimeUnit.MINUTES);
                    
            Build completedBuild = client.builds()
                .inNamespace(namespace)
                .withName(buildName)
                .get();
                
            if ("Complete".equals(completedBuild.getStatus().getPhase())) {
                System.out.println("Build completed successfully!");
            } else {
                System.out.println("Build failed: " + 
                    completedBuild.getStatus().getMessage());
            }
            
        } catch (Exception e) {
            System.err.println("Binary build failed: " + e.getMessage());
            throw new RuntimeException(e);
        }
    }
}

Types

Build

public class Build implements HasMetadata {
    public ObjectMeta getMetadata();
    public BuildSpec getSpec();
    public BuildStatus getStatus();
}

public class BuildSpec {
    public BuildSource getSource();
    public BuildStrategy getStrategy();
    public BuildOutput getOutput();
    public BuildConfigRef getBuildConfigRef();
    public List<BuildTriggerCause> getTriggeredBy();
}

public class BuildStatus {
    public String getPhase();  // Pending, Running, Complete, Failed, Error, Cancelled
    public String getMessage();
    public String getStartTimestamp();
    public String getCompletionTimestamp();
    public Long getDuration();
    public String getOutputDockerImageReference();
    public Boolean getCancelled();
}

BuildConfig

public class BuildConfig implements HasMetadata {
    public ObjectMeta getMetadata();
    public BuildConfigSpec getSpec();
    public BuildConfigStatus getStatus();
}

public class BuildConfigSpec {
    public BuildSource getSource();
    public BuildStrategy getStrategy();
    public BuildOutput getOutput();
    public List<BuildTriggerPolicy> getTriggers();
    public String getRunPolicy();  // Serial, Parallel, SerialLatestOnly
    public Integer getSuccessfulBuildsHistoryLimit();
    public Integer getFailedBuildsHistoryLimit();
}

public class BuildConfigStatus {
    public Integer getLastVersion();
    public List<SourceRevision> getLastRevisions();
}

BuildResource DSL

public interface BuildResource extends Resource<Build> {
    String getLog();
    String getLog(boolean follow);
    BuildResource withVersion(Integer version);
}

BuildConfigResource DSL

public interface BuildConfigResource<T, S, I> extends Resource<T> {
    Build instantiate();
    Build instantiate(BuildRequest buildRequest);
    BinaryBuildRequestBuilder instantiateBinary();
    WebhookTriggerBuilder trigger();
}

Binary Build Operations

public class BinaryBuildRequestBuilder {
    public Build fromDirectory(File directory);
    public Build fromFile(File file);
    public Build fromInputStream(InputStream inputStream);
}

Webhook Trigger Operations

public class WebhookTriggerBuilder {
    public Build webhookTrigger(String secret);
    public Build generic(String secret);
    public Build github(String secret);
    public Build gitlab(String secret);
    public Build bitbucket(String secret);
}

Install with Tessl CLI

npx tessl i tessl/maven-io-fabric8--kubernetes-client-project

docs

api-group-operations.md

authorization-reviews.md

build-operations.md

client-configuration.md

deployment-operations.md

image-operations.md

index.md

network-operations.md

project-operations.md

template-operations.md

user-security.md

tile.json