Pod myPod = client.pods().load(new FileInputStream("some-pod.yml")).item();

PodList podList = client.pods().inNamespace("default").list();

PodList podList = client.pods().inAnyNamespace().list();

PodList podList = client.pods().inNamespace("default").withLabel("foo", "bar").list();

Pod myPod = client.pods().inNamespace("default").withName("nginx-pod").get();

Pod aPod = new PodBuilder().withNewMetadata().withName("demo-pod1").endMetadata()
    .withNewSpec()
    .addNewContainer()
    .withName("nginx")
    .withImage("nginx:1.7.9")
    .addNewPort().withContainerPort(80).endPort()
    .endContainer()
    .endSpec()
    .build();
Pod createdPod = client.pods().inNamespace("default").resource(aPod).create();

client.pods().inNamespace("default").resource(pod).serverSideApply();

client.pods().inNamespace("default").withName("nginx").edit(
  p -> new PodBuilder(p).editOrNewMetadata().addToLabels("new","label").endMetadata().build()
);

String log = client.pods().inNamespace("default").withName("test-pod").getLog();

LogWatch watch = client.pods().inNamespace(namespace).withName(podName).tailingLines(10).watchLog(System.out);

client.pods().inNamespace("default").withName("nginx").delete();

client.resourceList(pod1, pod2).inNamespace("default").delete();

Pod pod = client.pods().inNamespace("default").withName("nginx").waitUntilReady(5, TimeUnit.MINUTES);

Pod pod = client.pods().inNamespace("default").withName("nginx").waitUntilCondition(pod -> pod.getStatus().getPhase().equals("Succeeded"), 1, TimeUnit.MINUTES);

int containerPort =  client.pods().inNamespace("default").withName("testpod").get().getSpec().getContainers().get(0).getPorts().get(0).getContainerPort();
LocalPortForward portForward = client.pods().inNamespace("default").withName("testpod").portForward(containerPort, 8080);

final CountDownLatch deleteLatch = new CountDownLatch(1);
Watch podWatch = client.pods().withName("pod1").watch(new Watcher<>() {
    @Override
    public void eventReceived(Action action, Pod resource) {
      switch (action) {
        case DELETED:
          deleteLatch.countDown();
      }
    }

    @Override
    public void onClose(WatcherException e) { }
});
deleteLatch.await(10, TimeUnit.MINUTES);

    client.pods().inNamespace(currentNamespace).withName(pod1.getMetadata().getName())
      .file("/tmp/toBeUploaded").upload(tmpFile.toPath());

    try (InputStream is = client.pods().inNamespace(currentNamespace).withName(pod1.getMetadata().getName()).file("/msg").read())  {
      String result = new BufferedReader(new InputStreamReader(is)).lines().collect(Collectors.joining("\n"));
    }

PodResource resource = client.pods().withName("pod1");
resource.ephemeralContainers()
  .edit(p -> new PodBuilder(p)
    .editSpec()
    .addNewEphemeralContainer()
    .withName("debugger")
    .withImage("busybox")
    .withCommand("sleep", "36000")
    .endEphemeralContainer()
    .endSpec()
    .build());

resource.waitUntilCondition(p -> p.getStatus()
	.getEphemeralContainerStatuses()
	.stream()
	.filter(s -> s.getName().equals("debugger"))
	.anyMatch(s -> s.getState().getRunning() != null), 2, TimeUnit.MINUTES);
ByteArrayOutputStream out = new ByteArrayOutputStream();
try (ExecWatch watch = resource.inContainer("debugger")
  .writingOutput(out)
  .exec("sh", "-c", "echo 'hello world!'")) {
  assertEquals(0, watch.exitCode().join());
  assertEquals("hello world!\n", out.toString());
}

Service aService = client.services().load(new FileInputStream("service.yml")).item();

Service service = client.services().inNamespace("default").withName("some-service").get();

Service createdSvc = client.services().inNamespace("default").resource(svc).create();

Service createdSvc = client.services().inNamespace("default").resource(svc).serverSideApply();

ServiceList svcList = client.services().inNamespace("default").list();

ServiceList svcList = client.services().inAnyNamespace().list();

ServiceList svcList = client.services().inNamespace("default").withLabel("foo", "bar").list();

client.services().inNamespace("default").withName("some-svc").delete();

client.services().inNamespace("default").watch(new Watcher<>() {
	@Override
	public void eventReceived(Action action, Service resource) {
		// Perform something depending upon action
	}

	@Override
	public void onClose(WatcherException cause) {

	}
});

Deployment aDeployment = client.apps().deployments().load(new FileInputStream("test-deployments.yml")).item();

Deployment deploy = client.apps().deployments().inNamespace("default").withName("deploy-1").get();

Deployment deployment1 = new DeploymentBuilder()
   .withNewMetadata()
      .withName("deployment1")
      .addToLabels("test", "deployment")
   .endMetadata()
   .withNewSpec()
      .withReplicas(1)
      .withNewTemplate()
        .withNewMetadata()
        .addToLabels("app", "httpd")
        .endMetadata()
        .withNewSpec()
          .addNewContainer()
             .withName("busybox")
             .withImage("busybox")
             .withCommand("sleep","36000")
          .endContainer()
        .endSpec()
      .endTemplate()
      .withNewSelector()
        .addToMatchLabels("app","httpd")
      .endSelector()
   .endSpec()
 .build();

client.apps().deployments().inNamespace("default").resource(deployment1).create();

Deployment createdDeployment = client.apps().deployments().inNamespace("default").resource(deployObj).serverSideApply();

DeploymentList aDeploymentList = client.apps().deployments().inNamespace("default").list();

DeploymentList aDeploymentList = client.apps().deployments().inAnyNamespace().list();

DeploymentList aDeployList = client.apps().deployments().inNamespace("default").withLabel("foo", "bar").list();

// Scales Deployment to 2 replicas
Deployment updatedDeploy = client.apps().deployments().inNamespace("default")
  .withName("deployment1").edit(
    d -> new DeploymentBuilder(d).editSpec().withReplicas(2).endSpec().build()
  );

Deployment updatedDeployment = client.apps()
  .deployments()
  .inNamespace("default")
  .withName("ngix-controller")
  .updateImage("docker.io/nginx:latest");

Map<String, String> containerToImageMap = new HashMap<>();
containerToImageMap.put("nginx", "nginx:perl");
containerToImageMap.put("sidecar", "someImage:someVersion");
Deployment updatedDeployment = client.apps().deployments()
      .inNamespace("default")
      .withName("nginx-deployment")
      .updateImage(containerToImageMap);

Deployment deployment = client.apps().deployments()
      .inNamespace("default")
      .withName("nginx-deployment")
      .rolling()
      .restart();

Deployment deployment = client.apps().deployments()
      .inNamespace("default")
      .withName("nginx-deployment")
      .rolling()
      .pause();

Deployment deployment = client.apps().deployments()
      .inNamespace("default")
      .withName("nginx-deployment")
      .rolling()
      .resume();

Deployment deployment = client.apps().deployments()
      .inNamespace("default")
      .withName("nginx-deployment")
      .rolling()
      .undo();

client.apps().deployments().inNamespace("default").withName("foo").delete();

client.apps().deployments().inNamespace("default").watch(new Watcher<>() {
	@Override
	public void eventReceived(Action action, Deployment resource) {
		// Do stuff depending upon action
	}

	@Override
	public void onClose(WatcherException cause) {

	}
});

client.apps().deployments().inNamespace("default").withName("nginx-deployment").scale(1);

client.apps().deployments().inNamespace("default").withName("nginx").watchLog(System.out);

ReplicaSet replicaSet = client.apps().replicaSets().inNamespace("default")
  .load(new FileInputStream("test-replicaset.yml")).item();

ReplicaSet rs = client.apps().replicaSets().inNamespace("default").withName("rs1").get();

ReplicaSet replicaset1 = new ReplicaSetBuilder()
      .withNewMetadata()
      .withName("replicaset1")
      .addToLabels("app", "guestbook")
      .addToLabels("tier", "frontend")
      .endMetadata()
      .withNewSpec()
      .withReplicas(1)
      .withNewSelector()
      .withMatchLabels(Collections.singletonMap("tier", "frontend"))
      .endSelector()
      .withNewTemplate()
      .withNewMetadata()
      .addToLabels("app", "guestbook")
      .addToLabels("tier", "frontend")
      .endMetadata()
      .withNewSpec()
      .addNewContainer()
      .withName("busybox")
      .withImage("busybox")
      .withCommand("sleep","36000")
      .withNewResources()
      .withRequests(requests)
      .endResources()
      .withEnv(envVarList)
      .endContainer()
      .endSpec()
      .endTemplate()
      .endSpec()
      .build();

