Subversion Info

Rev
437
Last Checked In
2008-03-28 00:49:20 (2 weeks ago)
Checked in by
deveiant

Parent

Arrow::Object

Class Index

Quicksearch

Arrow::Broker

Instance of this class contain a map of applets registered to a given location..

Constants

SVNRev
SVN Revision
SVNId
SVN Id
FILE_SEPARATOR
A regular expression that matches the file separator on this system

Attributes

registry[RW]
The Hash of RegistryEntry structs keyed by uri
start_time[R]
The Time when the Broker was started

Public Class Methods

new( config ) click to toggle source

Create a new Arrow::Broker object from the specified config (an Arrow::Config object). 

    # File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 47
47:     def initialize( config )
48:         @config = config
49:         @registry = Arrow::AppletRegistry.new( config )
50:         @start_time = Time.now
51:     end

Public Instance Methods

delegate( txn ) click to toggle source

Dispatch the specified transaction txn to the appropriate handler based on the request‘s path_info. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 68
 68:     def delegate( txn )
 69:         rval = appletchain = nil
 70:         self.log.debug "Start of delegation (%s)" % [ txn.unparsed_uri ]
 71: 
 72:         # Fetch the path and trim the leading '/'
 73:         path = txn.path
 74:         path.sub!( %r{^/}, '' )
 75:         self.log.debug "Request's path is %p" % path
 76: 
 77:         # Check for updated/deleted/added applets
 78:         @registry.check_for_updates
 79: 
 80:         # Get the chain of applets to execute for the request
 81:         appletchain = @registry.find_applet_chain( path )
 82: 
 83:         # If the pathinfo doesn't correspond to at least one applet, run
 84:         # the no-such-applet handler.
 85:         if appletchain.empty?
 86:             rval = self.run_missing_applet_handler( txn, path )
 87:         else
 88:             rval = self.run_applet_chain( txn, appletchain )
 89:         end
 90: 
 91:         # Set the request status to declined if it hasn't been set yet and
 92:         # the return value is false.
 93:         if !rval
 94:             self.log.error "Applet returned false value. " +
 95:                 "Setting status to DECLINED"
 96:             txn.status = Apache::DECLINED
 97:         end
 98: 
 99:         # self.log.debug "Returning %p" % [ rval ]
100:         return rval
101:     end

Protected Instance Methods

builtin_missing_handler( txn, *args ) click to toggle source

The builtin missing-applet handler routine. Returns false, which causes the dispatcher to decline the request. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 214
214:     def builtin_missing_handler( txn, *args )
215:         self.log.notice "Using builtin missing-applet handler."
216:         return false
217:     end
default_error_handler( applet, txn, err ) click to toggle source

The builtin error handler routine. Outputs a plain-text backtrace for the given exception err and applet to the given transaction txn. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 256
256:     def default_error_handler( applet, txn, err )
257:         self.log.notice "Using builtin error handler."
258:         txn.request.content_type = "text/plain"
259:         txn.status = Apache::OK
260: 
261:         return "Arrow Applet Error in '%s': %s\n\t%s" %
262:             [ applet.class.signature.name, err.message, err.backtrace.join("\n\t") ]
263:     end
run_applet( applet, txn, rest ) click to toggle source

Run the specified applet with the given txn (an Arrow::Transaction) and the rest of the path_info split on ’/’. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 171
171:     def run_applet( applet, txn, rest )
172:         self.log.debug "Running '%s' with args: %p" %
173:             [ applet.signature.name, rest ]
174:         return applet.run( txn, *rest )
175:     rescue ::Exception => err
176:         self.log.error "[%s]: Error running %s (%s): %s:\n\t%s" % [
177:             txn.serial,
178:             applet.signature.name,
179:             applet.class.filename,
180:             err.message,
181:             err.backtrace.join("\n\t"),
182:         ]
183:         return self.run_error_handler( applet, txn, err )
184:     end
run_applet_chain( txn, chain ) click to toggle source

