com.marcnuri.yakc.api.machineopenshiftio.v1beta1.MachineOpenshiftIoV1beta1Api 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.machineopenshiftio.v1beta1;
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.api.autoscaling.v1.Scale;
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.machine.v1beta1.Machine;
import com.marcnuri.yakc.model.io.openshift.machine.v1beta1.MachineHealthCheck;
import com.marcnuri.yakc.model.io.openshift.machine.v1beta1.MachineHealthCheckList;
import com.marcnuri.yakc.model.io.openshift.machine.v1beta1.MachineList;
import com.marcnuri.yakc.model.io.openshift.machine.v1beta1.MachineSet;
import com.marcnuri.yakc.model.io.openshift.machine.v1beta1.MachineSetList;
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 MachineOpenshiftIoV1beta1Api extends Api {
/**
* list objects of kind MachineHealthCheck
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/machinehealthchecks"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listMachineHealthCheckForAllNamespaces();
/**
* list objects of kind MachineHealthCheck
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/machinehealthchecks"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listMachineHealthCheckForAllNamespaces(
@QueryMap ListMachineHealthCheckForAllNamespaces queryParameters);
final class ListMachineHealthCheckForAllNamespaces 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 ListMachineHealthCheckForAllNamespaces 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 ListMachineHealthCheckForAllNamespaces continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListMachineHealthCheckForAllNamespaces fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListMachineHealthCheckForAllNamespaces 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 ListMachineHealthCheckForAllNamespaces limit(Number limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public ListMachineHealthCheckForAllNamespaces 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 ListMachineHealthCheckForAllNamespaces 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 ListMachineHealthCheckForAllNamespaces 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 ListMachineHealthCheckForAllNamespaces watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind Machine
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/machines"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listMachineForAllNamespaces();
/**
* list objects of kind Machine
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/machines"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listMachineForAllNamespaces(
@QueryMap ListMachineForAllNamespaces queryParameters);
final class ListMachineForAllNamespaces 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 ListMachineForAllNamespaces 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 ListMachineForAllNamespaces continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListMachineForAllNamespaces fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListMachineForAllNamespaces 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 ListMachineForAllNamespaces limit(Number limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public ListMachineForAllNamespaces 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 ListMachineForAllNamespaces 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 ListMachineForAllNamespaces 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 ListMachineForAllNamespaces watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind MachineSet
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/machinesets"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listMachineSetForAllNamespaces();
/**
* list objects of kind MachineSet
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/machinesets"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listMachineSetForAllNamespaces(
@QueryMap ListMachineSetForAllNamespaces queryParameters);
final class ListMachineSetForAllNamespaces 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 ListMachineSetForAllNamespaces 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 ListMachineSetForAllNamespaces continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListMachineSetForAllNamespaces fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListMachineSetForAllNamespaces 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 ListMachineSetForAllNamespaces limit(Number limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public ListMachineSetForAllNamespaces 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 ListMachineSetForAllNamespaces 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 ListMachineSetForAllNamespaces 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 ListMachineSetForAllNamespaces watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* delete collection of MachineHealthCheck
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNamespacedMachineHealthCheck(
@Path("namespace") String namespace);
/**
* delete collection of MachineHealthCheck
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNamespacedMachineHealthCheck(
@Path("namespace") String namespace,
@QueryMap DeleteCollectionNamespacedMachineHealthCheck queryParameters);
final class DeleteCollectionNamespacedMachineHealthCheck extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionNamespacedMachineHealthCheck 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 DeleteCollectionNamespacedMachineHealthCheck 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 DeleteCollectionNamespacedMachineHealthCheck continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionNamespacedMachineHealthCheck fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionNamespacedMachineHealthCheck 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 DeleteCollectionNamespacedMachineHealthCheck 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 DeleteCollectionNamespacedMachineHealthCheck 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 DeleteCollectionNamespacedMachineHealthCheck 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 DeleteCollectionNamespacedMachineHealthCheck watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind MachineHealthCheck
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedMachineHealthCheck(
@Path("namespace") String namespace);
/**
* list objects of kind MachineHealthCheck
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedMachineHealthCheck(
@Path("namespace") String namespace,
@QueryMap ListNamespacedMachineHealthCheck queryParameters);
final class ListNamespacedMachineHealthCheck extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListNamespacedMachineHealthCheck 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 ListNamespacedMachineHealthCheck 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 ListNamespacedMachineHealthCheck continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListNamespacedMachineHealthCheck fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListNamespacedMachineHealthCheck 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 ListNamespacedMachineHealthCheck 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 ListNamespacedMachineHealthCheck 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 ListNamespacedMachineHealthCheck 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 ListNamespacedMachineHealthCheck watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a MachineHealthCheck
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedMachineHealthCheck(
@Path("namespace") String namespace,
@Body MachineHealthCheck body);
/**
* create a MachineHealthCheck
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedMachineHealthCheck(
@Path("namespace") String namespace,
@Body MachineHealthCheck body,
@QueryMap CreateNamespacedMachineHealthCheck queryParameters);
final class CreateNamespacedMachineHealthCheck extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateNamespacedMachineHealthCheck 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 CreateNamespacedMachineHealthCheck 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 CreateNamespacedMachineHealthCheck fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachineHealthCheck(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body);
/**
* delete a MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachineHealthCheck(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* delete a MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachineHealthCheck(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body,
@QueryMap DeleteNamespacedMachineHealthCheck queryParameters);
/**
* delete a MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachineHealthCheck(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap DeleteNamespacedMachineHealthCheck queryParameters);
final class DeleteNamespacedMachineHealthCheck extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteNamespacedMachineHealthCheck 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 DeleteNamespacedMachineHealthCheck 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 DeleteNamespacedMachineHealthCheck 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 DeleteNamespacedMachineHealthCheck 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 DeleteNamespacedMachineHealthCheck propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineHealthCheck(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* read the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineHealthCheck(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap ReadNamespacedMachineHealthCheck queryParameters);
final class ReadNamespacedMachineHealthCheck extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNamespacedMachineHealthCheck 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 ReadNamespacedMachineHealthCheck resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineHealthCheck(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineHealthCheck body);
/**
* partially update the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineHealthCheck(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineHealthCheck body,
@QueryMap PatchNamespacedMachineHealthCheck queryParameters);
final class PatchNamespacedMachineHealthCheck extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNamespacedMachineHealthCheck 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 PatchNamespacedMachineHealthCheck 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 PatchNamespacedMachineHealthCheck fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineHealthCheck(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineHealthCheck body);
/**
* replace the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineHealthCheck(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineHealthCheck body,
@QueryMap ReplaceNamespacedMachineHealthCheck queryParameters);
final class ReplaceNamespacedMachineHealthCheck extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNamespacedMachineHealthCheck 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 ReplaceNamespacedMachineHealthCheck 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 ReplaceNamespacedMachineHealthCheck fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineHealthCheckStatus(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* read status of the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineHealthCheckStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap ReadNamespacedMachineHealthCheckStatus queryParameters);
final class ReadNamespacedMachineHealthCheckStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNamespacedMachineHealthCheckStatus 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 ReadNamespacedMachineHealthCheckStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineHealthCheckStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineHealthCheck body);
/**
* partially update status of the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineHealthCheckStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineHealthCheck body,
@QueryMap PatchNamespacedMachineHealthCheckStatus queryParameters);
final class PatchNamespacedMachineHealthCheckStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNamespacedMachineHealthCheckStatus 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 PatchNamespacedMachineHealthCheckStatus 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 PatchNamespacedMachineHealthCheckStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineHealthCheckStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineHealthCheck body);
/**
* replace status of the specified MachineHealthCheck
*
* @param name name of the MachineHealthCheck
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinehealthchecks/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineHealthCheckStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineHealthCheck body,
@QueryMap ReplaceNamespacedMachineHealthCheckStatus queryParameters);
final class ReplaceNamespacedMachineHealthCheckStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNamespacedMachineHealthCheckStatus 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 ReplaceNamespacedMachineHealthCheckStatus 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 ReplaceNamespacedMachineHealthCheckStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of Machine
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNamespacedMachine(
@Path("namespace") String namespace);
/**
* delete collection of Machine
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNamespacedMachine(
@Path("namespace") String namespace,
@QueryMap DeleteCollectionNamespacedMachine queryParameters);
final class DeleteCollectionNamespacedMachine extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionNamespacedMachine 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 DeleteCollectionNamespacedMachine 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 DeleteCollectionNamespacedMachine continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionNamespacedMachine fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionNamespacedMachine 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 DeleteCollectionNamespacedMachine 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 DeleteCollectionNamespacedMachine 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 DeleteCollectionNamespacedMachine 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 DeleteCollectionNamespacedMachine watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind Machine
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedMachine(
@Path("namespace") String namespace);
/**
* list objects of kind Machine
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedMachine(
@Path("namespace") String namespace,
@QueryMap ListNamespacedMachine queryParameters);
final class ListNamespacedMachine extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListNamespacedMachine 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 ListNamespacedMachine 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 ListNamespacedMachine continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListNamespacedMachine fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListNamespacedMachine 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 ListNamespacedMachine 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 ListNamespacedMachine 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 ListNamespacedMachine 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 ListNamespacedMachine watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a Machine
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedMachine(
@Path("namespace") String namespace,
@Body Machine body);
/**
* create a Machine
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedMachine(
@Path("namespace") String namespace,
@Body Machine body,
@QueryMap CreateNamespacedMachine queryParameters);
final class CreateNamespacedMachine extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateNamespacedMachine 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 CreateNamespacedMachine 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 CreateNamespacedMachine fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachine(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body);
/**
* delete a Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachine(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* delete a Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachine(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body,
@QueryMap DeleteNamespacedMachine queryParameters);
/**
* delete a Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachine(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap DeleteNamespacedMachine queryParameters);
final class DeleteNamespacedMachine extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteNamespacedMachine 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 DeleteNamespacedMachine 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 DeleteNamespacedMachine 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 DeleteNamespacedMachine 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 DeleteNamespacedMachine propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachine(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* read the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachine(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap ReadNamespacedMachine queryParameters);
final class ReadNamespacedMachine extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNamespacedMachine 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 ReadNamespacedMachine resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachine(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Machine body);
/**
* partially update the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachine(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Machine body,
@QueryMap PatchNamespacedMachine queryParameters);
final class PatchNamespacedMachine extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNamespacedMachine 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 PatchNamespacedMachine 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 PatchNamespacedMachine fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachine(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Machine body);
/**
* replace the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachine(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Machine body,
@QueryMap ReplaceNamespacedMachine queryParameters);
final class ReplaceNamespacedMachine extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNamespacedMachine 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 ReplaceNamespacedMachine 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 ReplaceNamespacedMachine fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineStatus(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* read status of the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap ReadNamespacedMachineStatus queryParameters);
final class ReadNamespacedMachineStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNamespacedMachineStatus 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 ReadNamespacedMachineStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Machine body);
/**
* partially update status of the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Machine body,
@QueryMap PatchNamespacedMachineStatus queryParameters);
final class PatchNamespacedMachineStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNamespacedMachineStatus 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 PatchNamespacedMachineStatus 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 PatchNamespacedMachineStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Machine body);
/**
* replace status of the specified Machine
*
* @param name name of the Machine
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machines/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Machine body,
@QueryMap ReplaceNamespacedMachineStatus queryParameters);
final class ReplaceNamespacedMachineStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNamespacedMachineStatus 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 ReplaceNamespacedMachineStatus 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 ReplaceNamespacedMachineStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of MachineSet
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNamespacedMachineSet(
@Path("namespace") String namespace);
/**
* delete collection of MachineSet
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNamespacedMachineSet(
@Path("namespace") String namespace,
@QueryMap DeleteCollectionNamespacedMachineSet queryParameters);
final class DeleteCollectionNamespacedMachineSet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionNamespacedMachineSet 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 DeleteCollectionNamespacedMachineSet 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 DeleteCollectionNamespacedMachineSet continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionNamespacedMachineSet fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionNamespacedMachineSet 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 DeleteCollectionNamespacedMachineSet 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 DeleteCollectionNamespacedMachineSet 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 DeleteCollectionNamespacedMachineSet 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 DeleteCollectionNamespacedMachineSet watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind MachineSet
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedMachineSet(
@Path("namespace") String namespace);
/**
* list objects of kind MachineSet
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedMachineSet(
@Path("namespace") String namespace,
@QueryMap ListNamespacedMachineSet queryParameters);
final class ListNamespacedMachineSet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListNamespacedMachineSet 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 ListNamespacedMachineSet 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 ListNamespacedMachineSet continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListNamespacedMachineSet fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListNamespacedMachineSet 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 ListNamespacedMachineSet 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 ListNamespacedMachineSet 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 ListNamespacedMachineSet 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 ListNamespacedMachineSet watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a MachineSet
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedMachineSet(
@Path("namespace") String namespace,
@Body MachineSet body);
/**
* create a MachineSet
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedMachineSet(
@Path("namespace") String namespace,
@Body MachineSet body,
@QueryMap CreateNamespacedMachineSet queryParameters);
final class CreateNamespacedMachineSet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateNamespacedMachineSet 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 CreateNamespacedMachineSet 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 CreateNamespacedMachineSet fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachineSet(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body);
/**
* delete a MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachineSet(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* delete a MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachineSet(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body,
@QueryMap DeleteNamespacedMachineSet queryParameters);
/**
* delete a MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedMachineSet(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap DeleteNamespacedMachineSet queryParameters);
final class DeleteNamespacedMachineSet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteNamespacedMachineSet 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 DeleteNamespacedMachineSet 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 DeleteNamespacedMachineSet 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 DeleteNamespacedMachineSet 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 DeleteNamespacedMachineSet propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineSet(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* read the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineSet(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap ReadNamespacedMachineSet queryParameters);
final class ReadNamespacedMachineSet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNamespacedMachineSet 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 ReadNamespacedMachineSet resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineSet(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineSet body);
/**
* partially update the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineSet(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineSet body,
@QueryMap PatchNamespacedMachineSet queryParameters);
final class PatchNamespacedMachineSet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNamespacedMachineSet 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 PatchNamespacedMachineSet 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 PatchNamespacedMachineSet fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineSet(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineSet body);
/**
* replace the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineSet(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineSet body,
@QueryMap ReplaceNamespacedMachineSet queryParameters);
final class ReplaceNamespacedMachineSet extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNamespacedMachineSet 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 ReplaceNamespacedMachineSet 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 ReplaceNamespacedMachineSet fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read scale of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/scale"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineSetScale(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* read scale of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/scale"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineSetScale(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap ReadNamespacedMachineSetScale queryParameters);
final class ReadNamespacedMachineSetScale extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNamespacedMachineSetScale 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 ReadNamespacedMachineSetScale resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update scale of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/scale",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineSetScale(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Scale body);
/**
* partially update scale of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/scale",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineSetScale(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Scale body,
@QueryMap PatchNamespacedMachineSetScale queryParameters);
final class PatchNamespacedMachineSetScale extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNamespacedMachineSetScale 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 PatchNamespacedMachineSetScale 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 PatchNamespacedMachineSetScale fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace scale of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/scale",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineSetScale(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Scale body);
/**
* replace scale of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/scale",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineSetScale(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Scale body,
@QueryMap ReplaceNamespacedMachineSetScale queryParameters);
final class ReplaceNamespacedMachineSetScale extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNamespacedMachineSetScale 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 ReplaceNamespacedMachineSetScale 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 ReplaceNamespacedMachineSetScale fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineSetStatus(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* read status of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedMachineSetStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap ReadNamespacedMachineSetStatus queryParameters);
final class ReadNamespacedMachineSetStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNamespacedMachineSetStatus 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 ReadNamespacedMachineSetStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineSetStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineSet body);
/**
* partially update status of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedMachineSetStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineSet body,
@QueryMap PatchNamespacedMachineSetStatus queryParameters);
final class PatchNamespacedMachineSetStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNamespacedMachineSetStatus 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 PatchNamespacedMachineSetStatus 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 PatchNamespacedMachineSetStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineSetStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineSet body);
/**
* replace status of the specified MachineSet
*
* @param name name of the MachineSet
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/machine.openshift.io/v1beta1/namespaces/{namespace}/machinesets/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedMachineSetStatus(
@Path("name") String name,
@Path("namespace") String namespace,
@Body MachineSet body,
@QueryMap ReplaceNamespacedMachineSetStatus queryParameters);
final class ReplaceNamespacedMachineSetStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNamespacedMachineSetStatus 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 ReplaceNamespacedMachineSetStatus 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 ReplaceNamespacedMachineSetStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
}