client.apps().replicaSets().inNamespace("default").resources(replicaset1).create();

ReplicaSet rs = client.apps().replicaSets().inNamespace("default").resource(replicaSet).serverSideApply();

ReplicaSetList rsList = client.apps().replicaSets().inNamespace("default").list();

ReplicaSetList rsList = client.apps().replicaSets().inAnyNamespace().list();

ReplicaSetList rsList = client.apps().replicaSets().inNamespace("default").withLabel("foo", "bar").list(); 

client.apps().replicaSets().inNamespace("default").withName("rs1").delete();

client.apps().replicaSets().inNamespace("default").watch(new Watcher<>() {
	@Override
	public void eventReceived(Action action, ReplicaSet resource) {
		// Do some stuff depending upon action type
	}

	@Override
	public void onClose(WatcherException e) {

	}
});

// Scale to 3 replicas
client.apps().replicaSets().inNamespace("default").withName("nginx-rs").scale(3);

ReplicaSet replicaSet = client.apps().replicaSets()
        .inNamespace("default")
        .withName("soaktestrs")
        .updateImage("nickchase/soaktest");

Map<String, String> containerToImageMap = new HashMap<>();
containerToImageMap.put("c1", "image1");
containerToImageMap.put("c2", "image2");
ReplicaSet replicaSet = client.apps().replicaSets()
            .inNamespace("default")
            .withName("soaktestrs")
            .updateImage(containerToImageMap);

ReplicationController aReplicationController = client.replicationControllers().inNamespace("default")
      .load(new FileInputStream("/test-replicationcontroller.yml")).item();

ReplicationController rc = client.replicationControllers().inNamespace("default").withName("nginx-controller").get();

ReplicationController rc1 = new ReplicationControllerBuilder()
  .withNewMetadata().withName("nginx-controller").addToLabels("server", "nginx").endMetadata()
  .withNewSpec().withReplicas(3)
  .withNewTemplate()
  .withNewMetadata().addToLabels("server", "nginx").endMetadata()
  .withNewSpec()
  .addNewContainer().withName("nginx").withImage("nginx")
  .addNewPort().withContainerPort(80).endPort()
  .endContainer()
  .endSpec()
  .endTemplate()
  .endSpec().build();

ReplicationController rc = client.replicationControllers().inNamespace("default").resource(rc1).create();

ReplicationController rc = client.replicationControllers().inNamespace("default").resource(rc1).serverSideApply();

ReplicationControllerList rcList = client.replicationControllers().inNamespace("default").list();

ReplicationControllerList rcList = client.replicationControllers().inAnyNamespace("default").list();

ReplicationControllerList rcList = client.replicationControllers().inNamespace("default").withLabel("foo", "bar").list();

client.replicationControlers().inNamespace("default").withName("nginx-controller").delete();

client.replicationControllers().inNamespace(currentNamespace).watch(new Watcher<>() {
  @Override
  public void eventReceived(Action action, ReplicationController resource) {
    // Do something depending upon action type    
  }

  @Override
  public void onClose(WatcherException cause) {

  }
});

ReplicationController rc = client.replicationControllers()
       .inNamespace("default")
       .withName("nginx")
       .updateImage("nginx:latest");

Map<String, String> containerToImageMap = new HashMap<>();
containerToImageMap.put("c1", "image1");
containerToImageMap.put("c2", "image2");
ReplicationController rc = client.replicationControllers()
       .inNamespace("default")
       .withName("nginx")
       .updateImage(controllerToImageMap);

ConfigMap configMap = client.configMaps().load(new FileInputStream("configmap1.yml")).item();

ConfigMap configMap = client.configMaps().inNamespace("default").withName("configmap1").get();

ConfigMap configMap1 = new ConfigMapBuilder()
      .withNewMetadata().withName("configmap1").endMetadata()
      .addToData("1", "one")
      .addToData("2", "two")
      .addToData("3", "three")
      .build();
ConfigMap configMap = client.configMaps().inNamespace("default").resource(configMap1).create();

ConfigMap configMap = client.configMaps().inNamespace("default").resource(configMap1).serverSideApply();

ConfigMapList configMapList = client.configMaps().inNamespace("default").list();

ConfigMapList configMapList = client.configMaps().inAnyNamespace().list();

ConfigMapList configMapList = client.configMaps().inNamespace("default").withLabel("foo", "bar").list();

client.configMaps().inNamespace("default").withName("configmap1").delete();

client.configMaps().inNamespace("default").watch(new Watcher<>() {
  @Override
  public void eventReceived(Action action, ConfigMap resource) {
    // Do something depending upon action type    
  }

  @Override
  public void onClose(WatcherException cause) {

  }
});

ConfigMap configMap1 = client.configMaps().inNamespace(currentNamespace).withName("configmap1").edit(
  c -> new ConfigMapBuilder(c).addToData("4", "four").build()
);

Secret aSecret = client.secrets().inNamespace("default").load(new FileInputStream("test-secret.yml")).item();

Secret secret = client.secrets().inNamespace("default").withName("secret1").get()

Secret secret1 = new SecretBuilder()
      .withNewMetadata().withName("secret1").endMetadata()
      .addToData("username", "guccifer")
      .addToData("password", "shadowgovernment")
      .build();
Secret secretCreated = client.secrets().inNamespace("default").resource(secret1).create();

Secret createdSecret = client.secrets().inNamespace("default").resource(secret1).serverSideApply();

SecretList secretList = client.secrets().inNamespace("default").list();

SecretList secretList = client.secrets().inAnyNamespace().list();

SecretList secretList = client.secrets().inNamespace("default").withLabel("foo", "bar").list();

Secret secret1 = client.secrets().inNamespace(currentNamespace).withName("secret1").edit(
  s -> new SecretBuilder(s).withType("Opaque").build()
);

client.secrets().inNamespace("default").withName("secret1").delete();

client.secrets().inNamespace("default").watch(new Watcher<>() {
  @Override
  public void eventReceived(Action action, Secret resource) {
    // Do something depending upon action type
  }

  @Override
  public void onClose(WatcherException cause) {

  }
});

Job job = client.batch().jobs().load(new FileInputStream("sample-job.yml")).item();

Job job = client.batch().jobs().inNamespace("default").withName("pi").get();

final Job job = new JobBuilder()
    .withApiVersion("batch/v1")
    .withNewMetadata()
    .withName("pi")
    .withLabels(Collections.singletonMap("label1", "maximum-length-of-63-characters"))
    .withAnnotations(Collections.singletonMap("annotation1", "some-very-long-annotation"))
    .endMetadata()
    .withNewSpec()
    .withNewTemplate()
    .withNewSpec()
    .addNewContainer()
    .withName("pi")
    .withImage("perl")
    .withArgs("perl", "-Mbignum=bpi", "-wle", "print bpi(2000)")
    .endContainer()
    .withRestartPolicy("Never")
    .endSpec()
    .endTemplate()
    .endSpec()
    .build();

client.batch().jobs().inNamespace("default").resource(job).create();

Job job = client.batch().v1().jobs().inNamespace("default").resource(job1).serverSideApply();

JobList jobList = client.batch().jobs().inNamespace("default").list();

JobList jobList = client.batch().jobs().inAnyNamespace().list();

JobList jobList = client.batch().jobs().inNamespace("default").withLabel("foo", "bar").list();

client.batch().jobs().inNamespace("default").withName("pi").delete();

client.batch().jobs().inNamespace("default").watch(new Watcher<>() {
    @Override
    public void eventReceived(Action action, Job resource) {
      // Do something depending upon action 
    }

    @Override
    public void onClose(WatcherException cause) {

    }
});

CronJob cronJob = client.batch().cronjobs().load(new FileInputStream("cronjob.yml")).item();

CronJob aCronJob = client.batch().cronjobs().inNamespace("default").withName("some-cj").get();

CronJob cronJob1 = new CronJobBuilder()
    .withApiVersion("batch/v1beta1")
    .withNewMetadata()
    .withName("hello")
    .withLabels(Collections.singletonMap("foo", "bar"))
    .endMetadata()
    .withNewSpec()
    .withSchedule("*/1 * * * *")
    .withNewJobTemplate()
    .withNewSpec()
    .withNewTemplate()
    .withNewSpec()
    .addNewContainer()
    .withName("hello")
    .withImage("busybox")
    .withArgs("/bin/sh", "-c", "date; echo Hello from Kubernetes")
    .endContainer()
    .withRestartPolicy("OnFailure")
    .endSpec()
    .endTemplate()
    .endSpec()
    .endJobTemplate()
    .endSpec()
    .build();