Given a chain of applets built from a URI, run the +index+th one with the specified transaction (txn). Applets before the last get called via their #delegate method, while the last one is called via #run. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 111
111:     def run_applet_chain( txn, chain )
112:         self.log.debug "Running applet chain: #{chain.inspect}"
113:         raise Arrow::AppletError, "Malformed applet chain" if
114:             chain.empty? || !chain.first.respond_to?( :applet )
115: 
116:         res = nil
117:         applet, txn.applet_path, args = self.unwrap_chain_link( chain.first )
118: 
119:         # If there's only one item left, run it
120:         if chain.nitems == 1
121:             self.log.debug "Running final applet in chain"
122:             res = self.run_applet( applet, txn, args )
123: 
124:         # Otherwise, delegate the transaction to the next applet with the
125:         # remainder of the chain.
126:         else
127:             dchain = chain[ 1..-1 ]
128:             self.log.debug "Running applet %s in chain of %d; chain = %p" %
129:                 [ applet.signature.name, chain.nitems, dchain ]
130: 
131:             begin
132:                 res = applet.delegate( txn, dchain, *args ) do |subchain|
133:                     subchain = dchain if subchain.nil?
134:                     self.log.debug "Delegated call to appletchain %p" % [ subchain ]
135:                     self.run_applet_chain( txn, subchain )
136:                 end
137:             rescue ::Exception => err
138:                 self.log.error "Error while executing applet chain: %p (/%s): %s:\n\t%s" % [
139:                     applet,
140:                     chain.first[1],
141:                     err.message,
142:                     err.backtrace.join("\n\t"),
143:                 ]
144:                 res = self.run_error_handler( applet, txn, err )
145:             end
146:         end
147: 
148:         return res
149:     end
run_error_handler( applet, txn, err ) click to toggle source

Handle the given applet error err for the specified applet, using the given transaction txn. This will attempt to run whatever applet is configured as the error-handler, or run a builtin handler applet if none is configured or the configured one isn‘t loaded. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 224
224:     def run_error_handler( applet, txn, err )
225:         rval = nil
226:         handlerName = @config.applets.errorApplet.sub( %r{^/}, '' )
227: 
228:         unless handlerName == "(builtin)" or !@registry.key?( handlerName )
229:             handler = @registry[handlerName]
230:             self.log.notice "Running error handler applet '%s' (%s)" %
231:                 [ handler.signature.name, handlerName ]
232: 
233:             begin
234:                 rval = handler.run( txn, "report_error", applet, err )
235:             rescue ::Exception => err2
236:                 self.log.error "Error while attempting to use custom error "\
237:                 "handler '%s': %s\n\t%s" % [
238:                     handler.signature.name,
239:                     err2.message,
240:                     err2.backtrace.join("\n\t"),
241:                 ]
242: 
243:                 rval = self.default_error_handler( applet, txn, err )
244:             end
245:         else
246:             rval = self.default_error_handler( applet, txn, err )
247:         end
248: 
249:         return rval
250:     end
run_missing_applet_handler( txn, uri ) click to toggle source

Handle requests that target an applet that doesn‘t exist. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 188
188:     def run_missing_applet_handler( txn, uri )
189:         rval = appletchain = nil
190:         handlerUri = @config.applets.missingApplet
191:         args = uri.split( %r{/} )
192: 
193:         # Build an applet chain for user-configured handlers
194:         if handlerUri != "(builtin)"
195:             appletchain = @registry.find_applet_chain( handlerUri )
196:             self.log.error "Configured MissingApplet handler (%s) doesn't exist" %
197:                 handlerUri if appletchain.empty?
198:         end
199: 
200:         # If the user-configured handler maps to one or more handlers, run
201:         # them. Otherwise, run the build-in handler.
202:         unless appletchain.nil? || appletchain.empty?
203:             rval = self.run_applet_chain( txn, appletchain )
204:         else
205:             rval = self.builtin_missing_handler( txn, *args )
206:         end
207: 
208:         return rval
209:     end
unwrap_chain_link( link ) click to toggle source

