In Files

Namespace

DNSSD

DNSSD is a wrapper for the DNS Service Discovery library.

DNSSD.announce and DNSSD::Reply.connect provide an easy-to-use way to announce and connect to services.

The methods DNSSD.enumerate_domains, DNSSD.browse, DNSSD.register, and DNSSD.resolve provide the basic API for making your applications DNS Service Discovery aware.

Constants

VERSION

The version of DNSSD you’re using.

Public Class Methods

announce(socket, name, service = nil, text_record = nil, flags = 0, interface = DNSSD::InterfaceAny, &block) click to toggle source

Registers socket with DNSSD as name. If service is omitted it is looked up using # and the ports address. text_record, flags and interface are used as in #.

Returns the Service created by registering the socket. The Service will automatically be shut down when # or # is called on the socket.

Only for bound TCP and UDP sockets.

    # File lib/dnssd.rb, line 29
29:   def self.announce(socket, name, service = nil, text_record = nil, flags = 0,
30:                     interface = DNSSD::InterfaceAny, &block)
31:     _, port, = socket.addr
32: 
33:     raise ArgumentError, 'socket not bound' if port == 0
34: 
35:     service ||= DNSSD.getservbyport port
36: 
37:     proto = case socket
38:             when TCPSocket then 'tcp'
39:             when UDPSocket then 'udp'
40:             else raise ArgumentError, 'tcp or udp sockets only'
41:             end
42: 
43:     type = "_#{service}._#{proto}"
44: 
45:     registrar = register(name, type, nil, port, text_record, flags, interface,
46:                          &block)
47: 
48:     socket.instance_variable_set :@registrar, registrar
49: 
50:     def socket.close
51:       result = super
52:       @registrar.stop
53:       return result
54:     end
55: 
56:     def socket.close_read
57:       result = super
58:       @registrar.stop
59:       return result
60:     end
61: 
62:     registrar
63:   end
browse(type, domain = nil, flags = 0, interface = DNSSD::InterfaceAny, &block) click to toggle source

Asynchronous version of DNSSD::Service#browse

    # File lib/dnssd.rb, line 68
68:   def self.browse(type, domain = nil, flags = 0,
69:                   interface = DNSSD::InterfaceAny, &block)
70:     service = DNSSD::Service.new
71: 
72:     Thread.start do
73:       run(service, :browse, type, domain, flags, interface, &block)
74:     end
75: 
76:     service
77:   end
browse!(type, domain = nil, flags = 0, interface = DNSSD::InterfaceAny, &block) click to toggle source

Synchronous version of DNSSD::Service#browse

    # File lib/dnssd.rb, line 82
82:   def self.browse!(type, domain = nil, flags = 0,
83:                   interface = DNSSD::InterfaceAny, &block)
84:     service = DNSSD::Service.new
85: 
86:     run(service, :browse, type, domain, flags, interface, &block)
87:   end
enumerate_domains(flags = DNSSD::Flags::BrowseDomains, interface = DNSSD::InterfaceAny, &block) click to toggle source

Asynchronous version of DNSSD::Service#enumerate_domains

     # File lib/dnssd.rb, line 92
 92:   def self.enumerate_domains(flags = DNSSD::Flags::BrowseDomains,
 93:                              interface = DNSSD::InterfaceAny, &block)
 94:     service = DNSSD::Service.new
 95: 
 96:     Thread.start do
 97:       run(service, :enumerate_domains, flags, interface, &block)
 98:     end
 99: 
100:     service
101:   end
enumerate_domains!(flags = DNSSD::Flags::BrowseDomains, interface = DNSSD::InterfaceAny, &block) click to toggle source

Synchronous version of DNSSD::Service#enumerate_domains

     # File lib/dnssd.rb, line 106
106:   def self.enumerate_domains!(flags = DNSSD::Flags::BrowseDomains,
107:                               interface = DNSSD::InterfaceAny, &block)
108:     service = DNSSD::Service.new
109: 
110:     run(service, :enumerate_domains, flags, interface, &block)
111:   end
register(name, type, domain, port, text_record = nil, flags = 0, interface = DNSSD::InterfaceAny, &block) click to toggle source

Asynchronous version of DNSSD::Service#register

     # File lib/dnssd.rb, line 116
116:   def self.register(name, type, domain, port, text_record = nil, flags = 0,
117:                     interface = DNSSD::InterfaceAny, &block)
118:     service = DNSSD::Service.new
119: 
120:     if block_given? then
121:       Thread.start do
122:         run(service, :register, name, type, domain, port, nil, text_record,
123:             flags, interface, &block)
124:       end
125:     else
126:       service.register name, type, domain, port, nil, text_record, flags,
127:                        interface
128:     end
129: 
130:     service
131:   end
register!(name, type, domain, port, text_record = nil, flags = 0, interface = DNSSD::InterfaceAny, &block) click to toggle source

Synchronous version of DNSSD::Service#register

     # File lib/dnssd.rb, line 136
136:   def self.register!(name, type, domain, port, text_record = nil, flags = 0,
137:                      interface = DNSSD::InterfaceAny, &block)
138:     service = DNSSD::Service.new
139: 
140:     if block_given? then
141:       run(service, :register, name, type, domain, port, nil, text_record, flags,
142:           interface, &block)
143:     else
144:       service.register name, type, domain, port, nil, text_record, flags,
145:                        interface
146:     end
147: 
148:     service
149:   end
resolve(*args, &block) click to toggle source

Asynchronous version of DNSSD::Service#resolve

     # File lib/dnssd.rb, line 154
154:   def self.resolve(*args, &block)
155:     service = DNSSD::Service.new
156: 
157:     Thread.start do
158:       run(service, :resolve, *args, &block)
159:     end
160: 
161:     service
162:   end
resolve!(*args, &block) click to toggle source

Synchronous version of DNSSD::Service#resolve

     # File lib/dnssd.rb, line 167
167:   def self.resolve!(*args, &block)
168:     service = DNSSD::Service.new
169: 
170:     run(service, :resolve, *args, &block)
171:   end
run(service, method, *args, &block) click to toggle source

Dispatches args and block to method on service and ensures service is shut down after use.

     # File lib/dnssd.rb, line 177
177:   def self.run(service, method, *args, &block)
178:     service.send(method, *args, &block)
179: 
180:     service
181:   ensure
182:     service.stop unless service.stopped?
183:   end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.