cronJob1 = client.batch().cronjobs().inNamespace("default").resource(cronJob1).create();

CronJob cronJob = client.batch().v1().cronjobs().inNamespace("default").resource(cronJob1).serverSideApply();

CronJobList cronJobList = client.batch().cronjobs().inNamespace("default").list()

CronJobList cronJobList = client.batch().cronjobs().inAnyNamespace().list();

CronJobList cronJobList = client.batch().cronjobs().inNamespace("default").withLabel("foo", "bar").list();

CronJob cronJob1 = client.batch().cronjobs().inNamespace("default").withName(cronJob1.getMetadata().getName()).edit(
  cj -> new CronJobBuilder(cj).editSpec().withSchedule("*/1 * * * *").endSpec().build()
);

client.batch().cronjobs().inNamespace("default").withName("pi").delete();

Namespace namespace = client.namespaces().load(new FileInputStream("namespace-test.yml")).item();

Namespace namespace = client.namespaces().withName("namespace1").get();

NamespaceList namespaceList = client.namespaces().list();

NamespaceList namespaceList = client.namespaces().withLabel("key1", "value1").list();

client.namespaces().withName("ns1").delete();

ServiceAccount svcAccount = client.serviceAccounts().inNamespace("default")
  .load(new FileInputStream("sa.yml")).item();

ServiceAccount sa = client.serviceAccounts().inNamespace("default").withName("sa-ribbon").get();

ServiceAccount serviceAccount1 = new ServiceAccountBuilder()
  .withNewMetadata().withName("serviceaccount1").endMetadata()
  .withAutomountServiceAccountToken(false)
  .build();

client.serviceAccounts().inNamespace("default").resource(serviceAccount1).create();

ServiceAccount serviceAccount = client.serviceAccounts().inNamespace("default").resource(serviceAccount1).serverSideApply();

ServiceAccountList svcAccountList = client.serviceAccounts().inNamespace("default").list();

ServiceAccountList saList = client.serviceAccounts().inNamespace("default").withLabel("foo", "bar").list();

ServiceAccount serviceAccount1 = client.serviceAccounts().inNamespace("default").withName("serviceaccount1").edit(
  sa -> new ServiceAccountBuilder(sa).addNewSecret().withName("default-token-uudp").endSecret()
  .addNewImagePullSecret().withName("myregistrykey").endImagePullSecret()
  .build();
);

client.serviceAccounts().inNamespace("default").withName("serviceaccount1").delete();

Ingress ingress = client.network().v1().ingress().load(new FileInputStream("ingress.yml")).item();

Ingress ingress = client.network().v1().ingress().inNamespace("default").withName("ingress1").get();

Ingress ingress = new IngressBuilder()
  .withNewMetadata().withName("test-ingress").addToAnnotations("nginx.ingress.kubernetes.io/rewrite-target", "/").endMetadata()
  .withNewSpec()
  .addNewRule()
  .withNewHttp()
  .addNewPath()
  .withPath("/testPath").withNewBackend().withServiceName("test").withServicePort(new IntOrString(80)).endBackend()
  .endPath()
  .endHttp()
  .endRule()
  .endSpec()
  .build();
client.network().v1().ingress().inNamespace("default").resource(ingress).create();

Ingress igx = client.network().v1().ingresses().inNamespace("default").resource(ingress).serverSideApply();

IngressList ingressList = client.network().v1().ingress().inNamespace("default").list();

IngressList ingressList = client.network().v1().ingress().inAnyNamespace().list();

IngressList ingressList = client.network().v1().ingress().inNamespace("default").withLabel("foo", "bar").list();

client.network().v1().ingress().inNamespace("default").withName("ingress1").delete();

StatefulSet aStatefulSet = client.apps().statefulSets()
  .load(new FileInputStream("test-statefulset.yml")).item();

StatefulSet ss1 = client.apps().statefulSets().inNamespace("default").withName("ss1").get();

StatefulSet ss1 = new StatefulSetBuilder()
      .withNewMetadata().withName("ss1").endMetadata()
      .withNewSpec()
      .withReplicas(2)
      .withNewSelector().withMatchLabels(Collections.singletonMap("app", "nginx")).endSelector()
      .withNewTemplate()
      .withNewMetadata()
      .addToLabels("app", "nginx")
      .endMetadata()
      .withNewSpec()
      .addNewContainer()
      .withName("nginx")
      .withImage("nginx")
      .addNewPort()
      .withContainerPort(80)
      .withName("web")
      .endPort()
      .addNewVolumeMount()
      .withName("www")
      .withMountPath("/usr/share/nginx/html")
      .endVolumeMount()
      .endContainer()
      .endSpec()
      .endTemplate()
      .addNewVolumeClaimTemplate()
      .withNewMetadata()
      .withName("www")
      .endMetadata()
      .withNewSpec()
      .addToAccessModes("ReadWriteOnce")
      .withNewResources()
      .withRequests(Collections.singletonMap("storage", new Quantity("1Gi")))
      .endResources()
      .endSpec()
      .endVolumeClaimTemplate()
      .endSpec()
      .build();

StatefulSet ss = client.apps().statefulSets().inNamespace("default").resource(ss1).create();

StatefulSet ss = client.apps().statefulSets().inNamespace("default").resource(ss1).serverSideApply();

StatefulSetList statefulSetList = client.apps().statefulSets().inNamespace("default").list();

StatefulSetList statefulSetList = client.apps().statefulSets().inAnyNamespace().list();

StatefulSetList statefulSetList = client.apps().statefulSets().inNamespace("default").withLabel("foo", "bar").list();

client.apps().statefulSets().inNamespace("default").withName("ss1").delete();

client.apps().statefulSets().inNamespace("default").withName("ss1").scale(2);

client.apps().statefulSets().inNamespace("default").withName("ss1").watch(new Watcher<>() {
  @Override
  public void eventReceived(Action action, StatefulSet resource) {
    // Do something on action type
  }

  @Override
  public void onClose(WatcherException cause) {

  }
})

StatefulSet statefulSet = client.apps().statefulSets()
      .inNamespace("default")
      .withName("web")
      .updateImage("nginx:1.19");

Map<String, String> containerToImageMap = new HashMap<>();
containerToImageMap("container1", "nginx:1.9");
containerToImageMap("container2", "busybox:latest");
Statefulset statefulSet = client.apps().statefulSets()
      .inNamespace("default")
      .withName("web")
      .updateImage(params);

StatefulSet ss = client.apps().statefulSets()
        .inNamespace("default")
        .withName("web")
        .rolling()
        .restart();

StatefulSet ss = client.apps().statefulSets()
         .inNamespace("default")
         .withName("web")
         .rolling()
         .pause();

StatefulSet ss = client.apps().statefulSets()
         .inNamespace("default")
         .withName("web")
         .rolling()
         .resume();

DaemonSet ds = client.apps().daemonSets().load(new FileInputStream("daemonset.yaml")).item();

DaemonSet ds = client.apps().daemonSets().inNamespace("default").withName("ds1").get();

DaemonSet ds = new DaemonSetBuilder()
  .withNewMetadata().withName("fluentd-elasticsearch").addToLabels("k8s-app", "fluentd-logging").endMetadata()
  .withNewSpec()
  .withNewSelector()
  .addToMatchLabels("name", "fluentd-elasticsearch")
  .endSelector()
  .withNewTemplate()
  .withNewSpec()
  .addNewToleration().withKey("node-role.kubernetes.io/master").withEffect("NoSchedule").endToleration()
  .addNewContainer()
  .withName("fluentd-elasticsearch").withImage("quay.io/fluentd_elasticsearch/fluentd:v2.5.2")
  .withNewResources()
  .addToLimits(Collections.singletonMap("memory", new Quantity("200Mi")))
  .addToRequests(Collections.singletonMap("cpu", new Quantity("100m")))
  .endResources()
  .addNewVolumeMount().withName("varlog").withMountPath("/var/log").endVolumeMount()
  .endContainer()
  .withTerminationGracePeriodSeconds(30l)
  .addNewVolume()
  .withName("varlog").withNewHostPath().withPath("/var/log").endHostPath()
  .endVolume()
  .endSpec()
  .endTemplate()
  .endSpec()
  .build();
