`DefaultOpenShiftClient` implementa tanto la interfaz `KubernetesClient` como la `OpenShiftClient`, así que si necesitas las
extensiones de OpenShift, como `Build`s, etc., entonces simplemente haz:```java
OpenShiftClient osClient = new DefaultOpenShiftClient();

El uso del DSL es el mismo para todos los recursos.

Listar recursos:```java
NamespaceList myNs = client.namespaces().list();

ServiceList myServices = client.services().list();

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

Eliminar:```java
Namespace myns = client.namespaces().withName("myns").delete();

Service myservice = client.services().inNamespace("default").withName("myservice").delete();

Con el mismo espíritu, puedes incorporar builders en línea para crear:```java
Namespace myns = client.namespaces().create(new NamespaceBuilder()
                   .withNewMetadata()
                     .withName("myns")
                     .addToLabels("a", "label")
                   .endMetadata()
                   .build());

Service myservice = client.services().inNamespace("default").create(new ServiceBuilder()
                     .withNewMetadata()
                       .withName("myservice")
                       .addToLabels("another", "label")
                     .endMetadata()
                     .build());

### Siguiendo eventos

Usa `io.fabric8.kubernetes.api.model.Event` como T para Watcher:```java
client.events().inAnyNamespace().watch(new Watcher<Event>() {

  @Override
  public void eventReceived(Action action, Event resource) {
    System.out.println("event " + action.name() + " " + resource.toString());
  }

  @Override
  public void onClose(KubernetesClientException cause) {
    System.out.println("Watcher close due to " + cause);
  }

});

### Cargando recursos desde fuentes externas

Hay casos en los que quieres leer un recurso desde una fuente externa, en lugar de definirlo usando el DSL de los clientes.
Para esos casos, el cliente te permite cargar el recurso desde:

- Un archivo *(Soporta tanto java.io.File como java.lang.String)*
- Una URL
- Un flujo de entrada

Una vez que el recurso está cargado, puedes tratarlo como lo harías si lo hubieras creado tú mismo.

Por ejemplo, leamos un pod desde un archivo yml y trabajemos con él:

    Pod refreshed = client.load('/path/to/a/pod.yml').fromServer().get();
    Boolean deleted = client.load('/workspace/pod.yml').delete();
    LogWatch handle = client.load('/workspace/pod.yml').watchLog(System.out);

### Pasando una referencia de un recurso al cliente

En el mismo sentido, puedes usar un objeto creado externamente (ya sea una referencia o usando su representación como cadena).

Por ejemplo:

    Pod pod = someThirdPartyCodeThatCreatesAPod();
    Boolean deleted = client.resource(pod).delete();

### Adaptando el cliente

El cliente admite adaptadores conectables. Un ejemplo de adaptador es el [Adaptador OpenShift](https://github.com/shoucheng3/fabric8io__kubernetes-client_cve-2021-4178_5-0-2/blob/HEAD/openshift-client/src/main/java/io/fabric8/openshift/client/OpenShiftExtensionAdapter.java)
que permite adaptar una instancia existente de [KubernetesClient](https://github.com/shoucheng3/fabric8io__kubernetes-client_cve-2021-4178_5-0-2/blob/HEAD/kubernetes-client/src/main/java/io/fabric8/kubernetes/client/KubernetesClient.java) a una de [OpenShiftClient](https://github.com/shoucheng3/fabric8io__kubernetes-client_cve-2021-4178_5-0-2/blob/HEAD/openshift-client/src/main/java/io/fabric8/openshift/client/OpenShiftClient.java).

 Por ejemplo:```java
KubernetesClient client = new DefaultKubernetesClient();

OpenShiftClient oClient = client.adapt(OpenShiftClient.class);

#### Adaptación y cierre
Ten en cuenta que al usar adapt(), tanto el adaptado como el destino compartirán los mismos recursos (cliente http subyacente, grupos de hilos, etc.).
Esto significa que no es necesario utilizar close() en cada instancia creada mediante adapt().
Llamar a close() en cualquiera de las instancias gestionadas por adapt(), o en la instancia original, limpiará correctamente todos los recursos y, por lo tanto, ninguna de las instancias podrá seguir utilizándose.


## Simulación de Kubernetes

Además del cliente, este proyecto también proporciona un servidor mock de Kubernetes que puedes usar con fines de prueba.
El servidor mock está basado en `https://github.com/square/okhttp/tree/master/mockwebserver` pero está potenciado por el DSL y las funcionalidades proporcionadas por `https://github.com/fabric8io/mockwebserver`.

El Mock Web Server tiene dos modos de funcionamiento:

- Modo de expectativas
- Modo CRUD

### Modo de expectativas

Es el modo típico en el que primero se establecen cuáles son las peticiones http esperadas y cuáles deben ser las respuestas para cada petición.
Se pueden encontrar más detalles de uso en: https://github.com/fabric8io/mockwebserver

Este modo se ha utilizado ampliamente para probar el propio cliente. Asegúrate de revisar [kubernetes-test](https://github.com/shoucheng3/fabric8io__kubernetes-client_cve-2021-4178_5-0-2/blob/HEAD/kubernetes-tests/src/test/java/io/fabric8/kubernetes/client/mock).

Para añadir un servidor de Kubernetes a tu prueba:```java
@Rule
public KubernetesServer server = new KubernetesServer();

Entonces puedes usar el servidor así:```java
@Test
public void testInCrudMode() {
    KubernetesClient client = server.getClient();
    final CountDownLatch deleteLatch = new CountDownLatch(1);
    final CountDownLatch closeLatch = new CountDownLatch(1);

    //CREATE
    client.pods().inNamespace("ns1").create(new PodBuilder().withNewMetadata().withName("pod1").endMetadata().build());

    //READ
    podList = client.pods().inNamespace("ns1").list();
    assertNotNull(podList);
    assertEquals(1, podList.getItems().size());

    //WATCH
    Watch watch = client.pods().inNamespace("ns1").withName("pod1").watch(new Watcher<Pod>() {
        @Override
        public void eventReceived(Action action, Pod resource) {
            switch (action) {
                case DELETED:
                    deleteLatch.countDown();
                    break;
                default:
                    throw new AssertionFailedError(action.toString().concat(" isn't recognised."));
            }
        }

        @Override
        public void onClose(KubernetesClientException cause) {
            closeLatch.countDown();
        }
    });

    //DELETE
    client.pods().inNamespace("ns1").withName("pod1").delete();

    //READ AGAIN
    podList = client.pods().inNamespace("ns1").list();
    assertNotNull(podList);
    assertEquals(0, podList.getItems().size());

    assertTrue(deleteLatch.await(1, TimeUnit.MINUTES));
    watch.close();
    assertTrue(closeLatch.await(1, TimeUnit.MINUTES));
}

KubernetesClient client;

@Test
public void testInStandardMode() {
        ...
}

En caso de que desees definir una instancia estática del servidor simulado para todas las pruebas (JUnit4 `@ClassRule`), necesitas declarar la instancia de `KubernetesClient` como se muestra a continuación.
También puedes habilitar crudMode mediante el campo de anotación `crud`.```java
@EnableKubernetesMockClient(crud = true)
class ExampleTest {

    static KubernetesClient client;

    @Test
    public void testInCrudMode() {
            ...
    }
}