class SDM::Resources

Public Class Methods

new(host, insecure, parent) click to toggle source

# File lib/svc.rb, line 721
def initialize(host, insecure, parent)
    begin
        if insecure
            @stub = V1::Resources::Stub.new(host, :this_channel_is_insecure)
        else
            cred = GRPC::Core::ChannelCredentials.new()
            @stub = V1::Resources::Stub.new(host, cred)
        end
    rescue => exception
        raise Plumbing::convert_error_to_porcelain(exception)
    end
    @parent = parent
end

Public Instance Methods

create( resource \ , deadline:nil) click to toggle source

Create registers a new Resource.

# File lib/svc.rb, line 735
        def create(
resource \
,
 deadline:nil)
            req = V1::ResourceCreateRequest.new()
                        
            req.resource = Plumbing::convert_resource_to_plumbing(resource)
            tries = 0
            plumbing_response = nil
            loop do
                begin
                    plumbing_response = @stub.create(req, metadata: @parent.get_metadata('Resources.Create', req), deadline:deadline)
                rescue => exception
                    if (@parent.shouldRetry(tries, exception))
                        tries++
                        @parent.jitterSleep(tries)
                        next
                    end
                    raise Plumbing::convert_error_to_porcelain(exception)
                end
                break
            end

                        
            resp = ResourceCreateResponse.new()
            resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
            resp.resource = Plumbing::convert_resource_to_porcelain(plumbing_response.resource)
            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
            resp
        end

delete( id \ , deadline:nil) click to toggle source

Delete removes a Resource by ID.

# File lib/svc.rb, line 828
        def delete(
id \
,
 deadline:nil)
            req = V1::ResourceDeleteRequest.new()
                        
            req.id = (id)
            tries = 0
            plumbing_response = nil
            loop do
                begin
                    plumbing_response = @stub.delete(req, metadata: @parent.get_metadata('Resources.Delete', req), deadline:deadline)
                rescue => exception
                    if (@parent.shouldRetry(tries, exception))
                        tries++
                        @parent.jitterSleep(tries)
                        next
                    end
                    raise Plumbing::convert_error_to_porcelain(exception)
                end
                break
            end

                        
            resp = ResourceDeleteResponse.new()
            resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
            resp
        end

get( id \ , deadline:nil) click to toggle source

Get reads one Resource by ID.

# File lib/svc.rb, line 766
        def get(
id \
,
 deadline:nil)
            req = V1::ResourceGetRequest.new()
                        
            req.id = (id)
            tries = 0
            plumbing_response = nil
            loop do
                begin
                    plumbing_response = @stub.get(req, metadata: @parent.get_metadata('Resources.Get', req), deadline:deadline)
                rescue => exception
                    if (@parent.shouldRetry(tries, exception))
                        tries++
                        @parent.jitterSleep(tries)
                        next
                    end
                    raise Plumbing::convert_error_to_porcelain(exception)
                end
                break
            end

                        
            resp = ResourceGetResponse.new()
            resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
            resp.resource = Plumbing::convert_resource_to_porcelain(plumbing_response.resource)
            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
            resp
        end

list( filter \ , *args, deadline:nil) click to toggle source

List gets a list of Resources matching a given set of criteria.

# File lib/svc.rb, line 858
        def list(
filter \
,
*args,
 deadline:nil)
            req = V1::ResourceListRequest.new()
            req.meta = V1::ListRequestMetadata.new()
            page_size_option = @parent._test_options['PageSize']
            if page_size_option.is_a? Integer
                req.meta.limit = page_size_option
            end
                        
            req.filter = Plumbing::quote_filter_args(filter, *args)
            resp = Enumerator::Generator.new { |g|
                tries = 0
                loop do
                    begin
                        plumbing_response = @stub.list(req, metadata: @parent.get_metadata('Resources.List', req), deadline:deadline)
                    rescue => exception
                        if (@parent.shouldRetry(tries, exception))
                            tries++
                            @parent.jitterSleep(tries)
                            next
                        end
                        raise Plumbing::convert_error_to_porcelain(exception)
                    end
                    tries = 0
                    plumbing_response.resources.each do |plumbing_item|
                        g.yield Plumbing::convert_resource_to_porcelain(plumbing_item)
                    end
                    break if plumbing_response.meta.next_cursor == ""
                    req.meta.cursor = plumbing_response.meta.next_cursor
                end
            }
            resp
        end

update( resource \ , deadline:nil) click to toggle source

Update patches a Resource by ID.

# File lib/svc.rb, line 797
        def update(
resource \
,
 deadline:nil)
            req = V1::ResourceUpdateRequest.new()
                        
            req.resource = Plumbing::convert_resource_to_plumbing(resource)
            tries = 0
            plumbing_response = nil
            loop do
                begin
                    plumbing_response = @stub.update(req, metadata: @parent.get_metadata('Resources.Update', req), deadline:deadline)
                rescue => exception
                    if (@parent.shouldRetry(tries, exception))
                        tries++
                        @parent.jitterSleep(tries)
                        next
                    end
                    raise Plumbing::convert_error_to_porcelain(exception)
                end
                break
            end

                        
            resp = ResourceUpdateResponse.new()
            resp.meta = Plumbing::convert_update_response_metadata_to_porcelain(plumbing_response.meta)
            resp.resource = Plumbing::convert_resource_to_porcelain(plumbing_response.resource)
            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
            resp
        end