ds = client.apps().daemonSets().inNamespace("default").resource(ds).create();

DaemonSet ds = client.apps().daemonSets().inNamespace("default").resource(ds1).serverSideApply();

DaemonSetList dsList = client.apps().daemonSets().inNamespace("default").list();

DaemonSetList dsList = client.apps().daemonSets().inAnyNamespace().list();

DaemonSetList dsList = client.apps().daemonSets().inNamespace("default").withLabel("foo", "bar").list();

client.apps().daemonSets().inNamespace("default").withName("ds1").delete();

client.apps().daemonSets().inNamespace("default").watch(new Watcher<>() {
  @Override
  public void eventReceived(Action action, DaemonSet resource) {
    // Do something depending upon action type
  }

  @Override
  public void onClose(WatcherException cause) {

  }
});

EndpointSlice es = client.discovery().v1().endpointSlices().load(getClass().getResourceAsStream("/endpointslice.yml")).item();

EndpointSlice esFromServer = client.discovery().v1().endpointSlices().inNamespace("default").withName("es1").get();

EndpointSlice esToCreate = new EndpointSliceBuilder()
  .withNewMetadata()
  .withName(name)
  .addToLabels("kubernetes.io/service-name", "example")
  .endMetadata()
  .withAddressType("IPv4")
  .addNewPort()
  .withName("http")
  .withPort(80)
  .endPort()
  .addNewEndpoint()
  .withAddresses("10.1.2.3")
  .withNewConditions().withReady(true).endConditions()
  .withHostname("pod-1")
  .addToTopology("kubernetes.io/hostname", "node-1")
  .addToTopology("topology.kubernetes.io/zone", "us-west2-a")
  .endEndpoint()
  .build();
esToCreate = client.discovery().v1().endpointSlices().inNamespace("ns1").resource(esToCreate).create();

EndpointSlice es = client.discovery().v1().endpointSlices().inNamespace("ns1").resource(endpointSlice).serverSideApply();

EndpointSliceList esList = client.discovery().v1().endpointSlices().inNamespace("default").list();

EndpointSliceList esList = client.discovery().v1().endpointSlices().inAnyNamespace().list();

EndpointSliceList esList = client.discovery().v1().endpointSlices().inNamespace("default").withLabel("foo", "bar").list();

client.discovery().v1().endpointSlices().inNamespace("default").withName("test-es").delete();

client.discovery().v1().endpointSlices().inNamespace("default").watch(new Watcher<>() {
  @Override
  public void eventReceived(Action action, EndpointSlice resource) {
    
  }

  @Override
  public void onClose(WatcherException cause) {

  }
});

PersistentVolumeClaim pvc = client.persistentVolumeClaims().load(new FileInputStream("pvc.yaml")).item();

PersistentVolumeClaim pvc = client.persistentVolumeClaims().inNamespace("default").withName("test-pv-claim").get();

PersistentVolumeClaim persistentVolumeClaim = new PersistentVolumeClaimBuilder()
  .withNewMetadata().withName("test-pv-claim").endMetadata()
  .withNewSpec()
  .withStorageClassName("my-local-storage")
  .withAccessModes("ReadWriteOnce")
  .withNewResources()
  .addToRequests("storage", new Quantity("500Gi"))
  .endResources()
  .endSpec()
  .build();

client.persistentVolumeClaims().inNamespace("default").resource(persistentVolumeClaim).item();

PersistentVolumeClaim pvc = client.persistentVolumeClaims().inNamespace("default").resource(pvcToCreate).serverSideApply();

PersistentVolumeClaimList pvcList = client.persistentVolumeClaims().inNamespace("default").list();

PersistentVolumeClaimList pvcList = client.persistentVolumeClaims().inAnyNamespace().list();

PersistentVolumeClaimList pvcList = client.persistentVolumeClaims().inNamespace("default").withLabel("foo", "bar").list();

client.persistentVolumeClaims().inNamespace("default").withName("test-pv-claim").delete();

PersistentVolume pv = client.persistentVolumes().load(new FileInputStream("pv.yaml")).item();

PersistentVolume pv = client.persistentVolumes().withName("test-local-pv").get();

PersistentVolume pv = new PersistentVolumeBuilder()
  .withNewMetadata().withName("test-local-pv").endMetadata()
  .withNewSpec()
  .addToCapacity(Collections.singletonMap("storage", new Quantity("500Gi")))
  .withAccessModes("ReadWriteOnce")
  .withPersistentVolumeReclaimPolicy("Retain")
  .withStorageClassName("my-local-storage")
  .withNewLocal()
  .withPath("/mnt/disks/vol1")
  .endLocal()
  .withNewNodeAffinity()
  .withNewRequired()
  .addNewNodeSelectorTerm()
  .withMatchExpressions(Arrays.asList(new NodeSelectorRequirementBuilder()
    .withKey("kubernetes.io/hostname")
    .withOperator("In")
    .withValues("my-node")
    .build()
  ))
  .endNodeSelectorTerm()
  .endRequired()
  .endNodeAffinity()
  .endSpec()
  .build();

PersistentVolume pvCreated = client.persistentVolumes().resource(pv).create();

PersistentVolume pv = client.persistentVolumes().resource(pvToCreate).serverSideApply();

PersistentVolumeList pvList = client.persistentVolumes().list();

PersistentVolumeList pvList = client.persistentVolumes().withLabel("foo", "bar").list();

client.persistentVolumes().withName("test-local-pv").delete();

NetworkPolicy loadedNetworkPolicy = client.network().networkPolicies()
  .load(new FileInputStream("/test-networkpolicy.yml")).item();

NetworkPolicy getNetworkPolicy = client.network().networkPolicies()
  .withName("networkpolicy").get();

NetworkPolicy networkPolicy = new NetworkPolicyBuilder()
      .withNewMetadata()
      .withName("networkpolicy")
      .addToLabels("foo","bar")
      .endMetadata()
      .withNewSpec()
      .withNewPodSelector()
      .addToMatchLabels("role","db")
      .endPodSelector()
      .addToIngress(0,
        new NetworkPolicyIngressRuleBuilder()
        .addToFrom(0, new NetworkPolicyPeerBuilder().withNewPodSelector()
          .addToMatchLabels("role","frontend").endPodSelector()
          .build()
        ).addToFrom(1, new NetworkPolicyPeerBuilder().withNewNamespaceSelector()
          .addToMatchLabels("project","myproject").endNamespaceSelector()
            .build()
        )
        .addToPorts(0,new NetworkPolicyPortBuilder().withPort(new IntOrString(6379))
          .withProtocol("TCP").build())
        .build()
      )
      .endSpec()
      .build();

NetworkPolicy npCreated = client.network().networkPolicies().resource(networkPolicy).create();

NetworkPolicy npCreated = client.network().networkPolicies().resource(networkPolicy).serverSideApply();

NetworkPolicyList networkPolicyList = client.network().networkPolicies().list();

NetworkPolicyList networkPolicyList = client.network().networkPolicies()
  .withLabels(Collections.singletonMap("foo","bar")).list();

client.network().networkPolicies().withName("np-test").delete();

PodDisruptionBudget pdb = client.policy().v1().podDisruptionBudget().load(new FileInputStream("/test-pdb.yml")).item();

PodDisruptionBudget podDisruptionBudget = client.policy().v1().podDisruptionBudget().inNamespace("default").withName("poddisruptionbudget1").get();

PodDisruptionBudget podDisruptionBudget = new PodDisruptionBudgetBuilder()
    .withNewMetadata().withName("zk-pkb").endMetadata()
    .withNewSpec()
    .withMaxUnavailable(new IntOrString("1%"))
    .withNewSelector()
    .withMatchLabels(Collections.singletonMap("app", "zookeeper"))
    .endSelector()
    .endSpec()
    .build();

client.policy().v1().podDisruptionBudget().inNamespace("default").resource(podDisruptionBudget).create();

PodDisruptionBudget pdb = client.policy().v1().podDisruptionBudget().inNamespace("default").resource(podDisruptionBudgetObj).serverSideApply();

PodDisruptionBudgetList podDisruptionBudgetList = client.policy().v1().podDisruptionBudget().inNamespace("default").list();

PodDisruptionBudgetList pdbList =client.policy().v1().podDisruptionBudget().inAnyNamespace().list();

PodDisruptionBudgetList pdbList = client.policy().v1().podDisruptionBudget().inNamespace("default").withLabel("foo", "bar").list();

client.policy().v1().podDisruptionBudget().inNamespace("default").withName("poddisruptionbudget1").delete();

