`DefaultOpenShiftClient` `KubernetesClient` और `OpenShiftClient` दोनों इंटरफ़ेस को लागू करता है, इसलिए यदि आपको
OpenShift एक्सटेंशन की आवश्यकता है, जैसे `Build`s, आदि, तो बस यह करें:```java
OpenShiftClient osClient = new DefaultOpenShiftClient();

सभी संसाधनों के लिए DSL का उपयोग समान है।

संसाधन सूचीबद्ध करें:```java
NamespaceList myNs = client.namespaces().list();

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

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

हटाएं:```java
Namespace myns = client.namespaces().withName("myns").delete();

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

उसी भावना में आप बिल्डरों को इनलाइन कर सकते हैं:```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());

### इवेंट्स का अनुसरण

Watcher के लिए T के रूप में `io.fabric8.kubernetes.api.model.Event` का उपयोग करें:```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);
  }

});

### बाहरी स्रोतों से संसाधन लोड करना

ऐसे मामले होते हैं जहाँ आप किसी संसाधन को क्लाइंट DSL का उपयोग करके परिभाषित करने के बजाय किसी बाहरी स्रोत से पढ़ना चाहते हैं।
ऐसे मामलों के लिए क्लाइंट आपको संसाधन को निम्न से लोड करने की सुविधा देता है:

- एक फ़ाइल *(java.io.File और java.lang.String दोनों का समर्थन करती है)*
- एक URL
- एक इनपुट स्ट्रीम

संसाधन लोड हो जाने के बाद, आप उसके साथ वैसे ही काम कर सकते हैं, जैसे आपने उसे स्वयं बनाया हो।

उदाहरण के लिए, आइए एक yml फ़ाइल से pod पढ़ें और उसके साथ काम करें:

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

### क्लाइंट को संसाधन का संदर्भ पास करना

इसी तर्ज पर, आप बाहरी रूप से बनाई गई किसी वस्तु का उपयोग कर सकते हैं (या तो संदर्भ के रूप में या उसके स्ट्रिंग निरूपण का उपयोग करके)।

उदाहरण के लिए:

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

### क्लाइंट को अनुकूलित करना

क्लाइंट प्लग-योग्य एडेप्टर का समर्थन करता है। एक उदाहरण एडेप्टर [OpenShift Adapter](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) है
जो किसी मौजूदा [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) इंस्टेंस को [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) इंस्टेंस में अनुकूलित करने की सुविधा देता है।

 उदाहरण के लिए:```java
KubernetesClient client = new DefaultKubernetesClient();

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

#### अनुकूलन और बंद करना
ध्यान दें कि adapt() का उपयोग करते समय adaptee और target दोनों समान संसाधनों (अंतर्निहित http client, thread pools आदि) को साझा करेंगे।
इसका अर्थ है कि adapt के माध्यम से बनाए गए प्रत्येक instance पर close() का उपयोग करना आवश्यक नहीं है।
adapt() द्वारा प्रबंधित किसी भी instance या मूल instance पर close() को कॉल करने से सभी संसाधन ठीक से साफ़ हो जाएँगे और इस प्रकार कोई भी instance आगे उपयोग योग्य नहीं रहेगा।


## Kubernetes मॉकिंग

क्लाइंट के साथ-साथ यह प्रोजेक्ट परीक्षण उद्देश्यों के लिए एक kubernetes मॉक सर्वर भी प्रदान करता है।
यह मॉक सर्वर `https://github.com/square/okhttp/tree/master/mockwebserver` पर आधारित है, लेकिन `https://github.com/fabric8io/mockwebserver` द्वारा प्रदान की गई DSL और सुविधाओं से सशक्त है।

मॉक वेब सर्वर में संचालन के दो तरीके हैं:

- Expectations mode
- CRUD mode

### Expectations mode

यह विशिष्ट मोड है जिसमें आप पहले निर्धारित करते हैं कि अपेक्षित http अनुरोध कौन से हैं और प्रत्येक अनुरोध के लिए प्रतिक्रियाएँ क्या होनी चाहिए।
उपयोग के अधिक विवरण यहाँ मिल सकते हैं: https://github.com/fabric8io/mockwebserver

इस मोड का उपयोग क्लाइंट के परीक्षण के लिए बड़े पैमाने पर किया गया है। [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) अवश्य देखें।

अपने परीक्षण में Kubernetes server जोड़ने के लिए:```java
@Rule
public KubernetesServer server = new KubernetesServer();

फिर आप सर्वर का उपयोग इस प्रकार कर सकते हैं:```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() {
        ...
}

यदि आप सभी परीक्षणों (JUnit4 `@ClassRule`) के लिए mocked server का static instance परिभाषित करना चाहते हैं, तो आपको नीचे दिखाए अनुसार `KubernetesClient` का instance घोषित करना होगा।
आप annotation field `crud` का उपयोग करके crudMode भी सक्षम कर सकते हैं।```java
@EnableKubernetesMockClient(crud = true)
class ExampleTest {

    static KubernetesClient client;

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