JezK

Edit File: os_management_client_composite_operations.py

# coding: utf-8
# Copyright (c) 2016, 2024, Oracle and/or its affiliates.  All rights reserved.
# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.

# NOTE: This class is auto generated by OracleSDKGenerator. DO NOT EDIT. API Version: 20190801

import oci  # noqa: F401
from oci.util import WAIT_RESOURCE_NOT_FOUND  # noqa: F401

class OsManagementClientCompositeOperations(object):
    """
    This class provides a wrapper around :py:class:`~oci.os_management.OsManagementClient` and offers convenience methods
    for operations that would otherwise need to be chained together. For example, instead of performing an action
    on a resource (e.g. launching an instance, creating a load balancer) and then using a waiter to wait for the resource
    to enter a given state, you can call a single method in this class to accomplish the same functionality
    """

def __init__(self, client, **kwargs):
        """
        Creates a new OsManagementClientCompositeOperations object

:param OsManagementClient client:
            The service client which will be wrapped by this object
        """
        self.client = client

def create_managed_instance_group_and_wait_for_state(self, create_managed_instance_group_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.create_managed_instance_group` and waits for the :py:class:`~oci.os_management.models.ManagedInstanceGroup` acted upon
        to enter the given state(s).

:param oci.os_management.models.CreateManagedInstanceGroupDetails create_managed_instance_group_details: (required)
            Details about a Managed Instance Group to create

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.ManagedInstanceGroup.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.create_managed_instance_group`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.create_managed_instance_group(create_managed_instance_group_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        managed_instance_group_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_managed_instance_group(managed_instance_group_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except (NameError, TypeError) as e:
            if not e.args:
                e.args = ('',)
            e.args = e.args + ('This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"', )
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def create_scheduled_job_and_wait_for_state(self, create_scheduled_job_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.create_scheduled_job` and waits for the :py:class:`~oci.os_management.models.ScheduledJob` acted upon
        to enter the given state(s).

:param oci.os_management.models.CreateScheduledJobDetails create_scheduled_job_details: (required)
            Details about a Scheduled Job to create

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.ScheduledJob.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.create_scheduled_job`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.create_scheduled_job(create_scheduled_job_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        scheduled_job_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_scheduled_job(scheduled_job_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

def create_software_source_and_wait_for_state(self, create_software_source_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.create_software_source` and waits for the :py:class:`~oci.os_management.models.SoftwareSource` acted upon
        to enter the given state(s).

:param oci.os_management.models.CreateSoftwareSourceDetails create_software_source_details: (required)
            Details about a Sofware Source to create

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.SoftwareSource.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.create_software_source`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.create_software_source(create_software_source_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        software_source_id = operation_result.data.id

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_software_source(software_source_id),  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

def delete_managed_instance_group_and_wait_for_state(self, managed_instance_group_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.delete_managed_instance_group` and waits for the :py:class:`~oci.os_management.models.ManagedInstanceGroup` acted upon
        to enter the given state(s).

:param str managed_instance_group_id: (required)
            OCID for the managed instance group

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.ManagedInstanceGroup.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.delete_managed_instance_group`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        initial_get_result = self.client.get_managed_instance_group(managed_instance_group_id)
        operation_result = None
        try:
            operation_result = self.client.delete_managed_instance_group(managed_instance_group_id, **operation_kwargs)
        except oci.exceptions.ServiceError as e:
            if e.status == 404:
                return WAIT_RESOURCE_NOT_FOUND
            else:
                raise e

if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]

try:
            if ("succeed_on_not_found" in waiter_kwargs) and (waiter_kwargs["succeed_on_not_found"] is False):
                self.client.base_client.logger.warning("The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_managed_instance_group, this would result in the operation to fail if the resource is not found! Please, do not pass this kwarg if this was not intended")
            else:
                """
                If the user does not send in this value, we set it to True by default.
                We are doing this because during a delete resource scenario and waiting on its state, the service can
                return a 404 NOT FOUND exception as the resource was deleted and a get on its state would fail
                """
                waiter_kwargs["succeed_on_not_found"] = True
            waiter_result = oci.wait_until(
                self.client,
                initial_get_result,  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

def delete_scheduled_job_and_wait_for_state(self, scheduled_job_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.delete_scheduled_job` and waits for the :py:class:`~oci.os_management.models.ScheduledJob` acted upon
        to enter the given state(s).

:param str scheduled_job_id: (required)
            The ID of the scheduled job.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.ScheduledJob.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.delete_scheduled_job`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        initial_get_result = self.client.get_scheduled_job(scheduled_job_id)
        operation_result = None
        try:
            operation_result = self.client.delete_scheduled_job(scheduled_job_id, **operation_kwargs)
        except oci.exceptions.ServiceError as e:
            if e.status == 404:
                return WAIT_RESOURCE_NOT_FOUND
            else:
                raise e

if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]

try:
            if ("succeed_on_not_found" in waiter_kwargs) and (waiter_kwargs["succeed_on_not_found"] is False):
                self.client.base_client.logger.warning("The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_scheduled_job, this would result in the operation to fail if the resource is not found! Please, do not pass this kwarg if this was not intended")
            else:
                """
                If the user does not send in this value, we set it to True by default.
                We are doing this because during a delete resource scenario and waiting on its state, the service can
                return a 404 NOT FOUND exception as the resource was deleted and a get on its state would fail
                """
                waiter_kwargs["succeed_on_not_found"] = True
            waiter_result = oci.wait_until(
                self.client,
                initial_get_result,  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

def delete_software_source_and_wait_for_state(self, software_source_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.delete_software_source` and waits for the :py:class:`~oci.os_management.models.SoftwareSource` acted upon
        to enter the given state(s).

:param str software_source_id: (required)
            The OCID of the software source.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.SoftwareSource.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.delete_software_source`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        initial_get_result = self.client.get_software_source(software_source_id)
        operation_result = None
        try:
            operation_result = self.client.delete_software_source(software_source_id, **operation_kwargs)
        except oci.exceptions.ServiceError as e:
            if e.status == 404:
                return WAIT_RESOURCE_NOT_FOUND
            else:
                raise e

if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]

try:
            if ("succeed_on_not_found" in waiter_kwargs) and (waiter_kwargs["succeed_on_not_found"] is False):
                self.client.base_client.logger.warning("The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_software_source, this would result in the operation to fail if the resource is not found! Please, do not pass this kwarg if this was not intended")
            else:
                """
                If the user does not send in this value, we set it to True by default.
                We are doing this because during a delete resource scenario and waiting on its state, the service can
                return a 404 NOT FOUND exception as the resource was deleted and a get on its state would fail
                """
                waiter_kwargs["succeed_on_not_found"] = True
            waiter_result = oci.wait_until(
                self.client,
                initial_get_result,  # noqa: F821
                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

def disable_module_stream_on_managed_instance_and_wait_for_state(self, managed_instance_id, module_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.disable_module_stream_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param str module_name: (required)
            The name of a module.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.disable_module_stream_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.disable_module_stream_on_managed_instance(managed_instance_id, module_name, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

try:
            waiter_result = oci.wait_until(
                self.client,
                self.client.get_work_request(wait_for_resource_id),
                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
                **waiter_kwargs
            )
            result_to_return = waiter_result

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def enable_module_stream_on_managed_instance_and_wait_for_state(self, managed_instance_id, module_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.enable_module_stream_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param str module_name: (required)
            The name of a module.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.enable_module_stream_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.enable_module_stream_on_managed_instance(managed_instance_id, module_name, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def get_module_stream_and_wait_for_state(self, software_source_id, module_name, stream_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.get_module_stream` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str software_source_id: (required)
            The OCID of the software source.

:param str module_name: (required)
            The name of the module

:param str stream_name: (required)
            The name of the stream of the containing module

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.get_module_stream`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.get_module_stream(software_source_id, module_name, stream_name, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def get_module_stream_profile_and_wait_for_state(self, software_source_id, module_name, stream_name, profile_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.get_module_stream_profile` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str software_source_id: (required)
            The OCID of the software source.

:param str module_name: (required)
            The name of the module

:param str stream_name: (required)
            The name of the stream of the containing module

:param str profile_name: (required)
            The name of the profile of the containing module stream

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.get_module_stream_profile`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.get_module_stream_profile(software_source_id, module_name, stream_name, profile_name, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def install_all_package_updates_on_managed_instance_and_wait_for_state(self, managed_instance_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.install_all_package_updates_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.install_all_package_updates_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.install_all_package_updates_on_managed_instance(managed_instance_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def install_all_updates_on_managed_instance_group_and_wait_for_state(self, managed_instance_group_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.install_all_updates_on_managed_instance_group` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_group_id: (required)
            OCID for the managed instance group

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.install_all_updates_on_managed_instance_group`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.install_all_updates_on_managed_instance_group(managed_instance_group_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def install_all_windows_updates_on_managed_instance_and_wait_for_state(self, managed_instance_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.install_all_windows_updates_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.install_all_windows_updates_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.install_all_windows_updates_on_managed_instance(managed_instance_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def install_module_stream_profile_on_managed_instance_and_wait_for_state(self, managed_instance_id, module_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.install_module_stream_profile_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param str module_name: (required)
            The name of a module.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.install_module_stream_profile_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.install_module_stream_profile_on_managed_instance(managed_instance_id, module_name, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def install_package_on_managed_instance_and_wait_for_state(self, managed_instance_id, software_package_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.install_package_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param str software_package_name: (required)
            Package name

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.install_package_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.install_package_on_managed_instance(managed_instance_id, software_package_name, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def install_package_update_on_managed_instance_and_wait_for_state(self, managed_instance_id, software_package_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.install_package_update_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param str software_package_name: (required)
            Package name

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.install_package_update_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.install_package_update_on_managed_instance(managed_instance_id, software_package_name, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def install_windows_update_on_managed_instance_and_wait_for_state(self, managed_instance_id, windows_update_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.install_windows_update_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param str windows_update_name: (required)
            Unique identifier for the Windows update. NOTE - This is not an OCID,
            but is a unique identifier assigned by Microsoft.
            Example: `6981d463-cd91-4a26-b7c4-ea4ded9183ed`

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.install_windows_update_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.install_windows_update_on_managed_instance(managed_instance_id, windows_update_name, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def list_module_stream_profiles_and_wait_for_state(self, software_source_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.list_module_stream_profiles` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str software_source_id: (required)
            The OCID of the software source.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.list_module_stream_profiles`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.list_module_stream_profiles(software_source_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def list_module_stream_profiles_on_managed_instance_and_wait_for_state(self, managed_instance_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.list_module_stream_profiles_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.list_module_stream_profiles_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.list_module_stream_profiles_on_managed_instance(managed_instance_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def list_module_streams_and_wait_for_state(self, software_source_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.list_module_streams` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str software_source_id: (required)
            The OCID of the software source.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.list_module_streams`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.list_module_streams(software_source_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def list_module_streams_on_managed_instance_and_wait_for_state(self, managed_instance_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.list_module_streams_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.list_module_streams_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.list_module_streams_on_managed_instance(managed_instance_id, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def manage_module_streams_on_managed_instance_and_wait_for_state(self, managed_instance_id, manage_module_streams_on_managed_instance_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.manage_module_streams_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param oci.os_management.models.ManageModuleStreamsOnManagedInstanceDetails manage_module_streams_on_managed_instance_details: (required)
            A description of an operation to perform against the modules, streams, and profiles of a managed instance

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.manage_module_streams_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.manage_module_streams_on_managed_instance(managed_instance_id, manage_module_streams_on_managed_instance_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def remove_module_stream_profile_from_managed_instance_and_wait_for_state(self, managed_instance_id, module_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.remove_module_stream_profile_from_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param str module_name: (required)
            The name of a module.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.remove_module_stream_profile_from_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.remove_module_stream_profile_from_managed_instance(managed_instance_id, module_name, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def remove_package_from_managed_instance_and_wait_for_state(self, managed_instance_id, software_package_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.remove_package_from_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param str software_package_name: (required)
            Package name

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.remove_package_from_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.remove_package_from_managed_instance(managed_instance_id, software_package_name, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def switch_module_stream_on_managed_instance_and_wait_for_state(self, managed_instance_id, module_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.switch_module_stream_on_managed_instance` and waits for the :py:class:`~oci.os_management.models.WorkRequest`
        to enter the given state(s).

:param str managed_instance_id: (required)
            OCID for the managed instance

:param str module_name: (required)
            The name of a module.

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.WorkRequest.status`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.switch_module_stream_on_managed_instance`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.switch_module_stream_on_managed_instance(managed_instance_id, module_name, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        if 'opc-work-request-id' not in operation_result.headers:
            return operation_result
        wait_for_resource_id = operation_result.headers['opc-work-request-id']

return result_to_return
        except Exception as e:
            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)

def update_managed_instance_group_and_wait_for_state(self, managed_instance_group_id, update_managed_instance_group_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.update_managed_instance_group` and waits for the :py:class:`~oci.os_management.models.ManagedInstanceGroup` acted upon
        to enter the given state(s).

:param str managed_instance_group_id: (required)
            OCID for the managed instance group

:param oci.os_management.models.UpdateManagedInstanceGroupDetails update_managed_instance_group_details: (required)
            Details about a Managed Instance Group to update

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.ManagedInstanceGroup.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.update_managed_instance_group`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.update_managed_instance_group(managed_instance_group_id, update_managed_instance_group_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        managed_instance_group_id = operation_result.data.id

def update_scheduled_job_and_wait_for_state(self, scheduled_job_id, update_scheduled_job_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.update_scheduled_job` and waits for the :py:class:`~oci.os_management.models.ScheduledJob` acted upon
        to enter the given state(s).

:param str scheduled_job_id: (required)
            The ID of the scheduled job.

:param oci.os_management.models.UpdateScheduledJobDetails update_scheduled_job_details: (required)
            Details about a Scheduled Job to update

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.ScheduledJob.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.update_scheduled_job`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.update_scheduled_job(scheduled_job_id, update_scheduled_job_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        scheduled_job_id = operation_result.data.id

def update_software_source_and_wait_for_state(self, software_source_id, update_software_source_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
        """
        Calls :py:func:`~oci.os_management.OsManagementClient.update_software_source` and waits for the :py:class:`~oci.os_management.models.SoftwareSource` acted upon
        to enter the given state(s).

:param str software_source_id: (required)
            The OCID of the software source.

:param oci.os_management.models.UpdateSoftwareSourceDetails update_software_source_details: (required)
            Details about a Sofware Source to update

:param list[str] wait_for_states:
            An array of states to wait on. These should be valid values for :py:attr:`~oci.os_management.models.SoftwareSource.lifecycle_state`

:param dict operation_kwargs:
            A dictionary of keyword arguments to pass to :py:func:`~oci.os_management.OsManagementClient.update_software_source`

:param dict waiter_kwargs:
            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
        """
        operation_result = self.client.update_software_source(software_source_id, update_software_source_details, **operation_kwargs)
        if not wait_for_states:
            return operation_result
        lowered_wait_for_states = [w.lower() for w in wait_for_states]
        software_source_id = operation_result.data.id

HOME - Twin Oaks Custom Cabinets

IMAGINE
making memories with family in your new kitchen
IMAGINE
entertaining friends around your new island
IMAGINE
waking up to your dream kitchen
IMAGINE
looking forward to doing laundry

1 2 3 4

FINEST QUALITY CUSTOM CABINETRY

FOR HOME BUILDERS, REMODEL CONTRACTORS, HOMEOWNERS, & COMMERCIAL CONTRACTORS

Twin Oaks Custom Cabinets Inc. is a family owned and operated company that has been built on quality craftsmanship and the idea that we want to treat our customers the way we would want to be treated. This means we will strive to make sure each and every customer not only gets high quality custom cabinets, but also receives outstanding service. To accomplish these goals we have assembled a veteran team of salespeople, skilled cabinetmakers and knowledgeable after sales support staff. Contact us today to experience for yourself the Twin Oaks difference.

Learn More

Home Page At Bottom (Next to text under - finest quality)-min

LOOKING FOR DESIGN INSPIRATION?

view our gallery of styles, colors & hardware options

VIEW GALLERY

IMAGINE

IMAGINE

IMAGINE

IMAGINE

FINEST QUALITY CUSTOM CABINETRY

LOOKING FOR DESIGN INSPIRATION?

view our gallery of styles, colors & hardware options

PHOTO GALLERIES

Twin Oaks Table