try (KubernetesClient client = new KubernetesClientBuilder().build()) {
    SelfSubjectAccessReview ssar = new SelfSubjectAccessReviewBuilder()
            .withNewSpec()
            .withNewResourceAttributes()
            .withGroup("apps")
            .withResource("deployments")
            .withVerb("create")
            .withNamespace("dev")
            .endResourceAttributes()
            .endSpec()
            .build();

    ssar = client.authorization().v1().selfSubjectAccessReview().create(ssar);

    System.out.println("Allowed: "+  ssar.getStatus().getAllowed());
}

try (KubernetesClient client = new KubernetesClientBuilder().build()) {
    SubjectAccessReview sar = new SubjectAccessReviewBuilder()
            .withNewSpec()
            .withNewResourceAttributes()
            .withGroup("apps")
            .withResource("deployments")
            .withVerb("create")
            .withNamespace("default")
            .endResourceAttributes()
            .withUser("kubeadmin")
            .endSpec()
            .build();

    sar = client.authorization().v1().subjectAccessReview().create(sar);

    System.out.println("Allowed: "+  sar.getStatus().getAllowed());
}

try (KubernetesClient client = new KubernetesClientBuilder().build()) {
    LocalSubjectAccessReview lsar = new LocalSubjectAccessReviewBuilder()
            .withNewMetadata().withNamespace("default").endMetadata()
            .withNewSpec()
            .withUser("foo")
            .withNewResourceAttributes()
            .withNamespace("default")
            .withVerb("get")
            .withGroup("apps")
            .withResource("pods")
            .endResourceAttributes()
            .endSpec()
            .build();
     lsar = client.authorization().v1().localSubjectAccessReview().inNamespace("default").create(lsar);
     System.out.println(lsar.getStatus().getAllowed());
}

try (KubernetesClient client = new KubernetesClientBuilder().build()) {
    SelfSubjectRulesReview selfSubjectRulesReview = new SelfSubjectRulesReviewBuilder()
            .withNewMetadata().withName("foo").endMetadata()
            .withNewSpec()
            .withNamespace("default")
            .endSpec()
            .build();

    selfSubjectRulesReview = client.authorization().v1().selfSubjectRulesReview().create(selfSubjectRulesReview);
    System.out.println(selfSubjectRulesReview.getStatus().getIncomplete());
    System.out.println("non resource rules: " + selfSubjectRulesReview.getStatus().getNonResourceRules().size());
    System.out.println("resource rules: " + selfSubjectRulesReview.getStatus().getResourceRules().size());
}

ClusterRole clusterRole = client.rbac().clusterRoles().load(new FileInputStream("clusterroles-test.yml")).item();

ClusterRole clusterRole = client.rbac().clusterRoles().withName("clusterrole1").get();

ClusterRoleList clusterRoleList = client.rbac().clusterRoles().list();

ClusterRoleList clusterRoleList = client.rbac().clusterRoles().withLabel("key1", "value1").list();

client.rbac().clusterRoles().withName("clusterrole1").delete();

ClusterRoleBinding clusterRoleBinding = client.rbac().clusterRoleBindings().load(new FileInputStream("clusterrolebinding-test.yml")).item();

List<Subject> subjects = new ArrayList<>();
    Subject subject = new Subject();
    subject.setKind("ServiceAccount");
    subject.setName("serviceaccountname");
    subject.setNamespace("default");
    subjects.add(subject);
    RoleRef roleRef = new RoleRef();
    roleRef.setApiGroup("rbac.authorization.k8s.io");
    roleRef.setKind("ClusterRole");
    roleRef.setName("clusterrolename");
ClusterRoleBinding clusterRoleBindingCreated = new ClusterRoleBindingBuilder()
            .withNewMetadata().withName("clusterrolebindingname").withNamespace("default").endMetadata()
            .withRoleRef(roleRef)
            .addAllToSubjects(subjects)
            .build();
ClusterRoleBinding clusterRoleBinding = client.rbac().clusterRoleBindings().resource(clusterRoleBindingCreated).create();

ClusterRoleBinding clusterRoleBinding = client.rbac().clusterRoleBindings().withName("clusterrolebindingname").get();

ClusterRoleBindingList clusterRoleBindingList = client.rbac().clusterRoleBindings().list();

ClusterRoleBindingList clusterRoleBindingList = client.rbac().clusterRoleBindings().withLabel("key1", "value1").list();

client.rbac().clusterRoleBindings().withName("clusterrolebindingname").delete();

Role role = client.rbac().roles().load(new FileInputStream("role-test.yml")).item();

List<PolicyRule> policyRuleList = new ArrayList<>();
    PolicyRule endpoints = new PolicyRule();
    endpoints.setApiGroups(Arrays.asList(""));
    endpoints.setResources(Arrays.asList("endpoints"));
    endpoints.setVerbs(Arrays.asList("get", "list", "watch", "create", "update", "patch"));
    policyRuleList.add(endpoints);
Role roleCreated = new RoleBuilder()
            .withNewMetadata().withName("rolename").withNamespace("default").endMetadata()
            .addAllToRules(policyRuleList)
            .build();
Role role = client.rbac().roles().resource(roleCreated).create();

Role role = client.rbac().roles().inNamespace("default").withName("rolename").get();

RoleList roleList = client.rbac().roles().inNamespace("default").list();

RoleList roleList = client.rbac().roles().inNamespace("default").withLabel("key1", "value1").list();

client.rbac().roles().withName("rolename").delete();

RoleBinding roleBinding = client.rbac().roleBindings().load(new FileInputStream("rolebinding-test.yml")).item();

List<Subject> subjects = new ArrayList<>();
    Subject subject = new Subject();
    subject.setNamespace("default");
    subject.setKind("ServiceAccount");
    subject.setName("servicecccountname");
    subjects.add(subject);
    RoleRef roleRef = new RoleRef();
    roleRef.setName("rolename");
    roleRef.setKind("Role");
    roleRef.setApiGroup("rbac.authorization.k8s.io");
RoleBinding roleBindingToCreate = new RoleBindingBuilder()
            .withNewMetadata().withName("rolename").withNamespace("default").endMetadata()
            .addAllToSubjects(subjects)
            .withRoleRef(roleRef)
            .build();
RoleBinding roleBinding = client.rbac().roleBindings().resource(roleBindingToCreate).create();

RoleBinding roleBinding = client.rbac().roleBindings().inNamespace("default").withName("rolename").get();

RoleBindingList roleBindingList = client.rbac().roleBindings().inNamespace("default").list();

RoleBindingList roleBindingList = client.rbac().roleBindings().inNamespace("default").withLabel("key1", "value1").list();

client.rbac().roleBindings().inNamespace("default").withName("rolename").delete();

NodeMetricsList nodeMetricList = client.top().nodes().metrics();

NodeMetrics nodeMetric = client.top().nodes().withName("minikube").metric();

PodMetricsList podMetricsList = client.top().pods().metrics();

PodMetricsList podMetricsList = client.top().pods().inNamespace("default").metrics();

PodMetrics podMetrics = client.top().pods().metrics("default", "nginx-pod");

Pod pod1 = new PodBuilder()
  .withNewMetadata().withName("resource-pod-" + RandomStringUtils.randomAlphanumeric(6).toLowerCase(Locale.ROOT)).endMetadata()
  .withNewSpec()
  .addNewContainer().withName("nginx").withImage("nginx").endContainer()
  .endSpec()
  .build();

client.resource(pod1).inNamespace("default").serverSideApply();

pod1 = client.resource(pod1).serverSideApply();
Pod p = client.pods().resource(pod1).waitUntilReady(10, TimeUnit.SECONDS);

client.resource(pod1).inNamespace("default").delete();

Service service =  new ServiceBuilder()
  .withNewMetadata().withName("my-service").endMetadata()
  .withNewSpec()
  .addToSelector("app", "Myapp")
  .addNewPort().withProtocol("TCP").withPort(80).withTargetPort(new IntOrString(9376)).endPort()
  .endSpec()
  .build();


ConfigMap configMap = new ConfigMapBuilder()
  .withNewMetadata().withName("my-configmap").endMetadata()
  .addToData(Collections.singletonMap("app", "Myapp"))
  .build();

KubernetesList list = new KubernetesListBuilder().withItems(deployment, service, configMap).build();

// Apply
client.resourceList(list).inNamespace("default").serverSideApply();

client.resourceList(new PodListBuilder().withItems(pod1, pod2, pod3).build()).inNamespace("default").delete();

