Class: DRbService

Inherits:
Object
  • Object
show all
Includes:
Logging, DRbUndumped
Defined in:
lib/drbservice.rb,
lib/drbservice/utils.rb

Overview

A base class for DRb-based services. Concrete subclasses must define the service API by declaring public methods. By default, any public methods are hidden until the client authenticates. You can optionally declare a subset of its API that is # accessible before authentication by wrapping them in an 'unguarded' block. # See DRbService::unguarded for more details.

Defined Under Namespace

Modules: ANSIColorUtilities, LDAPAuthentication, Logging, PasswordAuthentication Classes: ColorLogFormatter, HtmlLogFormatter, LogFormatter

Constant Summary collapse

VERSION =

Library version

'1.0.4'
REVISION =

Version-control revision

%$Revision: 59c8e5acd8bb $
DEFAULT_IP =

The default IP address to listen on

'127.0.0.1'
DEFAULT_PORT =

The default port to listen on

4848
DEFAULT_CERTNAME =

The default path to the service cert, relative to the current directory

'service-cert.pem'
DEFAULT_KEYNAME =

The default path to the service key, relative to the current directory

'service-key.pem'
DEFAULT_CONFIG =

The default values for the drbservice config hash

{
  :ip       => DEFAULT_IP,
  :port     => DEFAULT_PORT,
  :certfile => DEFAULT_CERTNAME,
  :keyfile  => DEFAULT_KEYNAME,
}

Constants included from Logging

Logging::LEVEL

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Logging

included, #initialize_copy, #log, #log_debug

Constructor Details

#initialize(config = {}) ⇒ DRbService

Create a new instance of the service. Raises a ScriptError if DRbService is instantiated directly.

Raises:

  • (ScriptError) 


146
147
148
149
150
151
 
# File 'lib/drbservice.rb', line 146

def initialize( config={} )
  raise ScriptError,
    "can't instantiate #{self.class} directly: please subclass it instead" if
    self.class == DRbService
  @authenticated = false
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(sym, *args) ⇒ Object (protected)

Handle calls to guarded methods by requiring the authentication flag be set if there is a password set.



194
195
196
197
198
199
200
201
202
203
 
# File 'lib/drbservice.rb', line 194

def method_missing( sym, *args )
  return super unless body = self.class.real_methods[ sym ]

  if self.authorized?
    return body.clone.bind( self ).call( *args )
  else
    self.log.error "Guarded method %p called without authentication!" % [ sym ]
    raise SecurityError, "not authenticated"
  end
end

Class Attribute Details

.real_methods ⇒ Object (readonly)

Returns the value of attribute real_methods.



45
46
47
 
# File 'lib/drbservice.rb', line 45

def real_methods
  @real_methods
end

.unguarded_mode ⇒ Object

The unguarded mode flag -- instance methods defined while this flag is set will not be hidden



135
136
137
 
# File 'lib/drbservice.rb', line 135

def unguarded_mode
  @unguarded_mode
end

Class Method Details

.inherited(subclass) ⇒ Object

Inheritance callback: Add a per-class 'unguarded mode' flag to subclasses.



105
106
107
108
109
 
# File 'lib/drbservice.rb', line 105

def self::inherited( subclass )
  self.log.debug "Setting @unguarded_mode in %p" % [ subclass ]
  subclass.instance_variable_set( :@unguarded_mode, false )
  super
end

.method_added(meth) ⇒ Object

Method-addition callback: Obscure the method meth unless unguarded mode is enabled.



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/drbservice.rb', line 86

def self::method_added( meth )
  super

  unless self == ::DRbService || meth.to_sym == :initialize
    if !self.public_instance_methods.collect( &:to_sym ).include?( meth )
      DRbService.log.debug "Not obsuring %p#%s: not a public method" % [ self, meth ]
    elsif self.unguarded_mode
      DRbService.log.debug "Not obscuring %p#%s: unguarded mode." % [ self, meth ]
    else
      DRbService.log.debug "Obscuring %p#%s." % [ self, meth ]
      @real_methods ||= {}
      @real_methods[ meth.to_sym ] = self.instance_method( meth )
      remove_method( meth )
    end
  end
end

.start(config = {}) ⇒ Object

Start the DRbService, using the ip, port, and cert information from the given config hash.

[:ip] the ip to bind to [:port] the port to listen on [:certfile] the name of the server's SSL certificate file [:keyfile] the name of the server's SSL key file



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/drbservice.rb', line 61

def self::start( config={} )
  config = DEFAULT_CONFIG.merge( config )

  frontobj = self.new( config )
  uri = "drbssl://%s:%d" % config.values_at( :ip, :port )

  cert = OpenSSL::X509::Certificate.new( File.read(config[:certfile]) )
  key  = OpenSSL::PKey::RSA.new( File.read(config[:keyfile]) )

  config = {
    :safe_level     => 1,
    :verbose        => true,
        :SSLCertificate => cert,
        :SSLPrivateKey  => key,
  }

  DRbService.log.info "Starting %p as a DRbService at %s" % [ self, uri ]
  server = DRb::DRbServer.new( uri, frontobj, config )
  DRbService.log.debug "  started. Joining the DRb thread."
  $0 = "%s %s" % [ self.name, uri ]
  server.thread.join
end

.unguarded ⇒ Object

Declare some service methods that can be called without authentication in the provided block.



114
115
116
117
118
119
 
# File 'lib/drbservice.rb', line 114

def self::unguarded
  self.unguarded_mode = true
  yield
ensure
  self.unguarded_mode = false
end

.version_string(include_buildnum = false) ⇒ Object

Return the library's version string



123
124
125
126
127
 
# File 'lib/drbservice.rb', line 123

def self::version_string( include_buildnum=false )
  vstring = "%s %s" % [ self.name, VERSION ]
  vstring << " (build %s)" % [ REVISION[/.*: ([[:xdigit:]]+)/, 1] || '0' ] if include_buildnum
  return vstring
end

Instance Method Details

#authenticate(*args) ⇒ Object

Default authentication implementation -- always fails. You'll need to include one of the authentication modules or provide your own #authenticate method in your subclass.

Raises:

  • (SecurityError) 


182
183
184
185
 
# File 'lib/drbservice.rb', line 182

def authenticate( *args )
  self.log.error "authentication failure (fallback method)"
  raise SecurityError, "authentication failure"
end

#authenticated? ⇒ Boolean

Returns true if the client has successfully authenticated.

Returns:

  • (Boolean) 


165
166
167
 
# File 'lib/drbservice.rb', line 165

def authenticated?
  return @authenticated ? true : false
end

#authorized? ⇒ Boolean

Returns true if the client has successfully authenticated and is authorized to use the service. By default, authentication is sufficient for authorization; to specify otherwise, override this method in your service's subclass or include an auth mixin that provides one.

Returns:

  • (Boolean) 


174
175
176
 
# File 'lib/drbservice.rb', line 174

def authorized?
  return self.authenticated?
end

#inspect ⇒ Object

Return a human-readable representation of the object.



159
160
161
 
# File 'lib/drbservice.rb', line 159

def inspect
  return "#<%s:0x%0x>" % [ self.class, self.__id__ * 2 ]
end