/// <summary>
/// Deletes the specified namespace scoped custom object.
/// </summary>
/// <typeparam name="T">
/// The type of object to delete.
/// </typeparam>
/// <param name="kind">
/// The group, version and kind information which represents the object type.
/// </param>
/// <param name="name">
/// The name of the object to delete.
/// </param>
/// <param name="body">
/// Specific delete options.
/// </param>
/// <param name="dryRun">
/// 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.
/// </param>
/// <param name="gracePeriodSeconds">
/// 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.
/// </param>
/// <param name="orphanDependents">
/// 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.
/// </param>
/// <param name="propagationPolicy">
/// 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.
/// </param>
/// <param name="pretty">
/// A value indicating whether the output should be pretty-printed.
/// </param>
/// <param name="cancellationToken">
/// A <see cref="CancellationToken"/> which can be used to cancel the asynchronous request.
/// </param>
/// <returns>
/// A <see cref="Task"/> which represents the asynchronous operation.
/// </returns>
public async Task <T?> DeleteNamespacedObjectAsync <T>(
KindMetadata kind,
string name,
V1DeleteOptions?body = null,
string?dryRun = null,
int?gracePeriodSeconds = null,
bool?orphanDependents = null,
string?propagationPolicy = null,
string?pretty = null,
CancellationToken cancellationToken = default)
where T : IKubernetesObject <V1ObjectMeta>
{
using (var operationResponse = await this.protocol.DeleteNamespacedCustomObjectWithHttpMessagesAsync(
kind.Group,
kind.Version,
this.options.Value.Namespace,
kind.Plural,
name,
body,
gracePeriodSeconds,
orphanDependents,
propagationPolicy,
dryRun,
customHeaders: null,
cancellationToken).ConfigureAwait(false))
{
// It is actually very wrong to return a T from this method, but it's a problem that is deeply rooted
// within the Kubernetes client, see e.g.
// - https://github.com/kubernetes-client/csharp/issues/145
// - https://github.com/kubernetes-client/csharp/issues/475
var status = await this.GetResponseAsync <V1Status>(operationResponse);
return(default);
/// <summary>
/// Asynchronously lists namespaced objects.
/// </summary>
/// <typeparam name="TObject">
/// The type of Kubernetes object to list.
/// </typeparam>
/// <typeparam name="TList">
/// The type of a list which contains the result.
/// </typeparam>
/// <param name="kind">
/// A <see cref="KindMetadata"/> object which describes the type of object to generate,
/// such as the API version or plural name.
/// </param>
/// <param name="allowWatchBookmarks">
/// 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.
/// </param>
/// <param name="continueParameter">
/// 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.
/// </param>
/// <param name="fieldSelector">
/// A selector to restrict the list of returned objects by their fields. Defaults
/// to everything.
/// </param>
/// <param name="labelSelector">
/// A selector to restrict the list of returned objects by their labels. Defaults
/// to everything.
/// </param>
/// <param name="limit">
/// 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.
/// </param>
/// <param name="resourceVersion">
/// 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.
/// </param>
/// <param name="resourceVersionMatch">
/// Determines how resourceVersion is applied to list calls.
/// It is highly recommended that resourceVersionMatch be set for list calls where
/// resourceVersion is set. See <see href="https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions"/>
/// for details. Defaults to unset.
/// </param>
/// <param name="timeoutSeconds">
/// Timeout for the list/watch call. This limits the duration of the call, regardless
/// of any activity or inactivity.
/// </param>
/// <param name="watch">
/// Watch for changes to the described resources and return them as a stream of add,
/// update, and remove notifications.
/// </param>
/// <param name="pretty">
/// If 'true', then the output is pretty printed.
/// </param>
/// <param name="customHeaders">
/// The headers that will be added to request.
/// </param>
/// <param name="cancellationToken">
/// A <see cref="CancellationToken"/> which can be used to cancel the asynchronous operation.
/// </param>
/// <returns>
/// A <see cref="Task"/> which represents the asynchronous operation.
/// </returns>
public async virtual Task <HttpOperationResponse <TList> > ListNamespacedObjectAsync <TObject, TList>(
KindMetadata kind,
bool?allowWatchBookmarks = null,
string?continueParameter = null,
string?fieldSelector = null,
string?labelSelector = null,
int?limit = null,
string?resourceVersion = null,
string?resourceVersionMatch = null,
int?timeoutSeconds = null,
bool?watch = null,
string?pretty = null,
Dictionary <string, List <string> >?customHeaders = null,
CancellationToken cancellationToken = default)
where TList : IItems <TObject>
where TObject : IKubernetesObject <V1ObjectMeta>
{
var operationResponse = await this.RunTaskAsync(this.protocol.ListNamespacedCustomObjectWithHttpMessagesAsync(
kind.Group,
kind.Version,
this.options.Value.Namespace,
kind.Plural,
allowWatchBookmarks: allowWatchBookmarks,
continueParameter: continueParameter,
fieldSelector: fieldSelector,
labelSelector: labelSelector,
limit: limit,
resourceVersion: resourceVersion,
resourceVersionMatch: resourceVersionMatch,
timeoutSeconds: timeoutSeconds,
watch: watch,
pretty: pretty,
customHeaders: customHeaders,
cancellationToken: cancellationToken)).ConfigureAwait(false);
var typedOperationResponse = new HttpOperationResponse <TList>()
{
Request = operationResponse.Request,
Response = operationResponse.Response,
};
if (operationResponse.Response.StatusCode == HttpStatusCode.OK)
{
var responseContent = await operationResponse.Response.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
typedOperationResponse.Body = SafeJsonConvert.DeserializeObject <TList>(responseContent, this.protocol.DeserializationSettings);
}
catch (JsonException ex)
{
throw new SerializationException("Unable to deserialize the response.", responseContent, ex);
}
}
return(typedOperationResponse);
}
/// <summary>
/// Asynchronously creates a new, namespaced object.
/// </summary>
/// <param name="kind">
/// A <see cref="KindMetadata"/> object which describes the type of object to generate,
/// such as the API version or plural name.
/// </param>
/// <param name="value">
/// The object to create.
/// </param>
/// <param name="cancellationToken">
/// A <see cref="CancellationToken"/> which can be used to cancel the asynchronous operation.
/// </param>
/// <returns>
/// A <see cref="Task"/> which represents the asynchronous operation, and returns the newly created object
/// when completed.
/// </returns>
/// <typeparam name="T">
/// The type of object to create.
/// </typeparam>
public virtual async Task <T> CreateNamespacedValueAsync <T>(
KindMetadata kind,
T value,
CancellationToken cancellationToken)
where T : IKubernetesObject <V1ObjectMeta>
{
if (kind == null)
{
throw new ArgumentNullException(nameof(kind));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (value.Metadata == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "value.Metadata");
}
if (value.Metadata.Name == null &&
value.Metadata.GenerateName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "value.Metadata.Name");
}
// Null values will default to the namespace configured in the options. If the caller was explicit about the
// namespace, accept it if it is the configured namespace, and throw if it was not.
if (value.Metadata.NamespaceProperty != null && value.Metadata.NamespaceProperty != this.Options.Namespace)
{
throw new ValidationException(ValidationRules.Pattern, "value.Metadata.NamespaceProperty must match the namespace in the Kubernetes options.");
}
using (var operationResponse = await this.RunTaskAsync(this.protocol.CreateNamespacedCustomObjectWithHttpMessagesAsync(
value,
kind.Group,
kind.Version,
this.Options.Namespace,
kind.Plural,
cancellationToken: cancellationToken)).ConfigureAwait(false))
{
return(await this.GetResponseAsync <T>(operationResponse));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NamespacedKubernetesClient{T}"/> class.
/// </summary>
/// <param name="parent">
/// The parent <see cref="KubernetesClient"/> which provides access to the Kubernetes API.
/// </param>
/// <param name="metadata">
/// Metadata on the current Kubernetes type, used to constructor the URLs used to access
/// the object in the Kubernetes API.
/// </param>
/// <param name="logger">
/// The logger to use when logging.
/// </param>
public NamespacedKubernetesClient(KubernetesClient parent, KindMetadata metadata, ILogger <NamespacedKubernetesClient <T> > logger)
{
this.parent = parent ?? throw new ArgumentNullException(nameof(parent));
this.metadata = metadata ?? throw new ArgumentNullException(nameof(metadata));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