CustomResourceDefinition customResourceDefinition = client.apiextensions().v1().customResourceDefinitions().load(new FileInputStream("/sparkapplication-crd.yml")).item();

CustomResourceDefinition crd = client.apiextensions().v1().customResourceDefinitions().withName("sparkclusters.radanalytics.io").get();

CustomResourceDefinition customResourceDefinition = new CustomResourceDefinitionBuilder()
      .withApiVersion("apiextensions.k8s.io/v1")
      .withNewMetadata().withName("sparkclusters.radanalytics.io")
      .endMetadata()
      .withNewSpec()
      .withNewNames()
      .withKind("SparkCluster")
      .withPlural("sparkclusters")
      .endNames()
      .withGroup("radanalytics.io")
      .withVersion("v1")
      .withScope("Namespaced")
      .withNewValidation()
      .withNewOpenAPIV3SchemaLike(readSchema())
      .endOpenAPIV3Schema()
      .endValidation()
      .endSpec()
      .build();

CustomResourceDefinition crd = client.apiextensions().v1().customResourceDefinitions().resource(customResourceDefinition).create();

CustomResourceDefinition crd = client.apiextensions().v1().customResourceDefinitions().resource(customResourceDefinition).serverSideApply();

CustomResourceDefinitionList crdList = client.apiextensions().v1().customResourceDefinitions().list();

client.apiextensions().v1().customResourceDefinitions().withName("sparkclusters.radanalytics.io").delete();

package io.fabric8.kubernetes.client.mock.crd;

import io.fabric8.kubernetes.api.model.Namespaced;
import io.fabric8.kubernetes.client.CustomResource;
import io.fabric8.kubernetes.model.annotation.Group;
import io.fabric8.kubernetes.model.annotation.Version;

@Version("v1")
@Group("stable.example.com")
public class CronTab extends CustomResource<CronTabSpec, CronTabStatus> implements Namespaced {
}

MixedOperation<CronTab, KubernetesResourceList<CronTab>, Resource<CronTab>> cronTabClient = client.resources(CronTab.class);

CronTab ct = cronTabClient.inNamespace("default").withName("my-second-cron-object").get();

cronTabClient.inNamespace("default").create(cronTab1);

CronTabList cronTabList = cronTabClient.inNamespace("default").list();

cronTabClient.inNamespace("default").withName("my-third-cron-object").delete();

cronTabClient.inNamespace("default").resource(updatedCronTab).updateStatus();

// does not require a full instance of the updatedCronTab, will produce a json merge patch based upon what is set in updatedCronTab
cronTabClient.inNamespace("default").resource(updatedCronTab).patchStatus();

// generates a json patch between the passed in cronTab and the updated result.  Typically you will use a builder to construct a copy from the current and make modifications
cronTabClient.inNamespace("default").resource(cronTab1).editStatus(cronTab->updatedCronTab);

cronTabClient.inNamespace("default").watch(new Watcher<>() {
   @Override
   public void eventReceived(Action action, CronTab resource) {
        
   }

   @Override
   public void onClose(WatcherException cause) {

   }
});

ResourceDefinitionContext resourceDefinitionContext = new ResourceDefinitionContext.Builder()
      .withGroup("jungle.example.com")
      .withVersion("v1")
      .withPlural("animals")
      .withNamespaced(true)
      .build();

GenericKubernetesResource customResource = client.genericKubernetesResources(context).load(new FileInputStream("cr.yaml")).item();

GenericKubernetesResource customResourceObject = client.genericKubernetesResources(resourceDefinitionContext).inNamespace(currentNamespace).withName("otter").get();

// Create via file
GenericKubernetesResource object = client.genericKubernetesResources(resourceDefinitionContext).inNamespace(currentNamespace).load(new FileInputStream("test-rawcustomresource.yml")).create();

// Create via raw JSON string

String rawJsonCustomResourceObj = "{\"apiVersion\":\"jungle.example.com/v1\"," +
  "\"kind\":\"Animal\",\"metadata\": {\"name\": \"walrus\"}," +
  "\"spec\": {\"image\": \"my-awesome-walrus-image\"}}";
GenericKubernetesResource object = client.genericKubernetesResources(resourceDefinitionContext).inNamespace(currentNamespace).load(rawJsonCustomResourceObj).create();

GenericKubernetesResourceList list = client.genericKubernetesResources(resourceDefinitionContext).inNamespace(currentNamespace).list();

GenericKubernetesResourceList list = client.genericKubernetesResources(resourceDefinitionContext).inNamespace(currentNamespace).withLabels(Collections.singletonMap("foo", "bar")).list();

GenericKubernetesResource walrus = client.genericKubernetesResources(resourceDefinitionContext).inNamespace(currentNamespace).withName("walrus").get();
Map<String, Object> spec = (Map<String, Object>) walrus.getAdditionalProperties().get("spec");
spec.put("image", "my-updated-awesome-walrus-image");
walrus.getAdditionalProperties().put("spec", spec);
client.genericKubernetesResources(resourceDefinitionContext).inNamespace(currentNamespace).resource(walrus).update()

client.genericKubernetesResources(resourceDefinitionContext).inNamespace(currentNamespace).withName("otter").delete();

GenericKubernetesResource result = client.genericKubernetesResources(resourceDefinitionContext).inNamespace("ns1").resource(objectAsGenericKubernetesResource).updateStatus();

final CountDownLatch closeLatch = new CountDownLatch(1);
client.genericKubernetesResources(crdContext).inNamespace(namespace).watch(new Watcher<>() {
    @Override
    public void eventReceived(Action action, GenericKubernetesResource resource) {
        logger.info("{}: {}", action, resource);
    }

    @Override
    public void onClose(WatcherException e) {
        logger.debug("Watcher onClose");
        closeLatch.countDown();
        if (e != null) {
            logger.error(e.getMessage(), e);
        }
    }
});
closeLatch.await(10, TimeUnit.MINUTES);

    CertificateSigningRequestCondition csrCondition = new CertificateSigningRequestConditionBuilder()
            .withType("Approved")
            .withStatus("True")
            .withReason("Approved ViaRESTApi")
            .withMessage("Approved by REST API /approval endpoint.")
            .build();
    client.certificates().v1().certificateSigningRequests().withName("test-k8s-csr").approve(csrCondition);

    CertificateSigningRequestCondition csrCondition = new CertificateSigningRequestConditionBuilder()
            .withType("Denied")
            .withStatus("True")
            .withReason("Denied ViaRESTApi")
            .withMessage("Denied by REST API /approval endpoint.")
            .build();
  client.certificates().v1().certificateSigningRequests().withName("test-k8s-csr").deny(csrCondition);

SharedInformerFactory sharedInformerFactory = client.informers();

SharedIndexInformer<Pod> podInformer = sharedInformerFactory.sharedIndexInformerFor(Pod.class, 30 * 1000L);
podInformer.addEventHandler(new ResourceEventHandler<Pod>() {
  @Override
  public void onAdd(Pod pod) {
    logger.info("{} pod added", pod.getMetadata().getName());
  }

  @Override
  public void onUpdate(Pod oldPod, Pod newPod) {
    logger.info("{} pod updated", oldPod.getMetadata().getName());
  }

  @Override
  public void onDelete(Pod pod, boolean deletedFinalStateUnknown) {
    logger.info("{} pod deleted", pod.getMetadata().getName());
  }
});

SharedIndexInformer<Dummy> dummyInformer = sharedInformerFactory.sharedIndexInformerFor(Dummy.class, 60 * 1000L);
dummyInformer.addEventHandler(new ResourceEventHandler<Dummy>() {
  @Override
  public void onAdd(Dummy dummy) {
    System.out.printf("%s dummy added\n", dummy.getMetadata().getName());
  }

  @Override
  public void onUpdate(Dummy oldDummy, Dummy newDummy) {
    System.out.printf("%s dummy updated\n", oldDummy.getMetadata().getName());
  }

  @Override
  public void onDelete(Dummy dummy, boolean deletedFinalStateUnknown) {
    System.out.printf("%s dummy deleted \n", dummy.getMetadata().getName());
  }
});

sharedInformerFactory.startAllRegisteredInformers();

sharedInformerFactory.stopAllRegisteredInformers();

