class SDM::Nodes

Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes:

Gateways are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers.
Relays are used to extend the strongDM network into segmented subnets. They provide access to databases and servers but do not listen for incoming connections.

Public Class Methods

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

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

Public Instance Methods

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

Create registers a new Node.

# File lib/svc.rb, line 589
        def create(
node \
,
 deadline:nil)
            req = V1::NodeCreateRequest.new()
                        
            req.node = Plumbing::convert_node_to_plumbing(node)
            tries = 0
            plumbing_response = nil
            loop do
                begin
                    plumbing_response = @stub.create(req, metadata: @parent.get_metadata('Nodes.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 = NodeCreateResponse.new()
            resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
            resp.node = Plumbing::convert_node_to_porcelain(plumbing_response.node)
            resp.token = (plumbing_response.token)
            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 Node by ID.

# File lib/svc.rb, line 683
        def delete(
id \
,
 deadline:nil)
            req = V1::NodeDeleteRequest.new()
                        
            req.id = (id)
            tries = 0
            plumbing_response = nil
            loop do
                begin
                    plumbing_response = @stub.delete(req, metadata: @parent.get_metadata('Nodes.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 = NodeDeleteResponse.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 Node by ID.

# File lib/svc.rb, line 621
        def get(
id \
,
 deadline:nil)
            req = V1::NodeGetRequest.new()
                        
            req.id = (id)
            tries = 0
            plumbing_response = nil
            loop do
                begin
                    plumbing_response = @stub.get(req, metadata: @parent.get_metadata('Nodes.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 = NodeGetResponse.new()
            resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
            resp.node = Plumbing::convert_node_to_porcelain(plumbing_response.node)
            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 Nodes matching a given set of criteria.

# File lib/svc.rb, line 713
        def list(
filter \
,
*args,
 deadline:nil)
            req = V1::NodeListRequest.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('Nodes.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.nodes.each do |plumbing_item|
                        g.yield Plumbing::convert_node_to_porcelain(plumbing_item)
                    end
                    break if plumbing_response.meta.next_cursor == ""
                    req.meta.cursor = plumbing_response.meta.next_cursor
                end
            }
            resp
        end

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

Update patches a Node by ID.

# File lib/svc.rb, line 652
        def update(
node \
,
 deadline:nil)
            req = V1::NodeUpdateRequest.new()
                        
            req.node = Plumbing::convert_node_to_plumbing(node)
            tries = 0
            plumbing_response = nil
            loop do
                begin
                    plumbing_response = @stub.update(req, metadata: @parent.get_metadata('Nodes.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 = NodeUpdateResponse.new()
            resp.meta = Plumbing::convert_update_response_metadata_to_porcelain(plumbing_response.meta)
            resp.node = Plumbing::convert_node_to_porcelain(plumbing_response.node)
            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
            resp
        end