com.marcnuri.yakc.api.networkopenshiftio.v1.NetworkOpenshiftIoV1Api Maven / Gradle / Ivy
Show all versions of openshift Show documentation
/*
* Copyright 2020 Marc Nuri
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.marcnuri.yakc.api.networkopenshiftio.v1;
import com.marcnuri.yakc.api.Api;
import com.marcnuri.yakc.api.KubernetesCall;
import com.marcnuri.yakc.api.KubernetesListCall;
import com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions;
import com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status;
import com.marcnuri.yakc.model.io.openshift.network.v1.ClusterNetwork;
import com.marcnuri.yakc.model.io.openshift.network.v1.ClusterNetworkList;
import com.marcnuri.yakc.model.io.openshift.network.v1.EgressNetworkPolicy;
import com.marcnuri.yakc.model.io.openshift.network.v1.EgressNetworkPolicyList;
import com.marcnuri.yakc.model.io.openshift.network.v1.HostSubnet;
import com.marcnuri.yakc.model.io.openshift.network.v1.HostSubnetList;
import com.marcnuri.yakc.model.io.openshift.network.v1.NetNamespace;
import com.marcnuri.yakc.model.io.openshift.network.v1.NetNamespaceList;
import java.util.HashMap;
import retrofit2.http.Body;
import retrofit2.http.HTTP;
import retrofit2.http.Headers;
import retrofit2.http.Path;
import retrofit2.http.QueryMap;
@SuppressWarnings({"squid:S1192", "unused"})
public interface NetworkOpenshiftIoV1Api extends Api {
/**
* delete collection of ClusterNetwork
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/clusternetworks"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionClusterNetwork();
/**
* delete collection of ClusterNetwork
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/clusternetworks"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionClusterNetwork(
@QueryMap DeleteCollectionClusterNetwork queryParameters);
final class DeleteCollectionClusterNetwork extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionClusterNetwork pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionClusterNetwork allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionClusterNetwork continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionClusterNetwork fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionClusterNetwork labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionClusterNetwork limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionClusterNetwork resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionClusterNetwork timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionClusterNetwork watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind ClusterNetwork
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/clusternetworks"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listClusterNetwork();
/**
* list objects of kind ClusterNetwork
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/clusternetworks"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listClusterNetwork(
@QueryMap ListClusterNetwork queryParameters);
final class ListClusterNetwork extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListClusterNetwork pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListClusterNetwork allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListClusterNetwork continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListClusterNetwork fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListClusterNetwork labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListClusterNetwork limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListClusterNetwork resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListClusterNetwork timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListClusterNetwork watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a ClusterNetwork
*/
@HTTP(
method = "POST",
path = "/apis/network.openshift.io/v1/clusternetworks",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createClusterNetwork(
@Body ClusterNetwork body);
/**
* create a ClusterNetwork
*/
@HTTP(
method = "POST",
path = "/apis/network.openshift.io/v1/clusternetworks",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createClusterNetwork(
@Body ClusterNetwork body,
@QueryMap CreateClusterNetwork queryParameters);
final class CreateClusterNetwork extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateClusterNetwork pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public CreateClusterNetwork dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public CreateClusterNetwork fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a ClusterNetwork
*
* @param name name of the ClusterNetwork
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/clusternetworks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterNetwork(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a ClusterNetwork
*
* @param name name of the ClusterNetwork
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/clusternetworks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterNetwork(
@Path("name") String name);
/**
* delete a ClusterNetwork
*
* @param name name of the ClusterNetwork
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/clusternetworks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterNetwork(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteClusterNetwork queryParameters);
/**
* delete a ClusterNetwork
*
* @param name name of the ClusterNetwork
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/clusternetworks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterNetwork(
@Path("name") String name,
@QueryMap DeleteClusterNetwork queryParameters);
final class DeleteClusterNetwork extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteClusterNetwork pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public DeleteClusterNetwork dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
*/
public DeleteClusterNetwork gracePeriodSeconds(Number gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
*/
public DeleteClusterNetwork orphanDependents(Boolean orphanDependents) {
put("orphanDependents", orphanDependents);
return this;
}
/**
* Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
*/
public DeleteClusterNetwork propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified ClusterNetwork
*
* @param name name of the ClusterNetwork
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/clusternetworks/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterNetwork(
@Path("name") String name);
/**
* read the specified ClusterNetwork
*
* @param name name of the ClusterNetwork
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/clusternetworks/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterNetwork(
@Path("name") String name,
@QueryMap ReadClusterNetwork queryParameters);
final class ReadClusterNetwork extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadClusterNetwork pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadClusterNetwork resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified ClusterNetwork
*
* @param name name of the ClusterNetwork
*/
@HTTP(
method = "PATCH",
path = "/apis/network.openshift.io/v1/clusternetworks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterNetwork(
@Path("name") String name,
@Body ClusterNetwork body);
/**
* partially update the specified ClusterNetwork
*
* @param name name of the ClusterNetwork
*/
@HTTP(
method = "PATCH",
path = "/apis/network.openshift.io/v1/clusternetworks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterNetwork(
@Path("name") String name,
@Body ClusterNetwork body,
@QueryMap PatchClusterNetwork queryParameters);
final class PatchClusterNetwork extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchClusterNetwork pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchClusterNetwork dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchClusterNetwork fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified ClusterNetwork
*
* @param name name of the ClusterNetwork
*/
@HTTP(
method = "PUT",
path = "/apis/network.openshift.io/v1/clusternetworks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterNetwork(
@Path("name") String name,
@Body ClusterNetwork body);
/**
* replace the specified ClusterNetwork
*
* @param name name of the ClusterNetwork
*/
@HTTP(
method = "PUT",
path = "/apis/network.openshift.io/v1/clusternetworks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterNetwork(
@Path("name") String name,
@Body ClusterNetwork body,
@QueryMap ReplaceClusterNetwork queryParameters);
final class ReplaceClusterNetwork extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceClusterNetwork pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceClusterNetwork dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceClusterNetwork fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* list objects of kind EgressNetworkPolicy
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/egressnetworkpolicies"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listEgressNetworkPolicyForAllNamespaces();
/**
* list objects of kind EgressNetworkPolicy
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/egressnetworkpolicies"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listEgressNetworkPolicyForAllNamespaces(
@QueryMap ListEgressNetworkPolicyForAllNamespaces queryParameters);
final class ListEgressNetworkPolicyForAllNamespaces extends HashMap {
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListEgressNetworkPolicyForAllNamespaces allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListEgressNetworkPolicyForAllNamespaces continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListEgressNetworkPolicyForAllNamespaces fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListEgressNetworkPolicyForAllNamespaces labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListEgressNetworkPolicyForAllNamespaces limit(Number limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public ListEgressNetworkPolicyForAllNamespaces pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListEgressNetworkPolicyForAllNamespaces resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListEgressNetworkPolicyForAllNamespaces timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListEgressNetworkPolicyForAllNamespaces watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* delete collection of HostSubnet
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/hostsubnets"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionHostSubnet();
/**
* delete collection of HostSubnet
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/hostsubnets"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionHostSubnet(
@QueryMap DeleteCollectionHostSubnet queryParameters);
final class DeleteCollectionHostSubnet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionHostSubnet pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionHostSubnet allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionHostSubnet continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionHostSubnet fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionHostSubnet labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionHostSubnet limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionHostSubnet resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionHostSubnet timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionHostSubnet watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind HostSubnet
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/hostsubnets"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listHostSubnet();
/**
* list objects of kind HostSubnet
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/hostsubnets"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listHostSubnet(
@QueryMap ListHostSubnet queryParameters);
final class ListHostSubnet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListHostSubnet pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListHostSubnet allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListHostSubnet continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListHostSubnet fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListHostSubnet labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListHostSubnet limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListHostSubnet resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListHostSubnet timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListHostSubnet watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a HostSubnet
*/
@HTTP(
method = "POST",
path = "/apis/network.openshift.io/v1/hostsubnets",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createHostSubnet(
@Body HostSubnet body);
/**
* create a HostSubnet
*/
@HTTP(
method = "POST",
path = "/apis/network.openshift.io/v1/hostsubnets",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createHostSubnet(
@Body HostSubnet body,
@QueryMap CreateHostSubnet queryParameters);
final class CreateHostSubnet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateHostSubnet pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public CreateHostSubnet dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public CreateHostSubnet fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a HostSubnet
*
* @param name name of the HostSubnet
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/hostsubnets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteHostSubnet(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a HostSubnet
*
* @param name name of the HostSubnet
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/hostsubnets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteHostSubnet(
@Path("name") String name);
/**
* delete a HostSubnet
*
* @param name name of the HostSubnet
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/hostsubnets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteHostSubnet(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteHostSubnet queryParameters);
/**
* delete a HostSubnet
*
* @param name name of the HostSubnet
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/hostsubnets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteHostSubnet(
@Path("name") String name,
@QueryMap DeleteHostSubnet queryParameters);
final class DeleteHostSubnet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteHostSubnet pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public DeleteHostSubnet dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
*/
public DeleteHostSubnet gracePeriodSeconds(Number gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
*/
public DeleteHostSubnet orphanDependents(Boolean orphanDependents) {
put("orphanDependents", orphanDependents);
return this;
}
/**
* Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
*/
public DeleteHostSubnet propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified HostSubnet
*
* @param name name of the HostSubnet
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/hostsubnets/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readHostSubnet(
@Path("name") String name);
/**
* read the specified HostSubnet
*
* @param name name of the HostSubnet
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/hostsubnets/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readHostSubnet(
@Path("name") String name,
@QueryMap ReadHostSubnet queryParameters);
final class ReadHostSubnet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadHostSubnet pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadHostSubnet resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified HostSubnet
*
* @param name name of the HostSubnet
*/
@HTTP(
method = "PATCH",
path = "/apis/network.openshift.io/v1/hostsubnets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchHostSubnet(
@Path("name") String name,
@Body HostSubnet body);
/**
* partially update the specified HostSubnet
*
* @param name name of the HostSubnet
*/
@HTTP(
method = "PATCH",
path = "/apis/network.openshift.io/v1/hostsubnets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchHostSubnet(
@Path("name") String name,
@Body HostSubnet body,
@QueryMap PatchHostSubnet queryParameters);
final class PatchHostSubnet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchHostSubnet pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchHostSubnet dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchHostSubnet fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified HostSubnet
*
* @param name name of the HostSubnet
*/
@HTTP(
method = "PUT",
path = "/apis/network.openshift.io/v1/hostsubnets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceHostSubnet(
@Path("name") String name,
@Body HostSubnet body);
/**
* replace the specified HostSubnet
*
* @param name name of the HostSubnet
*/
@HTTP(
method = "PUT",
path = "/apis/network.openshift.io/v1/hostsubnets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceHostSubnet(
@Path("name") String name,
@Body HostSubnet body,
@QueryMap ReplaceHostSubnet queryParameters);
final class ReplaceHostSubnet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceHostSubnet pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceHostSubnet dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceHostSubnet fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of EgressNetworkPolicy
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNamespacedEgressNetworkPolicy(
@Path("namespace") String namespace);
/**
* delete collection of EgressNetworkPolicy
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNamespacedEgressNetworkPolicy(
@Path("namespace") String namespace,
@QueryMap DeleteCollectionNamespacedEgressNetworkPolicy queryParameters);
final class DeleteCollectionNamespacedEgressNetworkPolicy extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionNamespacedEgressNetworkPolicy pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionNamespacedEgressNetworkPolicy allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionNamespacedEgressNetworkPolicy continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionNamespacedEgressNetworkPolicy fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionNamespacedEgressNetworkPolicy labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionNamespacedEgressNetworkPolicy limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionNamespacedEgressNetworkPolicy resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionNamespacedEgressNetworkPolicy timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionNamespacedEgressNetworkPolicy watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind EgressNetworkPolicy
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedEgressNetworkPolicy(
@Path("namespace") String namespace);
/**
* list objects of kind EgressNetworkPolicy
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedEgressNetworkPolicy(
@Path("namespace") String namespace,
@QueryMap ListNamespacedEgressNetworkPolicy queryParameters);
final class ListNamespacedEgressNetworkPolicy extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListNamespacedEgressNetworkPolicy pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListNamespacedEgressNetworkPolicy allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListNamespacedEgressNetworkPolicy continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListNamespacedEgressNetworkPolicy fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListNamespacedEgressNetworkPolicy labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListNamespacedEgressNetworkPolicy limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListNamespacedEgressNetworkPolicy resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListNamespacedEgressNetworkPolicy timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListNamespacedEgressNetworkPolicy watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create an EgressNetworkPolicy
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedEgressNetworkPolicy(
@Path("namespace") String namespace,
@Body EgressNetworkPolicy body);
/**
* create an EgressNetworkPolicy
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedEgressNetworkPolicy(
@Path("namespace") String namespace,
@Body EgressNetworkPolicy body,
@QueryMap CreateNamespacedEgressNetworkPolicy queryParameters);
final class CreateNamespacedEgressNetworkPolicy extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateNamespacedEgressNetworkPolicy pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public CreateNamespacedEgressNetworkPolicy dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public CreateNamespacedEgressNetworkPolicy fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete an EgressNetworkPolicy
*
* @param name name of the EgressNetworkPolicy
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedEgressNetworkPolicy(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body);
/**
* delete an EgressNetworkPolicy
*
* @param name name of the EgressNetworkPolicy
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedEgressNetworkPolicy(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* delete an EgressNetworkPolicy
*
* @param name name of the EgressNetworkPolicy
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedEgressNetworkPolicy(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body,
@QueryMap DeleteNamespacedEgressNetworkPolicy queryParameters);
/**
* delete an EgressNetworkPolicy
*
* @param name name of the EgressNetworkPolicy
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedEgressNetworkPolicy(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap DeleteNamespacedEgressNetworkPolicy queryParameters);
final class DeleteNamespacedEgressNetworkPolicy extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteNamespacedEgressNetworkPolicy pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public DeleteNamespacedEgressNetworkPolicy dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
*/
public DeleteNamespacedEgressNetworkPolicy gracePeriodSeconds(Number gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
*/
public DeleteNamespacedEgressNetworkPolicy orphanDependents(Boolean orphanDependents) {
put("orphanDependents", orphanDependents);
return this;
}
/**
* Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
*/
public DeleteNamespacedEgressNetworkPolicy propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified EgressNetworkPolicy
*
* @param name name of the EgressNetworkPolicy
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedEgressNetworkPolicy(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* read the specified EgressNetworkPolicy
*
* @param name name of the EgressNetworkPolicy
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedEgressNetworkPolicy(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap ReadNamespacedEgressNetworkPolicy queryParameters);
final class ReadNamespacedEgressNetworkPolicy extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNamespacedEgressNetworkPolicy pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadNamespacedEgressNetworkPolicy resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified EgressNetworkPolicy
*
* @param name name of the EgressNetworkPolicy
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedEgressNetworkPolicy(
@Path("name") String name,
@Path("namespace") String namespace,
@Body EgressNetworkPolicy body);
/**
* partially update the specified EgressNetworkPolicy
*
* @param name name of the EgressNetworkPolicy
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedEgressNetworkPolicy(
@Path("name") String name,
@Path("namespace") String namespace,
@Body EgressNetworkPolicy body,
@QueryMap PatchNamespacedEgressNetworkPolicy queryParameters);
final class PatchNamespacedEgressNetworkPolicy extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNamespacedEgressNetworkPolicy pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchNamespacedEgressNetworkPolicy dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchNamespacedEgressNetworkPolicy fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified EgressNetworkPolicy
*
* @param name name of the EgressNetworkPolicy
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedEgressNetworkPolicy(
@Path("name") String name,
@Path("namespace") String namespace,
@Body EgressNetworkPolicy body);
/**
* replace the specified EgressNetworkPolicy
*
* @param name name of the EgressNetworkPolicy
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/network.openshift.io/v1/namespaces/{namespace}/egressnetworkpolicies/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedEgressNetworkPolicy(
@Path("name") String name,
@Path("namespace") String namespace,
@Body EgressNetworkPolicy body,
@QueryMap ReplaceNamespacedEgressNetworkPolicy queryParameters);
final class ReplaceNamespacedEgressNetworkPolicy extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNamespacedEgressNetworkPolicy pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceNamespacedEgressNetworkPolicy dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceNamespacedEgressNetworkPolicy fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of NetNamespace
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/netnamespaces"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNetNamespace();
/**
* delete collection of NetNamespace
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/netnamespaces"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNetNamespace(
@QueryMap DeleteCollectionNetNamespace queryParameters);
final class DeleteCollectionNetNamespace extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionNetNamespace pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionNetNamespace allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionNetNamespace continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionNetNamespace fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionNetNamespace labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionNetNamespace limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionNetNamespace resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionNetNamespace timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionNetNamespace watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind NetNamespace
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/netnamespaces"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNetNamespace();
/**
* list objects of kind NetNamespace
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/netnamespaces"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNetNamespace(
@QueryMap ListNetNamespace queryParameters);
final class ListNetNamespace extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListNetNamespace pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListNetNamespace allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListNetNamespace continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListNetNamespace fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListNetNamespace labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListNetNamespace limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListNetNamespace resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListNetNamespace timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListNetNamespace watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a NetNamespace
*/
@HTTP(
method = "POST",
path = "/apis/network.openshift.io/v1/netnamespaces",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNetNamespace(
@Body NetNamespace body);
/**
* create a NetNamespace
*/
@HTTP(
method = "POST",
path = "/apis/network.openshift.io/v1/netnamespaces",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNetNamespace(
@Body NetNamespace body,
@QueryMap CreateNetNamespace queryParameters);
final class CreateNetNamespace extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateNetNamespace pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public CreateNetNamespace dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public CreateNetNamespace fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a NetNamespace
*
* @param name name of the NetNamespace
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/netnamespaces/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNetNamespace(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a NetNamespace
*
* @param name name of the NetNamespace
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/netnamespaces/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNetNamespace(
@Path("name") String name);
/**
* delete a NetNamespace
*
* @param name name of the NetNamespace
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/netnamespaces/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNetNamespace(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteNetNamespace queryParameters);
/**
* delete a NetNamespace
*
* @param name name of the NetNamespace
*/
@HTTP(
method = "DELETE",
path = "/apis/network.openshift.io/v1/netnamespaces/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNetNamespace(
@Path("name") String name,
@QueryMap DeleteNetNamespace queryParameters);
final class DeleteNetNamespace extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteNetNamespace pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public DeleteNetNamespace dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
*/
public DeleteNetNamespace gracePeriodSeconds(Number gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
*/
public DeleteNetNamespace orphanDependents(Boolean orphanDependents) {
put("orphanDependents", orphanDependents);
return this;
}
/**
* Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
*/
public DeleteNetNamespace propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified NetNamespace
*
* @param name name of the NetNamespace
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/netnamespaces/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNetNamespace(
@Path("name") String name);
/**
* read the specified NetNamespace
*
* @param name name of the NetNamespace
*/
@HTTP(
method = "GET",
path = "/apis/network.openshift.io/v1/netnamespaces/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNetNamespace(
@Path("name") String name,
@QueryMap ReadNetNamespace queryParameters);
final class ReadNetNamespace extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNetNamespace pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadNetNamespace resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified NetNamespace
*
* @param name name of the NetNamespace
*/
@HTTP(
method = "PATCH",
path = "/apis/network.openshift.io/v1/netnamespaces/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNetNamespace(
@Path("name") String name,
@Body NetNamespace body);
/**
* partially update the specified NetNamespace
*
* @param name name of the NetNamespace
*/
@HTTP(
method = "PATCH",
path = "/apis/network.openshift.io/v1/netnamespaces/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNetNamespace(
@Path("name") String name,
@Body NetNamespace body,
@QueryMap PatchNetNamespace queryParameters);
final class PatchNetNamespace extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNetNamespace pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchNetNamespace dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchNetNamespace fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified NetNamespace
*
* @param name name of the NetNamespace
*/
@HTTP(
method = "PUT",
path = "/apis/network.openshift.io/v1/netnamespaces/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNetNamespace(
@Path("name") String name,
@Body NetNamespace body);
/**
* replace the specified NetNamespace
*
* @param name name of the NetNamespace
*/
@HTTP(
method = "PUT",
path = "/apis/network.openshift.io/v1/netnamespaces/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNetNamespace(
@Path("name") String name,
@Body NetNamespace body,
@QueryMap ReplaceNetNamespace queryParameters);
final class ReplaceNetNamespace extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNetNamespace pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceNetNamespace dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceNetNamespace fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
}