SharedIndexInformer<Pod> podInformer = client.pods().inNamespace("default").inform(new ResourceEventHandler<>() {
    @Override
    public void onAdd(Pod pod) {
        logger.info("Pod " + pod.getMetadata().getName() + " got added");
    }

    @Override
    public void onUpdate(Pod oldPod, Pod newPod) {
        logger.info("Pod " + oldPod.getMetadata().getName() + " got updated");
    }

    @Override
    public void onDelete(Pod pod, boolean deletedFinalStateUnknown) {
        logger.info("Pod " + pod.getMetadata().getName() + " got deleted");
    }
},  30 * 1000L);

logger.info("Informer initialized.");

import io.fabric8.kubernetes.api.model.KubernetesResource;
import io.fabric8.kubernetes.api.model.Namespaced;
import io.fabric8.kubernetes.client.CustomResource;
import io.fabric8.kubernetes.model.annotation.Group;
import io.fabric8.kubernetes.model.annotation.Version;
import io.fabric8.kubernetes.model.annotation.Plural;

@Version("demo.fabric8.io")
@Group("v1")
public class Dummy extends CustomResource<DummySpec, KubernetesResource> implements Namespaced { }

SharedIndexInformer<Dummy> dummyInformer = client.resources(Dummy.class).inNamespace("default").inform(new ResourceEventHandler<>() {
    @Override
    public void onAdd(Dummy dummy) {
        System.out.printf("%s dummy added\n", dummy.getMetadata().getName());
    }

    @Override
    public void onUpdate(Dummy oldDummy, Dummy newDummy) {
        System.out.printf("%s dummy updated\n", oldDummy.getMetadata().getName());
    }

    @Override
    public void onDelete(Dummy dummy, boolean deletedFinalStateUnknown) {
        System.out.printf("%s dummy deleted \n", dummy.getMetadata().getName());
    }
},  60 * 1000L);

PodList podList = client.pods().inNamespace("myproject").list(new ListOptionsBuilder().withLimit(5L).build());

podList = client.pods().inNamespace("myproject").list(new ListOptionsBuilder().withLimit(5L)
		.withContinue(podList.getMetadata().getContinue())
		.build());

client.apps().deployments().inNamespace("default").withName("nginx-deploy").cascading(true).delete();

client.apps().deployments().inNamespace("default").withName("nginx-deploy").withPropagationPolicy(DeletionPropagation.FOREGROUND).delete();

client.apps().deployments().inNamespace("ns1").withName("mydeployment").withPropagationPolicy(DeletionPropagation.FOREGROUND).withGracePeriod(10).delete();

client.pods().inNamespace(namespace).watch(new Watcher<>() {
    @Override
    public void eventReceived(Action action, Pod pod) {
        logger.log(Level.INFO, action.name() + " " + pod.getMetadata().getName());
        switch (action.name()) {
            case "ADDED":
                logger.log(Level.INFO, pod.getMetadata().getName() + "got added");
                break;
            case "DELETED":
                logger.log(Level.INFO, pod.getMetadata().getName() + "got deleted");
                break;
            case "MODIFIED":
                logger.log(Level.INFO, pod.getMetadata().getName() + "got modified");
                break;
            default:
                logger.log(Level.SEVERE, "Unrecognized event: " + action.name());
        }
    }

    @Override
    public void onClose(WatcherException e) {
        logger.log(Level.INFO, "Closed");
        isWatchClosed.countDown();
    }
});

// Wait till watch gets closed
isWatchClosed.await();

String resourceVersion = "20012";
client.pods().inNamespace(namespace).watch(resourceVersion, new Watcher<>() {
    @Override
    public void eventReceived(Action action, Pod pod) {
        logger.log(Level.INFO, action.name() + " " + pod.getMetadata().getName());
        switch (action.name()) {
            case "ADDED":
                logger.log(Level.INFO, pod.getMetadata().getName() + "got added");
                break;
            case "DELETED":
                logger.log(Level.INFO, pod.getMetadata().getName() + "got deleted");
                break;
            case "MODIFIED":
                logger.log(Level.INFO, pod.getMetadata().getName() + "got modified");
                break;
            default:
                logger.log(Level.SEVERE, "Unrecognized event: " + action.name());
        }
    }

    @Override
    public void onClose(WatcherException e) {
        logger.log(Level.INFO, "Closed");
        isWatchClosed.countDown();
    }
});

// Wait till watch gets closed
isWatchClosed.await();

client.pods().watch(new ListOptionsBuilder().withTimeoutSeconds(30L).build(), new Watcher<>() {
  @Override
  public void eventReceived(Action action, Pod resource) { }

  @Override
  public void onClose(WatcherException cause) { }
});

client.pods().inNamespace("test").withName("foo").withPrettyOutput().getLog();

client.pods().inNamespace("test").withName("foo").inContainer("container1").getLog();

client.pods().inNamespace("test").withName("foo").terminated().getLog();

client.pods().inNamespace("test").withName("foo").sinceTime("2020-09-10T12:53:30.154148788Z").getLog();

client.pods().inNamespace("test").withName("foo").sinceSeconds(10).getLog();

client.pods().inNamespace("test").withName("foo").tailingLines(10).getLog();

client.pods().inNamespace("test").withName("foo").limitBytes(102).getLog();

client.pods().inNamespace("test").withName("foo").usingTimestamps().getLog();

Pod myPod;

String myPodAsYaml = Serialization.asYaml(myPod);

try (KubernetesClient client = new KubernetesClientBuilder().build()) {
    client.run().inNamespace("default")
            .withName("hazelcast")
            .withImage("hazelcast/hazelcast:3.12.9")
            .done();
}

try (KubernetesClient client = new KubernetesClientBuilder().build()) {
    client.run().inNamespace("default")
					.withNewRunConfig()
					.withName("nginx")
					.withImage("nginx:latest")
					.withLabels(Collections.singletonMap("foo", "bar"))
					.withEnv(Collections.singletonMap("KUBERNETES_TEST", "fabric8"))
					.done();}

client.services().withName("name").patch(PatchContext.of(PatchType.SERVER_SIDE_APPLY), service);

client.services().withName("name").patch(new PatchContext.Builder().withPatchType(PatchType.SERVER_SIDE_APPLY).withForce(true).build(), service);

try (final OpenShiftClient client = new KubernetesClientBuilder().build().adapt(OpenShiftClient.class)) {
  // Do stuff with client
}