Check the specified link of an applet chain for sanity and return its constituent bits for assignment. This is necessary to provide sensible errors if a delegating app screws up a chain somehow. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 155
155:     def unwrap_chain_link( link )
156:         applet = link.applet or raise Arrow::AppletChainError, "Null applet"
157:         path = link.path or raise Arrow::AppletChainError, "Null path"
158:         args = link.args or raise Arrow::AppletChainError, "Null argument list"
159:         unless args.is_a?( Array )
160:             emsg = "Argument list is a %s: expected an Array" %
161:                 args.class.name
162:             raise Arrow::AppletChainError, emsg
163:         end                   
164: 
165:         return applet, path, args
166:     end

secsequence

--- SEC00025

seccomment

--- ""

attributes

--- 
- name: registry
  rw: RW
  a_desc: |+
    
    The Hash of RegistryEntry structs keyed by uri
    
- name: start_time
  rw: R
  a_desc: |+
    
    The Time when the <a href="Broker.html">Broker</a> was started

method_list

--- 
- methods: 
  - visibility: public
    aref: M000341
    name: new
    sourcecode: "    <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 47</span>\n\
      47:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">initialize</span>( <span class=\"ruby-identifier\">config</span> )\n\
      48:         <span class=\"ruby-ivar\">@config</span> = <span class=\"ruby-identifier\">config</span>\n\
      49:         <span class=\"ruby-ivar\">@registry</span> = <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AppletRegistry</span>.<span class=\"ruby-identifier\">new</span>( <span class=\"ruby-identifier\">config</span> )\n\
      50:         <span class=\"ruby-ivar\">@start_time</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>\n\
      51:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Create a <a href="Broker.html#M000341">new</a> <a
      href="Broker.html">Arrow::Broker</a> object from the specified
      <tt>config</tt> (an <a href="Config.html">Arrow::Config</a> object).
      </p>
    params: ( config )
  category: Class
  type: Public
- methods: 
  - visibility: public
    aref: M000342
    name: delegate
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 68</span>\n 68:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">delegate</span>( <span class=\"ruby-identifier\">txn</span> )\n 69:         <span class=\"ruby-identifier\">rval</span> = <span class=\"ruby-identifier\">appletchain</span> = <span class=\"ruby-keyword kw\">nil</span>\n 70:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">debug</span> <span class=\"ruby-value str\">&quot;Start of delegation (%s)&quot;</span> <span class=\"ruby-operator\">%</span> [ <span class=\"ruby-identifier\">txn</span>.<span class=\"ruby-identifier\">unparsed_uri</span> ]\n 71: \n 72:         <span class=\"ruby-comment cmt\"># Fetch the path and trim the leading '/'</span>\n 73:         <span class=\"ruby-identifier\">path</span> = <span class=\"ruby-identifier\">txn</span>.<span class=\"ruby-identifier\">path</span>\n 74:         <span class=\"ruby-identifier\">path</span>.<span class=\"ruby-identifier\">sub!</span>( <span class=\"ruby-regexp re\">%r{^/}</span>, <span class=\"ruby-value str\">''</span> )\n 75:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">debug</span> <span class=\"ruby-value str\">&quot;Request's path is %p&quot;</span> <span class=\"ruby-operator\">%</span> <span class=\"ruby-identifier\">path</span>\n 76: \n 77:         <span class=\"ruby-comment cmt\"># Check for updated/deleted/added applets</span>\n 78:         <span class=\"ruby-ivar\">@registry</span>.<span class=\"ruby-identifier\">check_for_updates</span>\n 79: \n 80:         <span class=\"ruby-comment cmt\"># Get the chain of applets to execute for the request</span>\n 81:         <span class=\"ruby-identifier\">appletchain</span> = <span class=\"ruby-ivar\">@registry</span>.<span class=\"ruby-identifier\">find_applet_chain</span>( <span class=\"ruby-identifier\">path</span> )\n 82: \n 83:         <span class=\"ruby-comment cmt\"># If the pathinfo doesn't correspond to at least one applet, run</span>\n 84:         <span class=\"ruby-comment cmt\"># the no-such-applet handler.</span>\n 85:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">appletchain</span>.<span class=\"ruby-identifier\">empty?</span>\n 86:             <span class=\"ruby-identifier\">rval</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">run_missing_applet_handler</span>( <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">path</span> )\n 87:         <span class=\"ruby-keyword kw\">else</span>\n 88:             <span class=\"ruby-identifier\">rval</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">run_applet_chain</span>( <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">appletchain</span> )\n 89:         <span class=\"ruby-keyword kw\">end</span>\n 90: \n 91:         <span class=\"ruby-comment cmt\"># Set the request status to declined if it hasn't been set yet and</span>\n 92:         <span class=\"ruby-comment cmt\"># the return value is false.</span>\n 93:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-operator\">!</span><span class=\"ruby-identifier\">rval</span>\n 94:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">error</span> <span class=\"ruby-value str\">&quot;Applet returned false value. &quot;</span> <span class=\"ruby-operator\">+</span>\n 95:                 <span class=\"ruby-value str\">&quot;Setting status to DECLINED&quot;</span>\n 96:             <span class=\"ruby-identifier\">txn</span>.<span class=\"ruby-identifier\">status</span> = <span class=\"ruby-constant\">Apache</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">DECLINED</span>\n 97:         <span class=\"ruby-keyword kw\">end</span>\n 98: \n 99:         <span class=\"ruby-comment cmt\"># self.log.debug &quot;Returning %p&quot; % [ rval ]</span>\n\
      100:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">rval</span>\n\
      101:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Dispatch the specified transaction <tt>txn</tt> to the appropriate handler
      based on the request&#8216;s path_info.
      </p>
    params: ( txn )
  category: Instance
  type: Public
- methods: 
  - visibility: protected
    aref: M000347
    name: builtin_missing_handler
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 214</span>\n\
      214:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">builtin_missing_handler</span>( <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span> )\n\
      215:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">notice</span> <span class=\"ruby-value str\">&quot;Using builtin missing-applet handler.&quot;</span>\n\
      216:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">false</span>\n\
      217:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      The builtin missing-applet handler routine. Returns <tt>false</tt>, which
      causes the dispatcher to decline the request.
      </p>
    params: ( txn, *args )
  - visibility: protected
    aref: M000349
    name: default_error_handler
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 256</span>\n\
      256:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">default_error_handler</span>( <span class=\"ruby-identifier\">applet</span>, <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">err</span> )\n\
      257:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">notice</span> <span class=\"ruby-value str\">&quot;Using builtin error handler.&quot;</span>\n\
      258:         <span class=\"ruby-identifier\">txn</span>.<span class=\"ruby-identifier\">request</span>.<span class=\"ruby-identifier\">content_type</span> = <span class=\"ruby-value str\">&quot;text/plain&quot;</span>\n\
      259:         <span class=\"ruby-identifier\">txn</span>.<span class=\"ruby-identifier\">status</span> = <span class=\"ruby-constant\">Apache</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">OK</span>\n\
      260: \n\
      261:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-value str\">&quot;Arrow Applet Error in '%s': %s\\n\\t%s&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      262:             [ <span class=\"ruby-identifier\">applet</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">signature</span>.<span class=\"ruby-identifier\">name</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">join</span>(<span class=\"ruby-value str\">&quot;\\n\\t&quot;</span>) ]\n\
      263:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      The builtin error handler routine. Outputs a plain-text backtrace for the
      given exception <tt>err</tt> and <tt>applet</tt> to the given transaction
      <tt>txn</tt>.
      </p>
    params: ( applet, txn, err )
  - visibility: protected
    aref: M000345
    name: run_applet
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 171</span>\n\
      171:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">run_applet</span>( <span class=\"ruby-identifier\">applet</span>, <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">rest</span> )\n\
      172:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">debug</span> <span class=\"ruby-value str\">&quot;Running '%s' with args: %p&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      173:             [ <span class=\"ruby-identifier\">applet</span>.<span class=\"ruby-identifier\">signature</span>.<span class=\"ruby-identifier\">name</span>, <span class=\"ruby-identifier\">rest</span> ]\n\
      174:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">applet</span>.<span class=\"ruby-identifier\">run</span>( <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">rest</span> )\n\
      175:     <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Exception</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      176:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">error</span> <span class=\"ruby-value str\">&quot;[%s]: Error running %s (%s): %s:\\n\\t%s&quot;</span> <span class=\"ruby-operator\">%</span> [\n\
      177:             <span class=\"ruby-identifier\">txn</span>.<span class=\"ruby-identifier\">serial</span>,\n\
      178:             <span class=\"ruby-identifier\">applet</span>.<span class=\"ruby-identifier\">signature</span>.<span class=\"ruby-identifier\">name</span>,\n\
      179:             <span class=\"ruby-identifier\">applet</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">filename</span>,\n\
      180:             <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>,\n\
      181:             <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">join</span>(<span class=\"ruby-value str\">&quot;\\n\\t&quot;</span>),\n\
      182:         ]\n\
      183:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">run_error_handler</span>( <span class=\"ruby-identifier\">applet</span>, <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">err</span> )\n\
      184:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Run the specified <tt>applet</tt> with the given <tt>txn</tt> (an <a
      href="Transaction.html">Arrow::Transaction</a>) and the <tt>rest</tt> of
      the path_info split on &#8217;/&#8217;.
      </p>
    params: ( applet, txn, rest )
  - visibility: protected
    aref: M000343
    name: run_applet_chain
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 111</span>\n\
      111:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">run_applet_chain</span>( <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">chain</span> )\n\
      112:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">debug</span> <span class=\"ruby-node\">&quot;Running applet chain: #{chain.inspect}&quot;</span>\n\
      113:         <span class=\"ruby-identifier\">raise</span> <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AppletError</span>, <span class=\"ruby-value str\">&quot;Malformed applet chain&quot;</span> <span class=\"ruby-keyword kw\">if</span>\n\
      114:             <span class=\"ruby-identifier\">chain</span>.<span class=\"ruby-identifier\">empty?</span> <span class=\"ruby-operator\">||</span> <span class=\"ruby-operator\">!</span><span class=\"ruby-identifier\">chain</span>.<span class=\"ruby-identifier\">first</span>.<span class=\"ruby-identifier\">respond_to?</span>( <span class=\"ruby-identifier\">:applet</span> )\n\
      115: \n\
      116:         <span class=\"ruby-identifier\">res</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      117:         <span class=\"ruby-identifier\">applet</span>, <span class=\"ruby-identifier\">txn</span>.<span class=\"ruby-identifier\">applet_path</span>, <span class=\"ruby-identifier\">args</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">unwrap_chain_link</span>( <span class=\"ruby-identifier\">chain</span>.<span class=\"ruby-identifier\">first</span> )\n\
      118: \n\
      119:         <span class=\"ruby-comment cmt\"># If there's only one item left, run it</span>\n\
      120:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">chain</span>.<span class=\"ruby-identifier\">nitems</span> <span class=\"ruby-operator\">==</span> <span class=\"ruby-value\">1</span>\n\
      121:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">debug</span> <span class=\"ruby-value str\">&quot;Running final applet in chain&quot;</span>\n\
      122:             <span class=\"ruby-identifier\">res</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">run_applet</span>( <span class=\"ruby-identifier\">applet</span>, <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">args</span> )\n\
      123: \n\
      124:         <span class=\"ruby-comment cmt\"># Otherwise, delegate the transaction to the next applet with the</span>\n\
      125:         <span class=\"ruby-comment cmt\"># remainder of the chain.</span>\n\
      126:         <span class=\"ruby-keyword kw\">else</span>\n\
      127:             <span class=\"ruby-identifier\">dchain</span> = <span class=\"ruby-identifier\">chain</span>[ <span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">-1</span> ]\n\
      128:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">debug</span> <span class=\"ruby-value str\">&quot;Running applet %s in chain of %d; chain = %p&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      129:                 [ <span class=\"ruby-identifier\">applet</span>.<span class=\"ruby-identifier\">signature</span>.<span class=\"ruby-identifier\">name</span>, <span class=\"ruby-identifier\">chain</span>.<span class=\"ruby-identifier\">nitems</span>, <span class=\"ruby-identifier\">dchain</span> ]\n\
      130: \n\
      131:             <span class=\"ruby-keyword kw\">begin</span>\n\
      132:                 <span class=\"ruby-identifier\">res</span> = <span class=\"ruby-identifier\">applet</span>.<span class=\"ruby-identifier\">delegate</span>( <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">dchain</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span> ) <span class=\"ruby-keyword kw\">do</span> <span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">subchain</span><span class=\"ruby-operator\">|</span>\n\
      133:                     <span class=\"ruby-identifier\">subchain</span> = <span class=\"ruby-identifier\">dchain</span> <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">subchain</span>.<span class=\"ruby-identifier\">nil?</span>\n\
      134:                     <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">debug</span> <span class=\"ruby-value str\">&quot;Delegated call to appletchain %p&quot;</span> <span class=\"ruby-operator\">%</span> [ <span class=\"ruby-identifier\">subchain</span> ]\n\
      135:                     <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">run_applet_chain</span>( <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">subchain</span> )\n\
      136:                 <span class=\"ruby-keyword kw\">end</span>\n\
      137:             <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Exception</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err</span>\n\
      138:                 <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">error</span> <span class=\"ruby-value str\">&quot;Error while executing applet chain: %p (/%s): %s:\\n\\t%s&quot;</span> <span class=\"ruby-operator\">%</span> [\n\
      139:                     <span class=\"ruby-identifier\">applet</span>,\n\
      140:                     <span class=\"ruby-identifier\">chain</span>.<span class=\"ruby-identifier\">first</span>[<span class=\"ruby-value\">1</span>],\n\
      141:                     <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">message</span>,\n\
      142:                     <span class=\"ruby-identifier\">err</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">join</span>(<span class=\"ruby-value str\">&quot;\\n\\t&quot;</span>),\n\
      143:                 ]\n\
      144:                 <span class=\"ruby-identifier\">res</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">run_error_handler</span>( <span class=\"ruby-identifier\">applet</span>, <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">err</span> )\n\
      145:             <span class=\"ruby-keyword kw\">end</span>\n\
      146:         <span class=\"ruby-keyword kw\">end</span>\n\
      147: \n\
      148:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">res</span>\n\
      149:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Given a chain of applets built from a URI, run the +index+th one with the
      specified transaction (<tt>txn</tt>). Applets before the last get called
      via their <a href="Broker.html#M000342">#delegate</a> method, while the
      last one is called via #run.
      </p>
    params: ( txn, chain )
  - visibility: protected
    aref: M000348
    name: run_error_handler
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 224</span>\n\
      224:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">run_error_handler</span>( <span class=\"ruby-identifier\">applet</span>, <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">err</span> )\n\
      225:         <span class=\"ruby-identifier\">rval</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      226:         <span class=\"ruby-identifier\">handlerName</span> = <span class=\"ruby-ivar\">@config</span>.<span class=\"ruby-identifier\">applets</span>.<span class=\"ruby-identifier\">errorApplet</span>.<span class=\"ruby-identifier\">sub</span>( <span class=\"ruby-regexp re\">%r{^/}</span>, <span class=\"ruby-value str\">''</span> )\n\
      227: \n\
      228:         <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">handlerName</span> <span class=\"ruby-operator\">==</span> <span class=\"ruby-value str\">&quot;(builtin)&quot;</span> <span class=\"ruby-keyword kw\">or</span> <span class=\"ruby-operator\">!</span><span class=\"ruby-ivar\">@registry</span>.<span class=\"ruby-identifier\">key?</span>( <span class=\"ruby-identifier\">handlerName</span> )\n\
      229:             <span class=\"ruby-identifier\">handler</span> = <span class=\"ruby-ivar\">@registry</span>[<span class=\"ruby-identifier\">handlerName</span>]\n\
      230:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">notice</span> <span class=\"ruby-value str\">&quot;Running error handler applet '%s' (%s)&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      231:                 [ <span class=\"ruby-identifier\">handler</span>.<span class=\"ruby-identifier\">signature</span>.<span class=\"ruby-identifier\">name</span>, <span class=\"ruby-identifier\">handlerName</span> ]\n\
      232: \n\
      233:             <span class=\"ruby-keyword kw\">begin</span>\n\
      234:                 <span class=\"ruby-identifier\">rval</span> = <span class=\"ruby-identifier\">handler</span>.<span class=\"ruby-identifier\">run</span>( <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-value str\">&quot;report_error&quot;</span>, <span class=\"ruby-identifier\">applet</span>, <span class=\"ruby-identifier\">err</span> )\n\
      235:             <span class=\"ruby-keyword kw\">rescue</span> <span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Exception</span> =<span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">err2</span>\n\
      236:                 <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">error</span> <span class=\"ruby-value str\">&quot;Error while attempting to use custom error &quot;</span>\\\n\
      237:                 <span class=\"ruby-value str\">&quot;handler '%s': %s\\n\\t%s&quot;</span> <span class=\"ruby-operator\">%</span> [\n\
      238:                     <span class=\"ruby-identifier\">handler</span>.<span class=\"ruby-identifier\">signature</span>.<span class=\"ruby-identifier\">name</span>,\n\
      239:                     <span class=\"ruby-identifier\">err2</span>.<span class=\"ruby-identifier\">message</span>,\n\
      240:                     <span class=\"ruby-identifier\">err2</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">join</span>(<span class=\"ruby-value str\">&quot;\\n\\t&quot;</span>),\n\
      241:                 ]\n\
      242: \n\
      243:                 <span class=\"ruby-identifier\">rval</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">default_error_handler</span>( <span class=\"ruby-identifier\">applet</span>, <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">err</span> )\n\
      244:             <span class=\"ruby-keyword kw\">end</span>\n\
      245:         <span class=\"ruby-keyword kw\">else</span>\n\
      246:             <span class=\"ruby-identifier\">rval</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">default_error_handler</span>( <span class=\"ruby-identifier\">applet</span>, <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">err</span> )\n\
      247:         <span class=\"ruby-keyword kw\">end</span>\n\
      248: \n\
      249:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">rval</span>\n\
      250:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Handle the given applet error <tt>err</tt> for the specified
      <tt>applet</tt>, using the given transaction <tt>txn</tt>. This will
      attempt to run whatever applet is configured as the error-handler, or run a
      builtin handler applet if none is configured or the configured one
      isn&#8216;t loaded.
      </p>
    params: ( applet, txn, err )
  - visibility: protected
    aref: M000346
    name: run_missing_applet_handler
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 188</span>\n\
      188:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">run_missing_applet_handler</span>( <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">uri</span> )\n\
      189:         <span class=\"ruby-identifier\">rval</span> = <span class=\"ruby-identifier\">appletchain</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      190:         <span class=\"ruby-identifier\">handlerUri</span> = <span class=\"ruby-ivar\">@config</span>.<span class=\"ruby-identifier\">applets</span>.<span class=\"ruby-identifier\">missingApplet</span>\n\
      191:         <span class=\"ruby-identifier\">args</span> = <span class=\"ruby-identifier\">uri</span>.<span class=\"ruby-identifier\">split</span>( <span class=\"ruby-regexp re\">%r{/}</span> )\n\
      192: \n\
      193:         <span class=\"ruby-comment cmt\"># Build an applet chain for user-configured handlers</span>\n\
      194:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">handlerUri</span> <span class=\"ruby-operator\">!=</span> <span class=\"ruby-value str\">&quot;(builtin)&quot;</span>\n\
      195:             <span class=\"ruby-identifier\">appletchain</span> = <span class=\"ruby-ivar\">@registry</span>.<span class=\"ruby-identifier\">find_applet_chain</span>( <span class=\"ruby-identifier\">handlerUri</span> )\n\
      196:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">log</span>.<span class=\"ruby-identifier\">error</span> <span class=\"ruby-value str\">&quot;Configured MissingApplet handler (%s) doesn't exist&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      197:                 <span class=\"ruby-identifier\">handlerUri</span> <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">appletchain</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      198:         <span class=\"ruby-keyword kw\">end</span>\n\
      199: \n\
      200:         <span class=\"ruby-comment cmt\"># If the user-configured handler maps to one or more handlers, run</span>\n\
      201:         <span class=\"ruby-comment cmt\"># them. Otherwise, run the build-in handler.</span>\n\
      202:         <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">appletchain</span>.<span class=\"ruby-identifier\">nil?</span> <span class=\"ruby-operator\">||</span> <span class=\"ruby-identifier\">appletchain</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      203:             <span class=\"ruby-identifier\">rval</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">run_applet_chain</span>( <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-identifier\">appletchain</span> )\n\
      204:         <span class=\"ruby-keyword kw\">else</span>\n\
      205:             <span class=\"ruby-identifier\">rval</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">builtin_missing_handler</span>( <span class=\"ruby-identifier\">txn</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span> )\n\
      206:         <span class=\"ruby-keyword kw\">end</span>\n\
      207: \n\
      208:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">rval</span>\n\
      209:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Handle requests that target an applet that doesn&#8216;t exist.
      </p>
    params: ( txn, uri )
  - visibility: protected
    aref: M000344
    name: unwrap_chain_link
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/broker.rb, line 155</span>\n\
      155:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">unwrap_chain_link</span>( <span class=\"ruby-identifier\">link</span> )\n\
      156:         <span class=\"ruby-identifier\">applet</span> = <span class=\"ruby-identifier\">link</span>.<span class=\"ruby-identifier\">applet</span> <span class=\"ruby-keyword kw\">or</span> <span class=\"ruby-identifier\">raise</span> <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AppletChainError</span>, <span class=\"ruby-value str\">&quot;Null applet&quot;</span>\n\
      157:         <span class=\"ruby-identifier\">path</span> = <span class=\"ruby-identifier\">link</span>.<span class=\"ruby-identifier\">path</span> <span class=\"ruby-keyword kw\">or</span> <span class=\"ruby-identifier\">raise</span> <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AppletChainError</span>, <span class=\"ruby-value str\">&quot;Null path&quot;</span>\n\
      158:         <span class=\"ruby-identifier\">args</span> = <span class=\"ruby-identifier\">link</span>.<span class=\"ruby-identifier\">args</span> <span class=\"ruby-keyword kw\">or</span> <span class=\"ruby-identifier\">raise</span> <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AppletChainError</span>, <span class=\"ruby-value str\">&quot;Null argument list&quot;</span>\n\
      159:         <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">args</span>.<span class=\"ruby-identifier\">is_a?</span>( <span class=\"ruby-constant\">Array</span> )\n\
      160:             <span class=\"ruby-identifier\">emsg</span> = <span class=\"ruby-value str\">&quot;Argument list is a %s: expected an Array&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      161:                 <span class=\"ruby-identifier\">args</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">name</span>\n\
      162:             <span class=\"ruby-identifier\">raise</span> <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AppletChainError</span>, <span class=\"ruby-identifier\">emsg</span>\n\
      163:         <span class=\"ruby-keyword kw\">end</span>                   \n\
      164: \n\
      165:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">applet</span>, <span class=\"ruby-identifier\">path</span>, <span class=\"ruby-identifier\">args</span>\n\
      166:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Check the specified <tt>link</tt> of an applet chain for sanity and return
      its constituent bits for assignment. This is necessary to provide sensible
      errors if a delegating app screws up a chain somehow.
      </p>
    params: ( link )
  category: Instance
  type: Protected

sectitle

---

constants

--- 
- name: SVNRev
  desc: |+
    
    SVN Revision
    
  value: "%q$Rev: 437 $"
- name: SVNId
  desc: |+
    
    SVN Id
    
  value: "%q$Id: broker.rb 437 2008-03-28 00:49:20Z deveiant $"
- name: FILE_SEPARATOR
  desc: |+
    
    A regular expression that matches the file separator on this system
    
  value: Regexp.new( Regexp.compile(File::SEPARATOR) )

[Validate]

Generated with the Darkfish Rdoc Generator.