`DefaultOpenShiftClient` implémente à la fois les interfaces `KubernetesClient` et `OpenShiftClient`, donc si vous avez besoin des
extensions OpenShift, telles que les `Build`s, etc., faites simplement :```java
OpenShiftClient osClient = new DefaultOpenShiftClient();

L'utilisation du DSL est la même pour toutes les ressources.

Lister les ressources :```java
NamespaceList myNs = client.namespaces().list();

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

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

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

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

Dans le même esprit, vous pouvez rendre les builders inline pour créer :```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());

### Suivi des événements

Utilisez `io.fabric8.kubernetes.api.model.Event` comme T pour 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);
  }

});

### Chargement des ressources à partir de sources externes

Il existe des cas où vous souhaitez lire une ressource à partir d'une source externe, plutôt que de la définir à l'aide du DSL du client.
Dans ces cas, le client vous permet de charger la ressource à partir de :

- Un fichier *(prend en charge à la fois java.io.File et java.lang.String)*
- Une URL
- Un flux d'entrée

Une fois la ressource chargée, vous pouvez la traiter comme si vous l'aviez créée vous-même.

Par exemple, lisons un pod à partir d'un fichier yml et travaillons avec :

    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);

### Passer une référence d'une ressource au client

Dans le même esprit, vous pouvez utiliser un objet créé en externe (soit une référence, soit en utilisant sa représentation sous forme de chaîne).

Par exemple :

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

### Adapter le client

Le client prend en charge des adaptateurs enfichables. Un exemple d'adaptateur est [l'adaptateur 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)
qui permet d'adapter une instance existante 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) en une instance [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).

 Par exemple :```java
KubernetesClient client = new DefaultKubernetesClient();

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

#### Adaptation et fermeture
Notez que lors de l'utilisation d'`adapt()`, l'adapté et la cible partageront les mêmes ressources (client HTTP sous-jacent, pools de threads, etc.).
Cela signifie que `close()` n'est pas obligatoire sur chaque instance créée via `adapt`.
Appeler `close()` sur l'une des instances gérées par `adapt()` ou sur l'instance d'origine nettoiera correctement toutes les ressources et aucune des instances ne sera donc plus utilisable.


## Mocking Kubernetes

En plus du client, ce projet fournit également un serveur mock Kubernetes que vous pouvez utiliser à des fins de test.
Le serveur mock est basé sur `https://github.com/square/okhttp/tree/master/mockwebserver` mais est enrichi par le DSL et les fonctionnalités fournis par `https://github.com/fabric8io/mockwebserver`.

Le Mock Web Server a deux modes de fonctionnement :

- Mode Expectations
- Mode CRUD

### Mode Expectations

C'est le mode typique où vous définissez d'abord quelles sont les requêtes HTTP attendues et quelles doivent être les réponses pour chaque requête.
Plus de détails sur l'utilisation sont disponibles sur : https://github.com/fabric8io/mockwebserver

Ce mode a été largement utilisé pour tester le client lui-même. Assurez-vous de consulter [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).

Pour ajouter un serveur Kubernetes à votre test :```java
@Rule
public KubernetesServer server = new KubernetesServer();

Ensuite, vous pouvez utiliser le serveur comme ceci:```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() {
        ...
}

Si vous souhaitez définir une instance statique du serveur mocké pour tous les tests (JUnit4 `@ClassRule`), vous devez déclarer une instance de `KubernetesClient` comme indiqué ci-dessous.
Vous pouvez également activer crudMode en utilisant le champ d'annotation `crud`.```java
@EnableKubernetesMockClient(crud = true)
class ExampleTest {

    static KubernetesClient client;

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