Config kubeConfig = new ConfigBuilder()
            .withMasterUrl("https://api.ci-ln-3sbdl1b-d5d6b.origin-ci-int-aws.dev.examplecloud.com:6443")
            .withOauthToken("xxxxxxxx-41oafKI6iU637-xxxxxxxxxxxxx")
            .build())) {
try (final OpenShiftClient client = new KubernetesClientBuilder().withConfig(kubeConfig).build().adapt(OpenShiftClient.class)) {
  // Do stuff with client
}

DeploymentConfig deploymentConfig = client.deploymentConfigs().inNamespace(currentNamespace)
  .load(new FileInputStream("test-deploymentconfig.yml")).item();

DeploymentConfig dc = client.deploymentConfigs().inNamespace(currentNamespace).withName("deploymentconfig1").get();

DeploymentConfig dc = new DeploymentConfigBuilder()
      .withNewMetadata().withName("deploymentconfig1").endMetadata()
      .withNewSpec()
      .withReplicas(2)
      .withNewTemplate()
      .withNewMetadata()
      .addToLabels("app", "database")
      .endMetadata()
      .withNewSpec()
      .addNewContainer()
      .withName("mysql")
      .withImage("openshift/mysql-55-centos7")
      .endContainer()
      .endSpec()
      .endTemplate()
      .endSpec()
      .build();

DeploymentConfig dcCreated = client.deploymentConfigs().inNamespace("default").resource(dc).create();

DeploymentConfig dc = client.deploymentConfigs().inNamespace("default").resource(dcToCreate).serverSideApply();

DeploymentConfigList aDeploymentConfigList = client.deploymentConfigs().inNamespace("default").list();

DeploymentConfigList dcList = client.deploymentConfigs().inAnyNamespace().list();

DeploymentConfigList dcList = client.deploymentConfigs().inNamespace("default").withLabel("foo", "bar").list();

DeploymentConfig deploymentConfig1 = client.deploymentConfigs().inNamespace(currentNamespace).withName("deploymentconfig1").edit(
  dc -> new DeploymentConfigBuilder(dc).editSpec().withReplicas(3).endSpec().build()
);

client.deploymentConfigs().inNamespace("default").withName("deploymentconfig1").delete();

client.deploymentConfigs().inNamespace("default").watch(new Watcher<>() {
  @Override
  public void eventReceived(Action action, DeploymentConfig resource) {
    // Do something depending upon action    
  }

  @Override
  public void onClose(WatcherException cause) {

  }
});

BuildConfig aBuildConfig = client.buildConfigs().inNamespace(currentNamespace)
  .load(new FileInputStream("/test-buildconfig.yml")).item();

BuildConfig bc = client.buildConfigs().inNamespace(currentNamespace).withName("bc1").get();

BuildConfig buildConfig1 = new BuildConfigBuilder()
  .withNewMetadata().withName("bc1").endMetadata()
  .withNewSpec()
  .addNewTrigger()
  .withType("GitHub")
  .withNewGithub()
  .withSecret("secret101")
  .endGithub()
  .endTrigger()
  .addNewTrigger()
  .withType("Generic")
  .withNewGeneric()
  .withSecret("secret101")
  .endGeneric()
  .endTrigger()
  .addNewTrigger()
  .withType("ImageChange")
  .endTrigger()
  .withNewSource()
  .withType("Git")
  .withNewGit()
  .withUri("https://github.com/openshift/ruby-hello-world")
  .endGit()
  .withDockerfile("FROM openshift/ruby-22-centos7\\nUSER example")
  .endSource()
  .withNewStrategy()
  .withType("Source")
  .withNewSourceStrategy()
  .withNewFrom()
  .withKind("ImageStreamTag")
  .withName("origin-ruby-sample:latest")
  .endFrom()
  .endSourceStrategy()
  .endStrategy()
  .withNewOutput()
  .withNewTo()
  .withKind("ImageStreamTag")
  .withName("origin-ruby-sample:latest")
  .endTo()
  .endOutput()
  .withNewPostCommit()
  .withScript("bundle exec rake test")
  .endPostCommit()
  .endSpec()
  .build();

client.buildConfigs().inNamespace("default").resource(buildConfig1).create();

BuildConfigList bcList = client.buildConfigs().inNamespace("default").list();

BuildConfigList bcList = client.buildConfigs().inNamespace("default").list();

BuildConfigList bcList = client.buildConfigs().inNamespace("default").withLabel("foo", "bar").list();

client.buildConfigs().inNamespace("default").withName("bc1").delete();

client.buildConfigs().inNamespace("default").watch(new Watcher<>() {
  @Override
  public void eventReceived(Action action, BuildConfig resource) {
    // Do something depending upon action type    
  }

  @Override
  public void onClose(WatcherException cause) {

  }
});

Route aRoute = client.routes().inNamespace("default").load(new FileInputStream("test-route.yml")).item();

Route route1 = client.routes().inNamespace("default").withName("route1").get();

Route route1 = new RouteBuilder()
      .withNewMetadata().withName("route1").endMetadata()
      .withNewSpec().withHost("www.example.com").withNewTo().withKind("Service").withName("service-name1").endTo().endSpec()
      .build();

client.routes().inNamespace("defalt").resource(route1).create();

Route route = client.routes().inNamespace("default").resource(route1).serverSideApply();

RouteList aRouteList = client.routes().inNamespace("default").list();

RouteList aRouteList = client.routes().inAnyNamespace().list();

RouteList routeList = client.routes().inNamespace("default").withLabel("foo", "bar").list();

client.routes().inNamespace("default").withName("route1").delete();

Project myProject = client.projects().withName("default").get();

ProjectRequest request = client.projectrequests().create(
  new ProjectRequestBuilder().withNewMetadata().withName("thisisatest").endMetadata()
  .withDescription("Fabric8").withDisplayName("Fabric8).build()
);

ProjectList projectList = client.projects().list();

client.projects().withName("default").delete();

ImageStream aImageStream = client.imageStreams()
  .load(new FileInputStream("test-imagestream.yml")).item();

ImageStream is =client.imageStreams().inNamespace("default").withName("example-camel-cdi").get();

ImageStream imageStream1 = new ImageStreamBuilder()
      .withNewMetadata()
      .withName("example-camel-cdi")
      .endMetadata()
      .withNewSpec()
      .addNewTag()
      .withName("latest")
      .endTag()
      .withDockerImageRepository("fabric8/example-camel-cdi")
      .endSpec()
      .withNewStatus().withDockerImageRepository("").endStatus()
      .build();

client.imageStreams().inNamespace("default").resource(imageStream1).create();

ImageStream is = client.imageStreams().inNamespace("default").resource(imageStream1).create();

ImageStreamList aImageStreamList = client.imageStreams().inNamespace("default").list();

ImageStreamList isList = client.imageStreams().inAnyNamespace().list();

ImageStreamList isList = client.imageStreams().inNamespace("default").withLabel("foo", "bar").list();

client.imageStreams().inNamespace("default").withName("example-camel-cdi").delete();

CatalogSource cs = client.operatorHub().catalogSources()
  .load(new FileInputStream("/test-catalogsource.yml").item();

CatalogSource cs = new CatalogSourceBuilder()
  .withNewMetadata().withName("foo").endMetadata()
  .withNewSpec()
  .withSourceType("Foo")
  .withImage("nginx:latest")
  .withDisplayName("Foo Bar")
  .withPublisher("Fabric8")
  .endSpec()
  .build();
client.operatorHub().catalogSources().inNamespace("default").resource(cs).create();

CatalogSourceList csList = client.operatorHub().catalogSources().inNamespace("ns1").list();

CatalogSourceList csList = client.operatorHub().catalogSources().inAnyNamespace().list();

CatalogSourceList csList = client.operatorHub().catalogSources().inNamespace("default").withLabel("foo", "bar").list();

client.operatorHub().catalogSources().inNamespace("default").withName("foo").delete();

PrometheusRule prometheusRule = client.monitoring().prometheusRules()
  .load(new FileInputStream("/test-prometheusrule.yml").item();

PrometheusRule prometheusRule = new PrometheusRuleBuilder()
    .withNewMetadata().withName("foo").endMetadata()
    .withNewSpec()
    .addNewGroup()
    .withName("./example-rules")
    .addNewRule()
    .withAlert("ExampleAlert")
    .withNewExpr().withStrVal("vector(1)").endExpr()
    .endRule()
    .endGroup()
    .endSpec()
    .build();
client.monitoring().prometheusRules().inNamespace("default").resource(prometheusRule).create();

PrometheusRuleList prList = client.monitoring().prometheusRules().inNamespace("ns1").list();

PrometheusRuleList prList = client.monitoring().prometheusRules().inAnyNamespace().list();

PrometheusRuleList prList = client.monitoring().prometheusRules().inNamespace("default").withLabel("foo", "bar").list();

client.monitoring().prometheusRules().inNamespace("default").withName("foo").delete();

ServiceMonitor serviceMonitor = client.monitoring().serviceMonitors()
  .load(new FileInputStream("/test-servicemonitor.yml").item();

ServiceMonitor serviceMonitor = new ServiceMonitorBuilder()
    .withNewMetadata()
    .withName("foo")
    .addToLabels("prometheus", "frontend")
    .endMetadata()
    .withNewSpec()
    .withNewNamespaceSelector().withAny(true).endNamespaceSelector()
    .withNewSelector()
    .addToMatchLabels("prometheus", "frontend")
    .endSelector()
    .addNewEndpoint()
    .withPort("http-metric")
    .withInterval("15s")
    .endEndpoint()
    .endSpec()
    .build();

client.monitoring().serviceMonitors().inNamespace("default").resource(serviceMonitor).create();

ServiceMonitorList serviceMonitorList = client.monitoring().serviceMonitors().inNamespace("ns1").list();

ServiceMonitorList serviceMonitorList = client.monitoring().serviceMonitors().inAnyNamespace().list();

ServiceMonitorList serviceMonitorList = client.monitoring().catalogSources().inNamespace("default").withLabel("foo", "bar").list();

client.operatorHub().monitoring().inNamespace("default").withName("foo").delete();

try (OpenShiftClient client = new KubernetesClientBuilder().build().adapt(OpenShiftClient.class)) {
    Map<String, Quantity> hard = new HashMap<>();
    hard.put("pods", new Quantity("10"));
    hard.put("secrets", new Quantity("20"));
    ClusterResourceQuota acrq = new ClusterResourceQuotaBuilder()
            .withNewMetadata().withName("foo").endMetadata()
            .withNewSpec()
            .withNewSelector()
            .addToAnnotations("openshift.io/requester", "foo-user")
            .endSelector()
            .withQuota(new ResourceQuotaSpecBuilder()
                    .withHard(hard)
                    .build())
            .endSpec()
            .build();

    client.quotas().clusterResourceQuotas().resource(acrq).create();
}