Added Action Service to the repository
git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@658 5ecf4fe2-1ee6-0310-87b1-e25e094e27de
This commit is contained in:
David Heinemeier Hansson
parent
e39bf10594
commit
e7a2938029
|
|
@ -0,0 +1,41 @@
|
|||
UNRELEASED
|
||||
|
||||
* lib/action_service/router/wsdl.rb: ensure that #wsdl is
|
||||
defined in the final container class, or the new ActionPack
|
||||
filtering will exclude it
|
||||
* lib/action_service/struct.rb,test/struct_test.rb: create a
|
||||
default #initialize on inherit that accepts a Hash containing
|
||||
the default member values
|
||||
* lib/action_service/api/action_controller.rb: add support and
|
||||
tests for #client_api in controller
|
||||
* test/router_wsdl_test.rb: add tests to ensure declared
|
||||
service names don't contain ':', as ':' causes interoperability
|
||||
issues
|
||||
* lib/*, test/*: rename "interface" concept to "api", and change all
|
||||
related uses to reflect this change. update all uses of Inflector
|
||||
to call the method on String instead.
|
||||
* test/api_test.rb: add test to ensure API definition not
|
||||
instantiatable
|
||||
* lib/action_service/invocation.rb: change @invocation_params to
|
||||
@method_params
|
||||
* lib/*: update RDoc
|
||||
* lib/action_service/struct.rb: update to support base types
|
||||
* lib/action_service/support/signature.rb: support the notion of
|
||||
"base types" in signatures, with well-known unambiguous names such as :int,
|
||||
:bool, etc, which map to the correct Ruby class. accept the same names
|
||||
used by ActiveRecord as well as longer versions of each, as aliases.
|
||||
* examples/*: update for seperate API definition updates
|
||||
* lib/action_service/*, test/*: extensive refactoring: define API methods in
|
||||
a seperate class, and specify it wherever used with 'service_api'.
|
||||
this makes writing a client API for accessing defined API methods
|
||||
with ActionService really easy.
|
||||
* lib/action_service/container.rb: fix a bug in default call
|
||||
handling for direct dispatching, and add ActionController filter
|
||||
support for direct dispatching.
|
||||
* test/router_action_controller_test.rb: add tests to ensure
|
||||
ActionController filters are actually called.
|
||||
* test/protocol_soap_test.rb: add more tests for direct dispatching.
|
||||
|
||||
0.3.0
|
||||
|
||||
* First public release
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
== Coding Style
|
||||
|
||||
Please try to follow Rails conventions and idioms.
|
||||
|
||||
|
||||
== Concepts
|
||||
|
||||
* Service
|
||||
A service has an associated API definition, and
|
||||
implements the methods defined in the API definition
|
||||
|
||||
* Container
|
||||
A container contains zero or more services
|
||||
|
||||
* API
|
||||
An API definition defines a list of methods implemented by
|
||||
a service
|
||||
|
||||
* Router
|
||||
A router takes raw wire requests, decodes them, performs the invocation on
|
||||
the service, and generates raw wire responses from the invocation result.
|
||||
A router is mixed into a container class.
|
||||
|
||||
* Protocol
|
||||
A protocol implementation implements the unmarshaling and marshaling of
|
||||
raw wire requests and responses. Registers with router.
|
||||
|
||||
|
||||
== Action Pack Integration
|
||||
|
||||
For Action Pack, the ActionController is both container and router, and also contains
|
||||
the protocol implementations.
|
||||
|
||||
|
||||
== Adding support for a new protocol
|
||||
|
||||
1. Add an ActionService::Protocol::YourProtocol module and any classes you need to
|
||||
perform unmarshaling/marshaling of protocol requests. See the SOAP implementation
|
||||
for an example of a complex mapping, and also see
|
||||
ActionService::Protocol::AbstractProtocol for the methods you need to implement.
|
||||
|
||||
2. Add unit tests for your new protocol. Be sure to test using a Action Pack test request
|
||||
duplicating how the real requests will arrive and verify that mapping to and from Ruby
|
||||
types works correctly.
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
Copyright (C) 2005 Leon Breedt
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
"Software"), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
|
@ -0,0 +1,241 @@
|
|||
= Action Service -- Serving APIs on rails
|
||||
|
||||
Action Service provides a way to publish interoperable web service APIs with
|
||||
Rails without spending a lot of time delving into protocol details.
|
||||
|
||||
|
||||
== Features
|
||||
|
||||
* SOAP RPC protocol support
|
||||
* Dynamic WSDL generation for APIs
|
||||
* XML-RPC protocol support
|
||||
* Clients that use the same API definitions as the server for
|
||||
easy interoperability with other Action Service based applications
|
||||
* Type signature hints to improve interoperability with static languages
|
||||
* Active Record model class support in signatures
|
||||
|
||||
|
||||
== Defining your APIs
|
||||
|
||||
You specify the methods you want to make available as API methods in an
|
||||
ActionService::API::Base derivative, and then specify this API
|
||||
definition class wherever you want to use that API.
|
||||
|
||||
The implementation of the methods is done seperately to the API
|
||||
specification.
|
||||
|
||||
|
||||
==== Method name inflection
|
||||
|
||||
Action Service will camelcase the method names according to Rails Inflector
|
||||
rules for the API visible to public callers. What this means, for example
|
||||
is that the method names in generated WSDL will be camelcased, and callers will
|
||||
have to supply the camelcased name in their requests for the request to
|
||||
succeed.
|
||||
|
||||
If you do not desire this behaviour, you can turn it off with the
|
||||
ActionService::API::Base +inflect_names+ option.
|
||||
|
||||
|
||||
==== Inflection examples
|
||||
|
||||
:add => Add
|
||||
:find_all => FindAll
|
||||
|
||||
|
||||
==== Disabling inflection
|
||||
|
||||
class PersonAPI < ActionService::API::Base
|
||||
inflect_names false
|
||||
end
|
||||
|
||||
|
||||
==== API definition example
|
||||
|
||||
class PersonAPI < ActionService::API::Base
|
||||
api_method :add, :expects => [:string, :string, :bool], :returns => [:int]
|
||||
api_method :remove, :expects => [:int], :returns => [:bool]
|
||||
end
|
||||
|
||||
==== API usage example
|
||||
|
||||
class PersonController < ActionController::Base
|
||||
service_api PersonAPI
|
||||
|
||||
def add
|
||||
end
|
||||
|
||||
def remove
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
== Publishing your APIs
|
||||
|
||||
Action Service uses Action Pack to process protocol requests. There are two
|
||||
modes of dispatching protocol requests, _Direct_, and _Delegated_.
|
||||
|
||||
|
||||
=== Direct dispatching
|
||||
|
||||
This is the default mode. In this mode, controller actions implement the API
|
||||
methods, and parameters for incoming method calls will be placed in
|
||||
<tt>@params</tt> (keyed by name), and <tt>@method_params</tt> (ordered list).
|
||||
|
||||
The return value of the action is sent back as the return value to the
|
||||
caller.
|
||||
|
||||
In this mode, a special <tt>api</tt> action is generated in the target
|
||||
controller to unwrap the protocol request, forward it on to the relevant action
|
||||
and send back the wrapped return value. <em>This action must not be
|
||||
overridden.</em>
|
||||
|
||||
==== Direct dispatching example
|
||||
|
||||
class PersonController < ApplicationController
|
||||
service_api PersonAPI
|
||||
|
||||
def add
|
||||
end
|
||||
|
||||
def remove
|
||||
end
|
||||
end
|
||||
|
||||
class PersonAPI < ActionService::API::Base
|
||||
...
|
||||
end
|
||||
|
||||
|
||||
For this example, protocol requests for +Add+ and +Remove+ methods sent to
|
||||
<tt>/person/api</tt> will be routed to the actions +add+ and +remove+.
|
||||
|
||||
|
||||
=== Delegated dispatching
|
||||
|
||||
This mode can be turned on by setting the +service_dispatching_mode+ option
|
||||
in a controller.
|
||||
|
||||
In this mode, the controller contains one or more service API objects (objects
|
||||
that implement an ActionService::API::Base definition). These API
|
||||
objects are each mapped onto one controller action only.
|
||||
|
||||
==== Delegated dispatching example
|
||||
|
||||
class ApiController < ApplicationController
|
||||
service_dispatching_mode :delegated
|
||||
|
||||
service :person, PersonService.new
|
||||
end
|
||||
|
||||
class PersonService < ActionService::Base
|
||||
service_api PersonAPI
|
||||
|
||||
def add
|
||||
end
|
||||
|
||||
def remove
|
||||
end
|
||||
end
|
||||
|
||||
class PersonAPI < ActionService::API::Base
|
||||
...
|
||||
end
|
||||
|
||||
|
||||
For this example, all protocol requests for +PersonService+ are
|
||||
sent to the <tt>/api/person</tt> action.
|
||||
|
||||
The <tt>/api/person</tt> action is generated when the +service+
|
||||
method is called. <em>This action must not be overridden.</em>
|
||||
|
||||
Other controller actions (actions that aren't the target of a +service+ call)
|
||||
are ignored for ActionService purposes, and can do normal action tasks.
|
||||
|
||||
|
||||
== Using the client support
|
||||
|
||||
Action Service includes client classes that can use the same API
|
||||
definition as the server. The advantage of this approach is that your client
|
||||
will have the same support for Active Record and structured types as the
|
||||
server, and can just use them directly, and rely on the marshaling to Do The
|
||||
Right Thing.
|
||||
|
||||
*Note*: The client support is intended for communication between Ruby on Rails
|
||||
applications that both use Action Service. It may work with other servers, but
|
||||
that is not its intended use, and interoperability can't be guaranteed, especially
|
||||
not for .NET web services.
|
||||
|
||||
Web services protocol specifications are complex, and Action Service can only
|
||||
be guaranteed to work with a subset.
|
||||
|
||||
If you have the need for clients for a complex service not running on Action
|
||||
Service, it is recommended that you use +wsdl2ruby+ and generate the client
|
||||
stub classes.
|
||||
|
||||
==== Factory created client example
|
||||
|
||||
class BlogManagerController < ApplicationController
|
||||
client_api :blogger, :xmlrpc, 'http://url/to/blog/api/RPC2', :handler_name => 'blogger'
|
||||
end
|
||||
|
||||
class SearchingController < ApplicationController
|
||||
client_api :google, :soap, 'http://url/to/blog/api/beta', :service_name => 'GoogleSearch'
|
||||
end
|
||||
|
||||
See ActionService::API::ActionController::ClassMethods for more details.
|
||||
|
||||
==== Manually created client example
|
||||
|
||||
class PersonAPI < ActionService::API::Base
|
||||
api_method :find_all, :returns => [[Person]]
|
||||
end
|
||||
|
||||
soap_client = ActionService::Client::Soap.new(PersonAPI, "http://...")
|
||||
persons = soap_client.find_all
|
||||
|
||||
class BloggerAPI < ActionService::API::Base
|
||||
inflect_names false
|
||||
api_method :getRecentPosts, :returns => [[Blog::Post]]
|
||||
end
|
||||
|
||||
blog = ActionService::Client::XmlRpc.new(BloggerAPI, "http://.../xmlrpc", :handler_name => "blogger")
|
||||
posts = blog.getRecentPosts
|
||||
|
||||
|
||||
See ActionService::Client::Soap and ActionService::Client::XmlRpc for more details.
|
||||
|
||||
== Dependencies
|
||||
|
||||
Action Service requires that the Action Pack and Active Record are either
|
||||
available to be required immediately or are accessible as GEMs.
|
||||
|
||||
It also requires a version of Ruby that includes SOAP support in the standard
|
||||
library. At least version 1.8.2 final (2004-12-25) of Ruby is recommended, this
|
||||
is the version tested against.
|
||||
|
||||
|
||||
== Download
|
||||
|
||||
The latest Action Service version can be downloaded from
|
||||
http://rubyforge.org/projects/actionservice
|
||||
|
||||
|
||||
== Installation
|
||||
|
||||
You can install Action Service with the following command.
|
||||
|
||||
% [sudo] ruby setup.rb
|
||||
|
||||
|
||||
== License
|
||||
|
||||
Action Service is released under the MIT license.
|
||||
|
||||
|
||||
== Support
|
||||
|
||||
The Ruby on Rails mailing list
|
||||
|
||||
Or, to contact the author, send mail to bitserf@gmail.com
|
||||
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
require 'rubygems'
|
||||
require 'rake'
|
||||
require 'rake/testtask'
|
||||
require 'rake/rdoctask'
|
||||
require 'rake/packagetask'
|
||||
require 'rake/gempackagetask'
|
||||
require 'rake/contrib/rubyforgepublisher'
|
||||
require 'fileutils'
|
||||
|
||||
PKG_BUILD = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
|
||||
PKG_NAME = 'actionservice'
|
||||
PKG_VERSION = '0.4.0' + PKG_BUILD
|
||||
|
||||
desc "Default Task"
|
||||
task :default => [ :test ]
|
||||
|
||||
|
||||
# Run the unit tests
|
||||
Rake::TestTask.new { |t|
|
||||
t.libs << "test"
|
||||
t.pattern = 'test/*_test.rb'
|
||||
t.verbose = true
|
||||
}
|
||||
|
||||
|
||||
# Generate the RDoc documentation
|
||||
Rake::RDocTask.new { |rdoc|
|
||||
rdoc.rdoc_dir = 'doc'
|
||||
rdoc.title = "Action Service -- Web services for Action Pack"
|
||||
rdoc.options << '--line-numbers --inline-source --main README --accessor class_inheritable_option=RW'
|
||||
rdoc.rdoc_files.include('README')
|
||||
rdoc.rdoc_files.include('lib/action_service.rb')
|
||||
rdoc.rdoc_files.include('lib/action_service/*.rb')
|
||||
rdoc.rdoc_files.include('lib/action_service/api/*.rb')
|
||||
rdoc.rdoc_files.include('lib/action_service/client/*.rb')
|
||||
rdoc.rdoc_files.include('lib/action_service/protocol/*.rb')
|
||||
rdoc.rdoc_files.include('lib/action_service/router/*.rb')
|
||||
rdoc.rdoc_files.include('lib/action_service/support/*.rb')
|
||||
}
|
||||
|
||||
|
||||
# Create compressed packages
|
||||
spec = Gem::Specification.new do |s|
|
||||
s.platform = Gem::Platform::RUBY
|
||||
s.name = PKG_NAME
|
||||
s.summary = "Web service support for Action Pack."
|
||||
s.description = %q{Adds WSDL/SOAP and XML-RPC web service support to Action Pack}
|
||||
s.version = PKG_VERSION
|
||||
|
||||
s.author = "Leon Breedt"
|
||||
s.email = "bitserf@gmail.com"
|
||||
s.rubyforge_project = "actionservice"
|
||||
s.homepage = "http://rubyforge.org/projects/actionservice"
|
||||
|
||||
s.add_dependency('actionpack', '>= 1.4.0')
|
||||
s.add_dependency('activerecord', '>= 1.6.0')
|
||||
s.add_dependency('activesupport', '>= 0.9.0')
|
||||
|
||||
s.has_rdoc = true
|
||||
s.requirements << 'none'
|
||||
s.require_path = 'lib'
|
||||
s.autorequire = 'action_service'
|
||||
|
||||
s.files = [ "Rakefile", "setup.rb", "README", "TODO", "HACKING", "ChangeLog", "MIT-LICENSE" ]
|
||||
s.files = s.files + Dir.glob( "examples/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
|
||||
s.files = s.files + Dir.glob( "lib/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
|
||||
s.files = s.files + Dir.glob( "test/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
|
||||
end
|
||||
Rake::GemPackageTask.new(spec) do |p|
|
||||
p.gem_spec = spec
|
||||
p.need_tar = true
|
||||
p.need_zip = true
|
||||
end
|
||||
|
||||
|
||||
desc "Publish API docs to RubyForge"
|
||||
task :pdoc => [:rdoc] do
|
||||
FileUtils.mkdir_p 'html'
|
||||
FileUtils.mv 'doc', 'html/api'
|
||||
Rake::RubyForgePublisher.new('actionservice', 'ljb').upload
|
||||
end
|
||||
|
||||
def each_source_file(*args)
|
||||
prefix, includes, excludes, open_file = args
|
||||
prefix ||= File.dirname(__FILE__)
|
||||
open_file = true if open_file.nil?
|
||||
includes ||= %w[lib\/action_service\.rb$ lib\/action_service\/.*\.rb$]
|
||||
excludes ||= %w[]
|
||||
Find.find(prefix) do |file_name|
|
||||
next if file_name =~ /\.svn/
|
||||
file_name.gsub!(/^\.\//, '')
|
||||
continue = false
|
||||
includes.each do |inc|
|
||||
if file_name.match(/#{inc}/)
|
||||
continue = true
|
||||
break
|
||||
end
|
||||
end
|
||||
next unless continue
|
||||
excludes.each do |exc|
|
||||
if file_name.match(/#{exc}/)
|
||||
continue = false
|
||||
break
|
||||
end
|
||||
end
|
||||
next unless continue
|
||||
if open_file
|
||||
File.open(file_name) do |f|
|
||||
yield file_name, f
|
||||
end
|
||||
else
|
||||
yield file_name
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
desc "Count lines of the source code"
|
||||
task :lines do
|
||||
total_lines = total_loc = 0
|
||||
puts "Per File:"
|
||||
each_source_file do |file_name, f|
|
||||
file_lines = file_loc = 0
|
||||
while line = f.gets
|
||||
file_lines += 1
|
||||
next if line =~ /^\s*$/
|
||||
next if line =~ /^\s*#/
|
||||
file_loc += 1
|
||||
end
|
||||
puts " #{file_name}: Lines #{file_lines}, LOC #{file_loc}"
|
||||
total_lines += file_lines
|
||||
total_loc += file_loc
|
||||
end
|
||||
puts "Total:"
|
||||
puts " Lines #{total_lines}, LOC #{total_loc}"
|
||||
end
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
= Post-0.4.0 Tasks
|
||||
- relax type-checking for XML-RPC, and perform casts between base types if there
|
||||
are mismatches (i.e. String received when Integer expected, or vice-versa)
|
||||
|
||||
- support XML-RPC's "handler." method namespacing. perhaps something like:
|
||||
|
||||
class BloggingServices < ActionService::LayeredService
|
||||
def initialize(request)
|
||||
@request = controller.request
|
||||
end
|
||||
|
||||
service :mt {MTService.new(@request)}
|
||||
service :blogger {BloggerService.new(@request)}
|
||||
service :metaWeblog {MetaWeblogService.new(@request)}
|
||||
end
|
||||
|
||||
class ApiController < ApplicationController
|
||||
service_dispatching_mode :delegated
|
||||
service :xmlrpc { BloggingServices.new(@request) }
|
||||
end
|
||||
|
||||
|
||||
= Low priority tasks
|
||||
- add better type mapping tests for XML-RPC
|
||||
- add tests for ActiveRecord support (with mock objects?)
|
||||
|
||||
= Refactoring
|
||||
- Find an alternative way to map interesting types for SOAP (like ActiveRecord
|
||||
model classes) that doesn't require creation of a sanitized copy object with data
|
||||
copied from the real one. Ideally this would let us get rid of
|
||||
ActionService::Struct altogether and provide a block that would yield the
|
||||
attributes and values. "Filters" ? Not sure how to integrate with SOAP though.
|
||||
|
||||
- Don't have clean way to go from SOAP Class object to the xsd:NAME type
|
||||
string -- NaHi possibly looking at remedying this situation
|
||||
|
|
@ -0,0 +1,151 @@
|
|||
= Google Service example
|
||||
|
||||
|
||||
This example shows how one would implement an API like Google
|
||||
Search that uses lots of structured types.
|
||||
|
||||
There are examples for "Direct" and "Delegated" dispatching
|
||||
modes.
|
||||
|
||||
There is also an example for API definition file autoloading.
|
||||
|
||||
= Running
|
||||
|
||||
1. Ensure you have the 'actionservice' Gem installed. You can generate it using
|
||||
this command:
|
||||
|
||||
$ rake package
|
||||
|
||||
|
||||
2. Edit config/environment.rb, and add the following line after the rest of the
|
||||
require_gem statements:
|
||||
|
||||
require_gem 'actionservice'
|
||||
|
||||
|
||||
3. "Direct" example:
|
||||
|
||||
* Copy direct/search_controller.rb to "app/controllers"
|
||||
in a Rails project.
|
||||
|
||||
"Delegated" example:
|
||||
|
||||
* Copy delegated/search_controller.rb to "app/controllers"
|
||||
in a Rails project.
|
||||
* Copy delegated/google_search_service.rb to "lib"
|
||||
in a Rails project.
|
||||
|
||||
"Autoloading" example:
|
||||
|
||||
* Copy autoloading/google_search_api.rb to "app/apis" (create the directory
|
||||
if it doesn't exist) in a Rails project.
|
||||
|
||||
* Copy autoloading/google_search_controller.rb "app/controllers"
|
||||
in a Rails project.
|
||||
|
||||
|
||||
4. Go to the WSDL url in a browser, and check that it looks correct.
|
||||
|
||||
"Direct" and "Delegated" examples:
|
||||
http://url_to_project/search/wsdl
|
||||
|
||||
"Autoloading" example:
|
||||
http://url_to_project/google_search/wsdl
|
||||
|
||||
You can compare it to Google's hand-coded WSDL at http://api.google.com/GoogleSearch.wsdl
|
||||
and see how close (or not) the generated version is.
|
||||
|
||||
Note that I used GoogleSearch as the canonical "best practice"
|
||||
interoperable example when implementing WSDL/SOAP support, which might
|
||||
explain extreme similarities :)
|
||||
|
||||
|
||||
5. Test that it works with .NET (Mono in this example):
|
||||
|
||||
$ wget WSDL_URL
|
||||
$ mv wsdl GoogleSearch.wsdl
|
||||
$ wsdl -out:GoogleSearch.cs GoogleSearch.wsdl
|
||||
|
||||
Add these lines to the GoogleSearchService class body (be mindful of the
|
||||
wrapping):
|
||||
|
||||
public static void Main(string[] args)
|
||||
{
|
||||
GoogleSearchResult result;
|
||||
GoogleSearchService service;
|
||||
|
||||
service = new GoogleSearchService();
|
||||
result = service.doGoogleSearch("myApiKey", "my query", 10, 30, true, "restrict", false, "lr", "ie", "oe");
|
||||
System.Console.WriteLine("documentFiltering: {0}", result.documentFiltering);
|
||||
System.Console.WriteLine("searchComments: {0}", result.searchComments);
|
||||
System.Console.WriteLine("estimatedTotalResultsCount: {0}", result.estimatedTotalResultsCount);
|
||||
System.Console.WriteLine("estimateIsExact: {0}", result.estimateIsExact);
|
||||
System.Console.WriteLine("resultElements:");
|
||||
foreach (ResultElement element in result.resultElements) {
|
||||
System.Console.WriteLine("\tsummary: {0}", element.summary);
|
||||
System.Console.WriteLine("\tURL: {0}", element.URL);
|
||||
System.Console.WriteLine("\tsnippet: {0}", element.snippet);
|
||||
System.Console.WriteLine("\ttitle: {0}", element.title);
|
||||
System.Console.WriteLine("\tcachedSize: {0}", element.cachedSize);
|
||||
System.Console.WriteLine("\trelatedInformationPresent: {0}", element.relatedInformationPresent);
|
||||
System.Console.WriteLine("\thostName: {0}", element.hostName);
|
||||
System.Console.WriteLine("\tdirectoryCategory: {0}", element.directoryCategory.fullViewableName);
|
||||
System.Console.WriteLine("\tdirectoryTitle: {0}", element.directoryTitle);
|
||||
}
|
||||
System.Console.WriteLine("searchQuery: {0}", result.searchQuery);
|
||||
System.Console.WriteLine("startIndex: {0}", result.startIndex);
|
||||
System.Console.WriteLine("endIndex: {0}", result.endIndex);
|
||||
System.Console.WriteLine("searchTips: {0}", result.searchTips);
|
||||
System.Console.WriteLine("directoryCategories:");
|
||||
foreach (DirectoryCategory cat in result.directoryCategories) {
|
||||
System.Console.WriteLine("\t{0} ({1})", cat.fullViewableName, cat.specialEncoding);
|
||||
}
|
||||
System.Console.WriteLine("searchTime: {0}", result.searchTime);
|
||||
}
|
||||
|
||||
Now compile and run:
|
||||
|
||||
$ mcs -reference:System.Web.Services GoogleSearch.cs
|
||||
$ mono GoogleSearch.exe
|
||||
|
||||
|
||||
If you had the application running (on the same host you got
|
||||
the WSDL from), you should see something like this:
|
||||
|
||||
|
||||
documentFiltering: True
|
||||
searchComments:
|
||||
estimatedTotalResultsCount: 322000
|
||||
estimateIsExact: False
|
||||
resultElements:
|
||||
summary: ONlamp.com: Rolling with Ruby on Rails
|
||||
URL: http://www.onlamp.com/pub/a/onlamp/2005/01/20/rails.html
|
||||
snippet: Curt Hibbs shows off Ruby on Rails by building a simple ...
|
||||
title: Teh Railz0r
|
||||
cachedSize: Almost no lines of code!
|
||||
relatedInformationPresent: True
|
||||
hostName: rubyonrails.com
|
||||
directoryCategory: Web Development
|
||||
directoryTitle:
|
||||
searchQuery: http://www.google.com/search?q=ruby+on+rails
|
||||
startIndex: 10
|
||||
endIndex: 40
|
||||
searchTips: "on" is a very common word and was not included in your search [details]
|
||||
directoryCategories:
|
||||
Web Development (UTF-8)
|
||||
Programming (US-ASCII)
|
||||
searchTime: 1E-06
|
||||
|
||||
|
||||
Also, if an API method throws an exception, it will be sent back to the
|
||||
caller in the protocol's exception format, so they should get an exception
|
||||
thrown on their side with a meaningful error message.
|
||||
|
||||
If you don't like this behaviour, you can do:
|
||||
|
||||
class MyController < ActionController::Base
|
||||
service_exception_reporting false
|
||||
end
|
||||
|
||||
6. Crack open a beer. Publishing APIs for working with the same model as
|
||||
your Rails web app should be easy from now on :)
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
class DirectoryCategory < ActionService::Struct
|
||||
member :fullViewableName, :string
|
||||
member :specialEncoding, :string
|
||||
end
|
||||
|
||||
class ResultElement < ActionService::Struct
|
||||
member :summary, :string
|
||||
member :URL, :string
|
||||
member :snippet, :string
|
||||
member :title, :string
|
||||
member :cachedSize, :string
|
||||
member :relatedInformationPresent, :bool
|
||||
member :hostName, :string
|
||||
member :directoryCategory, DirectoryCategory
|
||||
member :directoryTitle, :string
|
||||
end
|
||||
|
||||
class GoogleSearchResult < ActionService::Struct
|
||||
member :documentFiltering, :bool
|
||||
member :searchComments, :string
|
||||
member :estimatedTotalResultsCount, :int
|
||||
member :estimateIsExact, :bool
|
||||
member :resultElements, [ResultElement]
|
||||
member :searchQuery, :string
|
||||
member :startIndex, :int
|
||||
member :endIndex, :int
|
||||
member :searchTips, :string
|
||||
member :directoryCategories, [DirectoryCategory]
|
||||
member :searchTime, :float
|
||||
end
|
||||
|
||||
class GoogleSearchAPI < ActionService::API::Base
|
||||
inflect_names false
|
||||
|
||||
api_method :doGetCachedPage, :returns => [:string], :expects => [{:key=>:string}, {:url=>:string}]
|
||||
api_method :doGetSpellingSuggestion, :returns => [:string], :expects => [{:key=>:string}, {:phrase=>:string}]
|
||||
|
||||
api_method :doGoogleSearch, :returns => [GoogleSearchResult], :expects => [
|
||||
{:key=>:string},
|
||||
{:q=>:string},
|
||||
{:start=>:int},
|
||||
{:maxResults=>:int},
|
||||
{:filter=>:bool},
|
||||
{:restrict=>:string},
|
||||
{:safeSearch=>:bool},
|
||||
{:lr=>:string},
|
||||
{:ie=>:string},
|
||||
{:oe=>:string}
|
||||
]
|
||||
end
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
class GoogleSearchController < ApplicationController
|
||||
wsdl_service_name 'GoogleSearch'
|
||||
|
||||
def doGetCachedPage
|
||||
"<html><body>i am a cached page. my key was %s, url was %s</body></html>" % [@params['key'], @params['url']]
|
||||
end
|
||||
|
||||
def doSpellingSuggestion
|
||||
"%s: Did you mean '%s'?" % [@params['key'], @params['phrase']]
|
||||
end
|
||||
|
||||
def doGoogleSearch
|
||||
resultElement = ResultElement.new
|
||||
resultElement.summary = "ONlamp.com: Rolling with Ruby on Rails"
|
||||
resultElement.URL = "http://www.onlamp.com/pub/a/onlamp/2005/01/20/rails.html"
|
||||
resultElement.snippet = "Curt Hibbs shows off Ruby on Rails by building a simple application that requires " +
|
||||
"almost no Ruby experience. ... Rolling with Ruby on Rails. ..."
|
||||
resultElement.title = "Teh Railz0r"
|
||||
resultElement.cachedSize = "Almost no lines of code!"
|
||||
resultElement.relatedInformationPresent = true
|
||||
resultElement.hostName = "rubyonrails.com"
|
||||
resultElement.directoryCategory = category("Web Development", "UTF-8")
|
||||
|
||||
result = GoogleSearchResult.new
|
||||
result.documentFiltering = @params['filter']
|
||||
result.searchComments = ""
|
||||
result.estimatedTotalResultsCount = 322000
|
||||
result.estimateIsExact = false
|
||||
result.resultElements = [resultElement]
|
||||
result.searchQuery = "http://www.google.com/search?q=ruby+on+rails"
|
||||
result.startIndex = @params['start']
|
||||
result.endIndex = @params['start'] + @params['maxResults']
|
||||
result.searchTips = "\"on\" is a very common word and was not included in your search [details]"
|
||||
result.searchTime = 0.000001
|
||||
|
||||
# For Mono, we have to clone objects if they're referenced by more than one place, otherwise
|
||||
# the Ruby SOAP collapses them into one instance and uses references all over the
|
||||
# place, confusing Mono.
|
||||
#
|
||||
# This has recently been fixed:
|
||||
# http://bugzilla.ximian.com/show_bug.cgi?id=72265
|
||||
result.directoryCategories = [
|
||||
category("Web Development", "UTF-8"),
|
||||
category("Programming", "US-ASCII"),
|
||||
]
|
||||
|
||||
result
|
||||
end
|
||||
|
||||
private
|
||||
def category(name, encoding)
|
||||
cat = DirectoryCategory.new
|
||||
cat.fullViewableName = name.dup
|
||||
cat.specialEncoding = encoding.dup
|
||||
cat
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,110 @@
|
|||
require 'action_service'
|
||||
|
||||
class DirectoryCategory < ActionService::Struct
|
||||
member :fullViewableName, :string
|
||||
member :specialEncoding, :string
|
||||
end
|
||||
|
||||
class ResultElement < ActionService::Struct
|
||||
member :summary, :string
|
||||
member :URL, :string
|
||||
member :snippet, :string
|
||||
member :title, :string
|
||||
member :cachedSize, :string
|
||||
member :relatedInformationPresent, :bool
|
||||
member :hostName, :string
|
||||
member :directoryCategory, DirectoryCategory
|
||||
member :directoryTitle, :string
|
||||
end
|
||||
|
||||
class GoogleSearchResult < ActionService::Struct
|
||||
member :documentFiltering, :bool
|
||||
member :searchComments, :string
|
||||
member :estimatedTotalResultsCount, :int
|
||||
member :estimateIsExact, :bool
|
||||
member :resultElements, [ResultElement]
|
||||
member :searchQuery, :string
|
||||
member :startIndex, :int
|
||||
member :endIndex, :int
|
||||
member :searchTips, :string
|
||||
member :directoryCategories, [DirectoryCategory]
|
||||
member :searchTime, :float
|
||||
end
|
||||
|
||||
class GoogleSearchAPI < ActionService::API::Base
|
||||
inflect_names false
|
||||
|
||||
api_method :doGetCachedPage, :returns => [:string], :expects => [{:key=>:string}, {:url=>:string}]
|
||||
api_method :doGetSpellingSuggestion, :returns => [:string], :expects => [{:key=>:string}, {:phrase=>:string}]
|
||||
|
||||
api_method :doGoogleSearch, :returns => [GoogleSearchResult], :expects => [
|
||||
{:key=>:string},
|
||||
{:q=>:string},
|
||||
{:start=>:int},
|
||||
{:maxResults=>:int},
|
||||
{:filter=>:bool},
|
||||
{:restrict=>:string},
|
||||
{:safeSearch=>:bool},
|
||||
{:lr=>:string},
|
||||
{:ie=>:string},
|
||||
{:oe=>:string}
|
||||
]
|
||||
end
|
||||
|
||||
class GoogleSearchService < ActionService::Base
|
||||
service_api GoogleSearchAPI
|
||||
|
||||
def doGetCachedPage(key, url)
|
||||
"<html><body>i am a cached page</body></html>"
|
||||
end
|
||||
|
||||
def doSpellingSuggestion(key, phrase)
|
||||
"Did you mean 'teh'?"
|
||||
end
|
||||
|
||||
def doGoogleSearch(key, q, start, maxResults, filter, restrict, safeSearch, lr, ie, oe)
|
||||
resultElement = ResultElement.new
|
||||
resultElement.summary = "ONlamp.com: Rolling with Ruby on Rails"
|
||||
resultElement.URL = "http://www.onlamp.com/pub/a/onlamp/2005/01/20/rails.html"
|
||||
resultElement.snippet = "Curt Hibbs shows off Ruby on Rails by building a simple application that requires " +
|
||||
"almost no Ruby experience. ... Rolling with Ruby on Rails. ..."
|
||||
resultElement.title = "Teh Railz0r"
|
||||
resultElement.cachedSize = "Almost no lines of code!"
|
||||
resultElement.relatedInformationPresent = true
|
||||
resultElement.hostName = "rubyonrails.com"
|
||||
resultElement.directoryCategory = category("Web Development", "UTF-8")
|
||||
|
||||
result = GoogleSearchResult.new
|
||||
result.documentFiltering = filter
|
||||
result.searchComments = ""
|
||||
result.estimatedTotalResultsCount = 322000
|
||||
result.estimateIsExact = false
|
||||
result.resultElements = [resultElement]
|
||||
result.searchQuery = "http://www.google.com/search?q=ruby+on+rails"
|
||||
result.startIndex = start
|
||||
result.endIndex = start + maxResults
|
||||
result.searchTips = "\"on\" is a very common word and was not included in your search [details]"
|
||||
result.searchTime = 0.000001
|
||||
|
||||
# For Mono, we have to clone objects if they're referenced by more than one place, otherwise
|
||||
# the Ruby SOAP collapses them into one instance and uses references all over the
|
||||
# place, confusing Mono.
|
||||
#
|
||||
# This has recently been fixed:
|
||||
# http://bugzilla.ximian.com/show_bug.cgi?id=72265
|
||||
result.directoryCategories = [
|
||||
category("Web Development", "UTF-8"),
|
||||
category("Programming", "US-ASCII"),
|
||||
]
|
||||
|
||||
result
|
||||
end
|
||||
|
||||
private
|
||||
def category(name, encoding)
|
||||
cat = DirectoryCategory.new
|
||||
cat.fullViewableName = name.dup
|
||||
cat.specialEncoding = encoding.dup
|
||||
cat
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
require 'google_search_service'
|
||||
|
||||
class SearchController < ApplicationController
|
||||
wsdl_service_name 'GoogleSearch'
|
||||
service_dispatching_mode :delegated
|
||||
service :beta3, GoogleSearchService.new
|
||||
end
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
class DirectoryCategory < ActionService::Struct
|
||||
member :fullViewableName, :string
|
||||
member :specialEncoding, :string
|
||||
end
|
||||
|
||||
class ResultElement < ActionService::Struct
|
||||
member :summary, :string
|
||||
member :URL, :string
|
||||
member :snippet, :string
|
||||
member :title, :string
|
||||
member :cachedSize, :string
|
||||
member :relatedInformationPresent, :bool
|
||||
member :hostName, :string
|
||||
member :directoryCategory, DirectoryCategory
|
||||
member :directoryTitle, :string
|
||||
end
|
||||
|
||||
class GoogleSearchResult < ActionService::Struct
|
||||
member :documentFiltering, :bool
|
||||
member :searchComments, :string
|
||||
member :estimatedTotalResultsCount, :int
|
||||
member :estimateIsExact, :bool
|
||||
member :resultElements, [ResultElement]
|
||||
member :searchQuery, :string
|
||||
member :startIndex, :int
|
||||
member :endIndex, :int
|
||||
member :searchTips, :string
|
||||
member :directoryCategories, [DirectoryCategory]
|
||||
member :searchTime, :float
|
||||
end
|
||||
|
||||
class GoogleSearchAPI < ActionService::API::Base
|
||||
inflect_names false
|
||||
|
||||
api_method :doGetCachedPage, :returns => [:string], :expects => [{:key=>:string}, {:url=>:string}]
|
||||
api_method :doGetSpellingSuggestion, :returns => [:string], :expects => [{:key=>:string}, {:phrase=>:string}]
|
||||
|
||||
api_method :doGoogleSearch, :returns => [GoogleSearchResult], :expects => [
|
||||
{:key=>:string},
|
||||
{:q=>:string},
|
||||
{:start=>:int},
|
||||
{:maxResults=>:int},
|
||||
{:filter=>:bool},
|
||||
{:restrict=>:string},
|
||||
{:safeSearch=>:bool},
|
||||
{:lr=>:string},
|
||||
{:ie=>:string},
|
||||
{:oe=>:string}
|
||||
]
|
||||
end
|
||||
|
||||
class SearchController < ApplicationController
|
||||
service_api GoogleSearchAPI
|
||||
wsdl_service_name 'GoogleSearch'
|
||||
|
||||
def doGetCachedPage
|
||||
"<html><body>i am a cached page. my key was %s, url was %s</body></html>" % [@params['key'], @params['url']]
|
||||
end
|
||||
|
||||
def doSpellingSuggestion
|
||||
"%s: Did you mean '%s'?" % [@params['key'], @params['phrase']]
|
||||
end
|
||||
|
||||
def doGoogleSearch
|
||||
resultElement = ResultElement.new
|
||||
resultElement.summary = "ONlamp.com: Rolling with Ruby on Rails"
|
||||
resultElement.URL = "http://www.onlamp.com/pub/a/onlamp/2005/01/20/rails.html"
|
||||
resultElement.snippet = "Curt Hibbs shows off Ruby on Rails by building a simple application that requires " +
|
||||
"almost no Ruby experience. ... Rolling with Ruby on Rails. ..."
|
||||
resultElement.title = "Teh Railz0r"
|
||||
resultElement.cachedSize = "Almost no lines of code!"
|
||||
resultElement.relatedInformationPresent = true
|
||||
resultElement.hostName = "rubyonrails.com"
|
||||
resultElement.directoryCategory = category("Web Development", "UTF-8")
|
||||
|
||||
result = GoogleSearchResult.new
|
||||
result.documentFiltering = @params['filter']
|
||||
result.searchComments = ""
|
||||
result.estimatedTotalResultsCount = 322000
|
||||
result.estimateIsExact = false
|
||||
result.resultElements = [resultElement]
|
||||
result.searchQuery = "http://www.google.com/search?q=ruby+on+rails"
|
||||
result.startIndex = @params['start']
|
||||
result.endIndex = @params['start'] + @params['maxResults']
|
||||
result.searchTips = "\"on\" is a very common word and was not included in your search [details]"
|
||||
result.searchTime = 0.000001
|
||||
|
||||
# For Mono, we have to clone objects if they're referenced by more than one place, otherwise
|
||||
# the Ruby SOAP collapses them into one instance and uses references all over the
|
||||
# place, confusing Mono.
|
||||
#
|
||||
# This has recently been fixed:
|
||||
# http://bugzilla.ximian.com/show_bug.cgi?id=72265
|
||||
result.directoryCategories = [
|
||||
category("Web Development", "UTF-8"),
|
||||
category("Programming", "US-ASCII"),
|
||||
]
|
||||
|
||||
result
|
||||
end
|
||||
|
||||
private
|
||||
def category(name, encoding)
|
||||
cat = DirectoryCategory.new
|
||||
cat.fullViewableName = name.dup
|
||||
cat.specialEncoding = encoding.dup
|
||||
cat
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
= metaWeblog example
|
||||
|
||||
|
||||
This example shows how one might begin to go about adding metaWeblog
|
||||
(http://www.xmlrpc.com/metaWeblogApi) API support to a Rails-based
|
||||
blogging application.
|
||||
|
||||
|
||||
= Running
|
||||
|
||||
1. Ensure you have the 'actionservice' Gem installed. You can generate it using
|
||||
this command:
|
||||
|
||||
$ rake package
|
||||
|
||||
|
||||
2. Edit config/environment.rb, and add the following line after the rest of the
|
||||
require_gem statements:
|
||||
|
||||
require_gem 'actionservice'
|
||||
|
||||
|
||||
3. Copy blog_controller.rb to "app/controllers" in a Rails project.
|
||||
|
||||
|
||||
4. Fire up a desktop blogging application (such as BloGTK on Linux),
|
||||
point it at http://localhost:3000/blog/api, and try creating or
|
||||
editing blog posts.
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
# structures as defined by the metaWeblog/blogger
|
||||
# specifications.
|
||||
module Blog
|
||||
class Enclosure < ActionService::Struct
|
||||
member :url, :string
|
||||
member :length, :int
|
||||
member :type, :string
|
||||
end
|
||||
|
||||
class Source < ActionService::Struct
|
||||
member :url, :string
|
||||
member :name, :string
|
||||
end
|
||||
|
||||
class Post < ActionService::Struct
|
||||
member :title, :string
|
||||
member :link, :string
|
||||
member :description, :string
|
||||
member :author, :string
|
||||
member :category, :string
|
||||
member :comments, :string
|
||||
member :enclosure, Enclosure
|
||||
member :guid, :string
|
||||
member :pubDate, :string
|
||||
member :source, Source
|
||||
end
|
||||
|
||||
class Blog < ActionService::Struct
|
||||
member :url, :string
|
||||
member :blogid, :string
|
||||
member :blogName, :string
|
||||
end
|
||||
end
|
||||
|
||||
# skeleton metaWeblog API
|
||||
class MetaWeblogAPI < ActionService::API::Base
|
||||
inflect_names false
|
||||
|
||||
api_method :newPost, :returns => [:string], :expects => [
|
||||
{:blogid=>:string},
|
||||
{:username=>:string},
|
||||
{:password=>:string},
|
||||
{:struct=>Blog::Post},
|
||||
{:publish=>:bool},
|
||||
]
|
||||
|
||||
api_method :editPost, :returns => [:bool], :expects => [
|
||||
{:postid=>:string},
|
||||
{:username=>:string},
|
||||
{:password=>:string},
|
||||
{:struct=>Blog::Post},
|
||||
{:publish=>:bool},
|
||||
]
|
||||
|
||||
api_method :getPost, :returns => [Blog::Post], :expects => [
|
||||
{:postid=>:string},
|
||||
{:username=>:string},
|
||||
{:password=>:string},
|
||||
]
|
||||
|
||||
api_method :getUsersBlogs, :returns => [[Blog::Blog]], :expects => [
|
||||
{:appkey=>:string},
|
||||
{:username=>:string},
|
||||
{:password=>:string},
|
||||
]
|
||||
|
||||
api_method :getRecentPosts, :returns => [[Blog::Post]], :expects => [
|
||||
{:blogid=>:string},
|
||||
{:username=>:string},
|
||||
{:password=>:string},
|
||||
{:numberOfPosts=>:int},
|
||||
]
|
||||
end
|
||||
|
||||
class BlogController < ApplicationController
|
||||
service_api MetaWeblogAPI
|
||||
|
||||
def initialize
|
||||
@postid = 0
|
||||
end
|
||||
|
||||
def newPost
|
||||
$stderr.puts 'Creating post: username=%s password=%s struct=%s' % [
|
||||
@params['username'],
|
||||
@params['password'],
|
||||
@params['struct'].inspect
|
||||
]
|
||||
(@postid += 1).to_s
|
||||
end
|
||||
|
||||
def editPost
|
||||
$stderr.puts 'Editing post: username=%s password=%s struct=%s' % [
|
||||
@params['username'],
|
||||
@params['password'],
|
||||
@params['struct'].inspect
|
||||
]
|
||||
true
|
||||
end
|
||||
|
||||
def getUsersBlogs
|
||||
$stderr.puts "Returning user %s's blogs" % @params['username']
|
||||
blog = Blog::Blog.new
|
||||
blog.url = 'http://blog.xeraph.org'
|
||||
blog.blogid = 'sttm'
|
||||
blog.blogName = 'slave to the machine'
|
||||
[blog]
|
||||
end
|
||||
|
||||
def getRecentPosts
|
||||
$stderr.puts "Returning recent posts (%d requested)" % @params['numberOfPosts']
|
||||
post1 = Blog::Post.new
|
||||
post1.title = 'first post!'
|
||||
post1.link = 'http://blog.xeraph.org/testOne.html'
|
||||
post1.description = 'this is the first post'
|
||||
post2 = Blog::Post.new
|
||||
post2.title = 'second post!'
|
||||
post2.link = 'http://blog.xeraph.org/testTwo.html'
|
||||
post2.description = 'this is the second post'
|
||||
[post1, post2]
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#--
|
||||
# Copyright (C) 2005 Leon Breedt
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be
|
||||
# included in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#++
|
||||
|
||||
begin
|
||||
require 'active_support'
|
||||
require 'action_controller'
|
||||
require 'active_record'
|
||||
rescue LoadError
|
||||
require 'rubygems'
|
||||
require_gem 'activesupport', '>= 0.9.0'
|
||||
require_gem 'actionpack', '>= 1.4.0'
|
||||
require_gem 'activerecord', '>= 1.6.0'
|
||||
end
|
||||
|
||||
$:.unshift(File.dirname(__FILE__))
|
||||
|
||||
require 'action_service/base'
|
||||
require 'action_service/client'
|
||||
require 'action_service/invocation'
|
||||
require 'action_service/api'
|
||||
require 'action_service/struct'
|
||||
require 'action_service/container'
|
||||
require 'action_service/protocol'
|
||||
require 'action_service/router'
|
||||
|
||||
ActionService::Base.class_eval do
|
||||
include ActionService::API
|
||||
include ActionService::Invocation
|
||||
end
|
||||
|
||||
ActionController::Base.class_eval do
|
||||
include ActionService::Container
|
||||
include ActionService::Protocol::Registry
|
||||
include ActionService::Protocol::Soap
|
||||
include ActionService::Protocol::XmlRpc
|
||||
include ActionService::API
|
||||
include ActionService::API::ActionController
|
||||
include ActionService::Router::ActionController
|
||||
include ActionService::Router::Wsdl
|
||||
end
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
require 'action_service/api/abstract'
|
||||
require 'action_service/api/action_controller'
|
||||
|
|
@ -0,0 +1,198 @@
|
|||
module ActionService # :nodoc:
|
||||
module API # :nodoc:
|
||||
class APIError < ActionService::ActionServiceError # :nodoc:
|
||||
end
|
||||
|
||||
def self.append_features(base) # :nodoc:
|
||||
super
|
||||
base.extend(ClassMethods)
|
||||
end
|
||||
|
||||
module ClassMethods
|
||||
# Attaches ActionService API +definition+ to the calling class.
|
||||
#
|
||||
# If +definition+ is not an ActionService::API::Base derivative class
|
||||
# object, it may be a symbol or a string, in which case a file named
|
||||
# <tt>definition_api.rb</tt> will be expected to exist in the load path,
|
||||
# containing an API definition class named <tt>DefinitionAPI</tt> or
|
||||
# <tt>DefinitionApi</tt>.
|
||||
#
|
||||
# Action Controllers can have a default associated API, removing the need
|
||||
# to call this method if you follow the Action Service naming conventions.
|
||||
#
|
||||
# A controller with a class name of GoogleSearchController will
|
||||
# implicitly load <tt>app/apis/google_search_api.rb</tt>, and expect the
|
||||
# API definition class to be named <tt>GoogleSearchAPI</tt> or
|
||||
# <tt>GoogleSearchApi</tt>.
|
||||
#
|
||||
# ==== Service class example
|
||||
#
|
||||
# class MyService < ActionService::Base
|
||||
# service_api MyAPI
|
||||
# end
|
||||
#
|
||||
# class MyAPI < ActionService::API::Base
|
||||
# ...
|
||||
# end
|
||||
#
|
||||
# ==== Controller class example
|
||||
#
|
||||
# class MyController < ActionController::Base
|
||||
# service_api MyAPI
|
||||
# end
|
||||
#
|
||||
# class MyAPI < ActionService::API::Base
|
||||
# ...
|
||||
# end
|
||||
def service_api(definition=nil)
|
||||
if definition.nil?
|
||||
read_inheritable_attribute("service_api")
|
||||
else
|
||||
if definition.is_a?(Symbol)
|
||||
raise(APIError, "symbols can only be used for #service_api inside of a controller")
|
||||
end
|
||||
unless definition.respond_to?(:ancestors) && definition.ancestors.include?(Base)
|
||||
raise(APIError, "#{definition.to_s} is not a valid API definition")
|
||||
end
|
||||
write_inheritable_attribute("service_api", definition)
|
||||
call_service_api_callbacks(self, definition)
|
||||
end
|
||||
end
|
||||
|
||||
def add_service_api_callback(&block) # :nodoc:
|
||||
write_inheritable_array("service_api_callbacks", [block])
|
||||
end
|
||||
|
||||
private
|
||||
def call_service_api_callbacks(container_class, definition)
|
||||
(read_inheritable_attribute("service_api_callbacks") || []).each do |block|
|
||||
block.call(container_class, definition)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# A service API class specifies the methods that will be available for
|
||||
# invocation for an API. It also contains metadata such as the method type
|
||||
# signature hints.
|
||||
#
|
||||
# It is not intended to be instantiated.
|
||||
#
|
||||
# It is attached to service implementation classes like ActionService::Base
|
||||
# and ActionController::Base derivatives with ClassMethods#service_api.
|
||||
class Base
|
||||
# Whether to transform API method names into camel-cased
|
||||
# names
|
||||
class_inheritable_option :inflect_names, true
|
||||
|
||||
# If present, the name of a method to call when the remote caller
|
||||
# tried to call a nonexistent method. Semantically equivalent to
|
||||
# +method_missing+.
|
||||
class_inheritable_option :default_api_method
|
||||
|
||||
# Disallow instantiation
|
||||
private_class_method :new, :allocate
|
||||
|
||||
class << self
|
||||
include ActionService::Signature
|
||||
|
||||
# API methods have a +name+, which must be the Ruby method name to use when
|
||||
# performing the invocation on the service object.
|
||||
#
|
||||
# The type signature hints for the method input parameters and return value
|
||||
# can by specified in +options+.
|
||||
#
|
||||
# A signature hint is an array of one or more parameter type specifiers.
|
||||
# A type specifier can be one of the following:
|
||||
#
|
||||
# * A symbol or string of representing one of the Action Service base types.
|
||||
# See ActionService::Signature for a canonical list of the base types.
|
||||
# * The Class object of the parameter type
|
||||
# * A single-element Array containing one of the two preceding items. This
|
||||
# will cause Action Service to treat the parameter at that position
|
||||
# as an array containing only values of the given type.
|
||||
# * A Hash containing as key the name of the parameter, and as value
|
||||
# one of the three preceding items
|
||||
#
|
||||
# If no method input parameter or method return value hints are given,
|
||||
# the method is assumed to take no parameters and return no values of
|
||||
# interest, and any values that are received by the server will be
|
||||
# discarded and ignored.
|
||||
#
|
||||
# Valid options:
|
||||
# [<tt>:expects</tt>] Signature hint for the method input parameters
|
||||
# [<tt>:returns</tt>] Signature hint for the method return value
|
||||
# [<tt>:expects_and_returns</tt>] Signature hint for both input parameters and return value
|
||||
def api_method(name, options={})
|
||||
validate_options([:expects, :returns, :expects_and_returns], options.keys)
|
||||
if options[:expects_and_returns]
|
||||
expects = options[:expects_and_returns]
|
||||
returns = options[:expects_and_returns]
|
||||
else
|
||||
expects = options[:expects]
|
||||
returns = options[:returns]
|
||||
end
|
||||
expects = canonical_signature(expects) if expects
|
||||
returns = canonical_signature(returns) if returns
|
||||
if expects && Object.const_defined?('ActiveRecord')
|
||||
expects.each do |param|
|
||||
klass = signature_parameter_class(param)
|
||||
klass = klass[0] if klass.is_a?(Array)
|
||||
if klass.ancestors.include?(ActiveRecord::Base)
|
||||
raise(ActionServiceError, "ActiveRecord model classes not allowed in :expects")
|
||||
end
|
||||
end
|
||||
end
|
||||
name = name.to_sym
|
||||
public_name = public_api_method_name(name)
|
||||
info = { :expects => expects, :returns => returns }
|
||||
write_inheritable_hash("api_methods", name => info)
|
||||
write_inheritable_hash("api_public_method_names", public_name => name)
|
||||
end
|
||||
|
||||
# Whether the given method name is a service method on this API
|
||||
def has_api_method?(name)
|
||||
api_methods.has_key?(name)
|
||||
end
|
||||
|
||||
# Whether the given public method name has a corresponding service method
|
||||
# on this API
|
||||
def has_public_api_method?(public_name)
|
||||
api_public_method_names.has_key?(public_name)
|
||||
end
|
||||
|
||||
# The corresponding public method name for the given service method name
|
||||
def public_api_method_name(name)
|
||||
if inflect_names
|
||||
name.to_s.camelize
|
||||
else
|
||||
name.to_s
|
||||
end
|
||||
end
|
||||
|
||||
# The corresponding service method name for the given public method name
|
||||
def api_method_name(public_name)
|
||||
api_public_method_names[public_name]
|
||||
end
|
||||
|
||||
# A Hash containing all service methods on this API, and their
|
||||
# associated metadata.
|
||||
def api_methods
|
||||
read_inheritable_attribute("api_methods") || {}
|
||||
end
|
||||
|
||||
private
|
||||
def api_public_method_names
|
||||
read_inheritable_attribute("api_public_method_names") || {}
|
||||
end
|
||||
|
||||
def validate_options(valid_option_keys, supplied_option_keys)
|
||||
unknown_option_keys = supplied_option_keys - valid_option_keys
|
||||
unless unknown_option_keys.empty?
|
||||
raise(ActionServiceError, "Unknown options: #{unknown_option_keys}")
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
module ActionService # :nodoc:
|
||||
module API # :nodoc:
|
||||
module ActionController # :nodoc:
|
||||
def self.append_features(base) # :nodoc:
|
||||
base.class_eval do
|
||||
class << self
|
||||
alias_method :inherited_without_api, :inherited
|
||||
alias_method :service_api_without_require, :service_api
|
||||
end
|
||||
end
|
||||
base.extend(ClassMethods)
|
||||
end
|
||||
|
||||
module ClassMethods
|
||||
# Creates a _protected_ factory method with the given
|
||||
# +name+. This method will create a +protocol+ client connected
|
||||
# to the given endpoint URL.
|
||||
#
|
||||
# ==== Example
|
||||
#
|
||||
# class MyController < ActionController::Base
|
||||
# client_api :blogger, :xmlrpc, "http://blogger.com/myblog/api/RPC2", :handler_name => 'blogger'
|
||||
# end
|
||||
#
|
||||
# In this example, a protected method named <tt>blogger</tt> will
|
||||
# now exist on the controller, and calling it will return the
|
||||
# XML-RPC client object for working with that remote service.
|
||||
#
|
||||
# The same rules as ActionService::API::Base#service_api are
|
||||
# used to retrieve the API definition with the given +name+.
|
||||
#
|
||||
# +options+ is the set of protocol client specific options,
|
||||
# see the protocol client class for details.
|
||||
#
|
||||
# If your API definition does not exist on the load path
|
||||
# with the correct rules for it to be found, you can
|
||||
# pass through the API definition class in +options+, using
|
||||
# a key of <tt>:api</tt>
|
||||
def client_api(name, protocol, endpoint_uri, options={})
|
||||
unless method_defined?(name)
|
||||
api_klass = options.delete(:api) || require_api(name)
|
||||
class_eval do
|
||||
define_method(name) do
|
||||
probe_protocol_client(api_klass, protocol, endpoint_uri, options)
|
||||
end
|
||||
protected name
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def service_api(definition=nil) # :nodoc:
|
||||
return service_api_without_require if definition.nil?
|
||||
case definition
|
||||
when String, Symbol
|
||||
klass = require_api(definition)
|
||||
else
|
||||
klass = definition
|
||||
end
|
||||
service_api_without_require(klass)
|
||||
end
|
||||
|
||||
def require_api(name) # :nodoc:
|
||||
case name
|
||||
when String, Symbol
|
||||
file_name = name.to_s.underscore + "_api"
|
||||
class_name = file_name.camelize
|
||||
class_names = [class_name, class_name.sub(/Api$/, 'API')]
|
||||
begin
|
||||
require_dependency(file_name)
|
||||
rescue LoadError => load_error
|
||||
requiree = / -- (.*?)(\.rb)?$/.match(load_error).to_a[1]
|
||||
raise LoadError, requiree == file_name ? "Missing API definition file in apis/#{file_name}.rb" : "Can't load file: #{requiree}"
|
||||
end
|
||||
klass = nil
|
||||
class_names.each do |name|
|
||||
klass = name.constantize rescue nil
|
||||
break unless klass.nil?
|
||||
end
|
||||
unless klass
|
||||
raise(NameError, "neither #{class_names[0]} or #{class_names[1]} found")
|
||||
end
|
||||
klass
|
||||
else
|
||||
raise(ArgumentError, "expected String or Symbol argument")
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
def inherited(child)
|
||||
inherited_without_api(child)
|
||||
child.service_api(child.controller_path)
|
||||
rescue Exception => e
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
require 'action_service/support/class_inheritable_options'
|
||||
require 'action_service/support/signature'
|
||||
|
||||
module ActionService # :nodoc:
|
||||
class ActionServiceError < StandardError # :nodoc:
|
||||
end
|
||||
|
||||
# An Action Service object implements a specified API.
|
||||
#
|
||||
# Used by controllers operating in _Delegated_ dispatching mode.
|
||||
#
|
||||
# ==== Example
|
||||
#
|
||||
# class PersonService < ActionService::Base
|
||||
# service_api PersonAPI
|
||||
#
|
||||
# def find_person(criteria)
|
||||
# Person.find_all [...]
|
||||
# end
|
||||
#
|
||||
# def delete_person(id)
|
||||
# Person.find_by_id(id).destroy
|
||||
# end
|
||||
# end
|
||||
#
|
||||
# class PersonAPI < ActionService::API::Base
|
||||
# api_method :find_person, :expects => [SearchCriteria], :returns => [[Person]]
|
||||
# api_method :delete_person, :expects => [:int]
|
||||
# end
|
||||
#
|
||||
# class SearchCriteria < ActionStruct::Base
|
||||
# member :firstname, :string
|
||||
# member :lastname, :string
|
||||
# member :email, :string
|
||||
# end
|
||||
class Base
|
||||
# Whether to report exceptions back to the caller in the protocol's exception
|
||||
# format
|
||||
class_inheritable_option :service_exception_reporting, true
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
require 'action_service/client/base'
|
||||
require 'action_service/client/soap'
|
||||
require 'action_service/client/xmlrpc'
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
module ActionService # :nodoc:
|
||||
module Client # :nodoc:
|
||||
class ClientError < StandardError # :nodoc:
|
||||
end
|
||||
|
||||
class Base # :nodoc:
|
||||
def initialize(api, endpoint_uri)
|
||||
@api = api
|
||||
@endpoint_uri = endpoint_uri
|
||||
end
|
||||
|
||||
def method_missing(name, *args) # :nodoc:
|
||||
call_name = method_name(name)
|
||||
return super(name, *args) if call_name.nil?
|
||||
perform_invocation(call_name, args)
|
||||
end
|
||||
|
||||
protected
|
||||
def perform_invocation(method_name, args) # :nodoc:
|
||||
raise NotImplementedError, "use a protocol-specific client"
|
||||
end
|
||||
|
||||
private
|
||||
def method_name(name)
|
||||
if @api.has_api_method?(name.to_sym)
|
||||
name.to_s
|
||||
elsif @api.has_public_api_method?(name.to_s)
|
||||
@api.api_method_name(name.to_s).to_s
|
||||
else
|
||||
nil
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
require 'soap/rpc/driver'
|
||||
require 'uri'
|
||||
|
||||
module ActionService # :nodoc:
|
||||
module Client # :nodoc:
|
||||
|
||||
# Implements SOAP client support (using RPC encoding for the messages).
|
||||
#
|
||||
# ==== Example Usage
|
||||
#
|
||||
# class PersonAPI < ActionService::API::Base
|
||||
# api_method :find_all, :returns => [[Person]]
|
||||
# end
|
||||
#
|
||||
# soap_client = ActionService::Client::Soap.new(PersonAPI, "http://...")
|
||||
# persons = soap_client.find_all
|
||||
#
|
||||
class Soap < Base
|
||||
|
||||
# Creates a new web service client using the SOAP RPC protocol.
|
||||
#
|
||||
# +api+ must be an ActionService::API::Base derivative, and
|
||||
# +endpoint_uri+ must point at the relevant URL to which protocol requests
|
||||
# will be sent with HTTP POST.
|
||||
#
|
||||
# Valid options:
|
||||
# [<tt>:service_name</tt>] If the remote server has used a custom +wsdl_service_name+
|
||||
# option, you must specify it here
|
||||
def initialize(api, endpoint_uri, options={})
|
||||
super(api, endpoint_uri)
|
||||
@service_name = options[:service_name] || 'ActionService'
|
||||
@namespace = "urn:#{@service_name}"
|
||||
@mapper = ActionService::Protocol::Soap::SoapMapper.new(@namespace)
|
||||
@protocol = ActionService::Protocol::Soap::SoapProtocol.new(@mapper)
|
||||
@soap_action_base = options[:soap_action_base]
|
||||
@soap_action_base ||= URI.parse(endpoint_uri).path
|
||||
@driver = create_soap_rpc_driver(api, endpoint_uri)
|
||||
end
|
||||
|
||||
protected
|
||||
def perform_invocation(method_name, args)
|
||||
@driver.send(method_name, *args)
|
||||
end
|
||||
|
||||
def soap_action(method_name)
|
||||
"#{@soap_action_base}/#{method_name}"
|
||||
end
|
||||
|
||||
private
|
||||
def create_soap_rpc_driver(api, endpoint_uri)
|
||||
@mapper.map_api(api)
|
||||
driver = SoapDriver.new(endpoint_uri, nil)
|
||||
driver.mapping_registry = @mapper.registry
|
||||
api.api_methods.each do |name, info|
|
||||
public_name = api.public_api_method_name(name)
|
||||
qname = XSD::QName.new(@namespace, public_name)
|
||||
action = soap_action(public_name)
|
||||
expects = info[:expects]
|
||||
returns = info[:returns]
|
||||
param_def = []
|
||||
i = 1
|
||||
if expects
|
||||
expects.each do |klass|
|
||||
param_name = klass.is_a?(Hash) ? klass.keys[0] : "param#{i}"
|
||||
mapping = @mapper.lookup(klass)
|
||||
param_def << ['in', param_name, mapping.registry_mapping]
|
||||
i += 1
|
||||
end
|
||||
end
|
||||
if returns
|
||||
mapping = @mapper.lookup(returns[0])
|
||||
param_def << ['retval', 'return', mapping.registry_mapping]
|
||||
end
|
||||
driver.add_method(qname, action, name.to_s, param_def)
|
||||
end
|
||||
driver
|
||||
end
|
||||
|
||||
class SoapDriver < SOAP::RPC::Driver # :nodoc:
|
||||
def add_method(qname, soapaction, name, param_def)
|
||||
@proxy.add_rpc_method(qname, soapaction, name, param_def)
|
||||
add_rpc_method_interface(name, param_def)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
require 'uri'
|
||||
require 'xmlrpc/client'
|
||||
|
||||
module ActionService # :nodoc:
|
||||
module Client # :nodoc:
|
||||
|
||||
# Implements XML-RPC client support
|
||||
#
|
||||
# ==== Example Usage
|
||||
#
|
||||
# class BloggerAPI < ActionService::API::Base
|
||||
# inflect_names false
|
||||
# api_method :getRecentPosts, :returns => [[Blog::Post]]
|
||||
# end
|
||||
#
|
||||
# blog = ActionService::Client::XmlRpc.new(BloggerAPI, "http://.../RPC", :handler_name => "blogger")
|
||||
# posts = blog.getRecentPosts
|
||||
class XmlRpc < Base
|
||||
|
||||
# Creates a new web service client using the XML-RPC protocol.
|
||||
#
|
||||
# +api+ must be an ActionService::API::Base derivative, and
|
||||
# +endpoint_uri+ must point at the relevant URL to which protocol requests
|
||||
# will be sent with HTTP POST.
|
||||
#
|
||||
# Valid options:
|
||||
# [<tt>:handler_name</tt>] If the remote server defines its services inside special
|
||||
# handler (the Blogger API uses a <tt>"blogger"</tt> handler name for example),
|
||||
# provide it here, or your method calls will fail
|
||||
def initialize(api, endpoint_uri, options={})
|
||||
@api = api
|
||||
@handler_name = options[:handler_name]
|
||||
@client = XMLRPC::Client.new2(endpoint_uri, options[:proxy], options[:timeout])
|
||||
end
|
||||
|
||||
protected
|
||||
def perform_invocation(method_name, args)
|
||||
args = transform_outgoing_method_params(method_name, args)
|
||||
ok, return_value = @client.call2(public_name(method_name), *args)
|
||||
return transform_return_value(method_name, return_value) if ok
|
||||
raise(ClientError, "#{return_value.faultCode}: #{return_value.faultString}")
|
||||
end
|
||||
|
||||
def transform_outgoing_method_params(method_name, params)
|
||||
info = @api.api_methods[method_name.to_sym]
|
||||
signature = info[:expects]
|
||||
signature_length = signature.nil?? 0 : signature.length
|
||||
if signature_length != params.length
|
||||
raise(ProtocolError, "API declares #{public_name(method_name)} to accept " +
|
||||
"#{signature_length} parameters, but #{params.length} parameters " +
|
||||
"were supplied")
|
||||
end
|
||||
if signature_length > 0
|
||||
signature = Protocol::XmlRpc::XmlRpcProtocol.transform_array_types(signature)
|
||||
(1..signature.size).each do |i|
|
||||
i -= 1
|
||||
params[i] = Protocol::XmlRpc::XmlRpcProtocol.ruby_to_xmlrpc(params[i], signature[i])
|
||||
end
|
||||
end
|
||||
params
|
||||
end
|
||||
|
||||
def transform_return_value(method_name, return_value)
|
||||
info = @api.api_methods[method_name.to_sym]
|
||||
return true unless signature = info[:returns]
|
||||
signature = Protocol::XmlRpc::XmlRpcProtocol.transform_array_types(signature)
|
||||
Protocol::XmlRpc::XmlRpcProtocol.xmlrpc_to_ruby(return_value, signature[0])
|
||||
end
|
||||
|
||||
def public_name(method_name)
|
||||
public_name = @api.public_api_method_name(method_name)
|
||||
@handler_name ? "#{@handler_name}.#{public_name}" : public_name
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,232 @@
|
|||
module ActionService # :nodoc:
|
||||
module Container # :nodoc:
|
||||
class ContainerError < ActionService::ActionServiceError # :nodoc:
|
||||
end
|
||||
|
||||
def self.append_features(base) # :nodoc:
|
||||
super
|
||||
base.class_inheritable_option(:service_dispatching_mode, :direct)
|
||||
base.class_inheritable_option(:service_exception_reporting, true)
|
||||
base.extend(ClassMethods)
|
||||
base.send(:include, ActionService::Container::InstanceMethods)
|
||||
end
|
||||
|
||||
module ClassMethods
|
||||
# Declares a service that will provides access to the API of the given
|
||||
# service +object+. +object+ must be an ActionService::Base derivative.
|
||||
#
|
||||
# Service object creation can either be _immediate_, where the object
|
||||
# instance is given at class definition time, or _deferred_, where
|
||||
# object instantiation is delayed until request time.
|
||||
#
|
||||
# ==== Immediate service object example
|
||||
#
|
||||
# class ApiController < ApplicationController
|
||||
# service_dispatching_mode :delegated
|
||||
#
|
||||
# service :person, PersonService.new
|
||||
# end
|
||||
#
|
||||
# For deferred instantiation, a block should be given instead of an
|
||||
# object instance. This block will be executed in controller instance
|
||||
# context, so it can rely on controller instance variables being present.
|
||||
#
|
||||
# ==== Deferred service object example
|
||||
#
|
||||
# class ApiController < ApplicationController
|
||||
# service_dispatching_mode :delegated
|
||||
#
|
||||
# service(:person) { PersonService.new(@request.env) }
|
||||
# end
|
||||
def service(name, object=nil, &block)
|
||||
if (object && block_given?) || (object.nil? && block.nil?)
|
||||
raise(ContainerError, "either service, or a block must be given")
|
||||
end
|
||||
name = name.to_sym
|
||||
if block_given?
|
||||
info = { name => { :block => block } }
|
||||
else
|
||||
info = { name => { :object => object } }
|
||||
end
|
||||
write_inheritable_hash("action_services", info)
|
||||
call_service_definition_callbacks(self, name, info)
|
||||
end
|
||||
|
||||
# Whether this service contains a service with the given +name+
|
||||
def has_service?(name)
|
||||
services.has_key?(name.to_sym)
|
||||
end
|
||||
|
||||
def services # :nodoc:
|
||||
read_inheritable_attribute("action_services") || {}
|
||||
end
|
||||
|
||||
def add_service_definition_callback(&block) # :nodoc:
|
||||
write_inheritable_array("service_definition_callbacks", [block])
|
||||
end
|
||||
|
||||
private
|
||||
def call_service_definition_callbacks(container_class, service_name, service_info)
|
||||
(read_inheritable_attribute("service_definition_callbacks") || []).each do |block|
|
||||
block.call(container_class, service_name, service_info)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
module InstanceMethods # :nodoc:
|
||||
def service_object(service_name)
|
||||
info = self.class.services[service_name.to_sym]
|
||||
unless info
|
||||
raise(ContainerError, "no such service '#{service_name}'")
|
||||
end
|
||||
service = info[:block]
|
||||
service ? instance_eval(&service) : info[:object]
|
||||
end
|
||||
|
||||
private
|
||||
def dispatch_service_request(protocol_request)
|
||||
case service_dispatching_mode
|
||||
when :direct
|
||||
dispatch_direct_service_request(protocol_request)
|
||||
when :delegated
|
||||
dispatch_delegated_service_request(protocol_request)
|
||||
else
|
||||
raise(ContainerError, "unsupported dispatching mode '#{service_dispatching_mode}'")
|
||||
end
|
||||
end
|
||||
|
||||
def dispatch_direct_service_request(protocol_request)
|
||||
public_method_name = protocol_request.public_method_name
|
||||
api = self.class.service_api
|
||||
method_name = api.api_method_name(public_method_name)
|
||||
block = nil
|
||||
expects = nil
|
||||
if method_name
|
||||
signature = api.api_methods[method_name]
|
||||
expects = signature[:expects]
|
||||
protocol_request.type = Protocol::CheckedMessage
|
||||
protocol_request.signature = expects
|
||||
protocol_request.return_signature = signature[:returns]
|
||||
else
|
||||
protocol_request.type = Protocol::UncheckedMessage
|
||||
system_methods = self.class.read_inheritable_attribute('default_system_methods') || {}
|
||||
protocol = protocol_request.protocol
|
||||
block = system_methods[protocol.class]
|
||||
unless block
|
||||
method_name = api.default_api_method
|
||||
unless method_name && respond_to?(method_name)
|
||||
raise(ContainerError, "no such method ##{public_method_name}")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@method_params = protocol_request.unmarshal
|
||||
@params ||= {}
|
||||
if expects
|
||||
(1..@method_params.size).each do |i|
|
||||
i -= 1
|
||||
if expects[i].is_a?(Hash)
|
||||
@params[expects[i].keys.shift.to_s] = @method_params[i]
|
||||
else
|
||||
@params["param#{i}"] = @method_params[i]
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
if respond_to?(:before_action)
|
||||
@params['action'] = method_name.to_s
|
||||
return protocol_request.marshal(nil) if before_action == false
|
||||
end
|
||||
|
||||
perform_invoke = lambda do
|
||||
if block
|
||||
block.call(public_method_name, self.class, *@method_params)
|
||||
else
|
||||
send(method_name)
|
||||
end
|
||||
end
|
||||
try_default = true
|
||||
result = nil
|
||||
catch(:try_default) do
|
||||
result = perform_invoke.call
|
||||
try_default = false
|
||||
end
|
||||
if try_default
|
||||
method_name = api.default_api_method
|
||||
if method_name
|
||||
protocol_request.type = Protocol::UncheckedMessage
|
||||
else
|
||||
raise(ContainerError, "no such method ##{public_method_name}")
|
||||
end
|
||||
result = perform_invoke.call
|
||||
end
|
||||
after_action if respond_to?(:after_action)
|
||||
protocol_request.marshal(result)
|
||||
end
|
||||
|
||||
def dispatch_delegated_service_request(protocol_request)
|
||||
service_name = protocol_request.service_name
|
||||
service = service_object(service_name)
|
||||
api = service.class.service_api
|
||||
public_method_name = protocol_request.public_method_name
|
||||
method_name = api.api_method_name(public_method_name)
|
||||
|
||||
invocation = ActionService::Invocation::InvocationRequest.new(
|
||||
ActionService::Invocation::ConcreteInvocation,
|
||||
public_method_name,
|
||||
method_name)
|
||||
|
||||
if method_name
|
||||
protocol_request.type = Protocol::CheckedMessage
|
||||
signature = api.api_methods[method_name]
|
||||
protocol_request.signature = signature[:expects]
|
||||
protocol_request.return_signature = signature[:returns]
|
||||
invocation.params = protocol_request.unmarshal
|
||||
else
|
||||
protocol_request.type = Protocol::UncheckedMessage
|
||||
invocation.type = ActionService::Invocation::VirtualInvocation
|
||||
system_methods = self.class.read_inheritable_attribute('default_system_methods') || {}
|
||||
protocol = protocol_request.protocol
|
||||
block = system_methods[protocol.class]
|
||||
if block
|
||||
invocation.block = block
|
||||
invocation.block_params << service.class
|
||||
else
|
||||
method_name = api.default_api_method
|
||||
if method_name && service.respond_to?(method_name)
|
||||
invocation.params = protocol_request.unmarshal
|
||||
invocation.method_name = method_name.to_sym
|
||||
else
|
||||
raise(ContainerError, "no such method /#{service_name}##{public_method_name}")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
canceled_reason = nil
|
||||
canceled_block = lambda{|r| canceled_reason = r}
|
||||
perform_invoke = lambda do
|
||||
service.perform_invocation(invocation, &canceled_block)
|
||||
end
|
||||
try_default = true
|
||||
result = nil
|
||||
catch(:try_default) do
|
||||
result = perform_invoke.call
|
||||
try_default = false
|
||||
end
|
||||
if try_default
|
||||
method_name = api.default_api_method
|
||||
if method_name
|
||||
protocol_request.type = Protocol::UncheckedMessage
|
||||
invocation.params = protocol_request.unmarshal
|
||||
invocation.method_name = method_name.to_sym
|
||||
invocation.type = ActionService::Invocation::UnpublishedConcreteInvocation
|
||||
else
|
||||
raise(ContainerError, "no such method /#{service_name}##{public_method_name}")
|
||||
end
|
||||
result = perform_invoke.call
|
||||
end
|
||||
protocol_request.marshal(result)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,252 @@
|
|||
module ActionService # :nodoc:
|
||||
module Invocation # :nodoc:
|
||||
ConcreteInvocation = :concrete
|
||||
VirtualInvocation = :virtual
|
||||
UnpublishedConcreteInvocation = :unpublished_concrete
|
||||
|
||||
class InvocationError < ActionService::ActionServiceError # :nodoc:
|
||||
end
|
||||
|
||||
def self.append_features(base) # :nodoc:
|
||||
super
|
||||
base.extend(ClassMethods)
|
||||
base.send(:include, ActionService::Invocation::InstanceMethods)
|
||||
end
|
||||
|
||||
# Invocation interceptors provide a means to execute custom code before
|
||||
# and after method invocations on ActionService::Base objects.
|
||||
#
|
||||
# When running in _Direct_ dispatching mode, ActionController filters
|
||||
# should be used for this functionality.
|
||||
#
|
||||
# The semantics of invocation interceptors are the same as ActionController
|
||||
# filters, and accept the same parameters and options.
|
||||
#
|
||||
# A _before_ interceptor can also cancel execution by returning +false+,
|
||||
# or returning a <tt>[false, "cancel reason"]</tt> array if it wishes to supply
|
||||
# a reason for canceling the request.
|
||||
#
|
||||
# === Example
|
||||
#
|
||||
# class CustomService < ActionService::Base
|
||||
# before_invocation :intercept_add, :only => [:add]
|
||||
#
|
||||
# def add(a, b)
|
||||
# a + b
|
||||
# end
|
||||
#
|
||||
# private
|
||||
# def intercept_add
|
||||
# return [false, "permission denied"] # cancel it
|
||||
# end
|
||||
# end
|
||||
#
|
||||
# Options:
|
||||
# [<tt>:except</tt>] A list of methods for which the interceptor will NOT be called
|
||||
# [<tt>:only</tt>] A list of methods for which the interceptor WILL be called
|
||||
module ClassMethods
|
||||
# Appends the given +interceptors+ to be called
|
||||
# _before_ method invocation.
|
||||
def append_before_invocation(*interceptors, &block)
|
||||
conditions = extract_conditions!(interceptors)
|
||||
interceptors << block if block_given?
|
||||
add_interception_conditions(interceptors, conditions)
|
||||
append_interceptors_to_chain("before", interceptors)
|
||||
end
|
||||
|
||||
# Prepends the given +interceptors+ to be called
|
||||
# _before_ method invocation.
|
||||
def prepend_before_invocation(*interceptors, &block)
|
||||
conditions = extract_conditions!(interceptors)
|
||||
interceptors << block if block_given?
|
||||
add_interception_conditions(interceptors, conditions)
|
||||
prepend_interceptors_to_chain("before", interceptors)
|
||||
end
|
||||
|
||||
alias :before_invocation :append_before_invocation
|
||||
|
||||
# Appends the given +interceptors+ to be called
|
||||
# _after_ method invocation.
|
||||
def append_after_invocation(*interceptors, &block)
|
||||
conditions = extract_conditions!(interceptors)
|
||||
interceptors << block if block_given?
|
||||
add_interception_conditions(interceptors, conditions)
|
||||
append_interceptors_to_chain("after", interceptors)
|
||||
end
|
||||
|
||||
# Prepends the given +interceptors+ to be called
|
||||
# _after_ method invocation.
|
||||
def prepend_after_invocation(*interceptors, &block)
|
||||
conditions = extract_conditions!(interceptors)
|
||||
interceptors << block if block_given?
|
||||
add_interception_conditions(interceptors, conditions)
|
||||
prepend_interceptors_to_chain("after", interceptors)
|
||||
end
|
||||
|
||||
alias :after_invocation :append_after_invocation
|
||||
|
||||
def before_invocation_interceptors # :nodoc:
|
||||
read_inheritable_attribute("before_invocation_interceptors")
|
||||
end
|
||||
|
||||
def after_invocation_interceptors # :nodoc:
|
||||
read_inheritable_attribute("after_invocation_interceptors")
|
||||
end
|
||||
|
||||
def included_intercepted_methods # :nodoc:
|
||||
read_inheritable_attribute("included_intercepted_methods") || {}
|
||||
end
|
||||
|
||||
def excluded_intercepted_methods # :nodoc:
|
||||
read_inheritable_attribute("excluded_intercepted_methods") || {}
|
||||
end
|
||||
|
||||
private
|
||||
def append_interceptors_to_chain(condition, interceptors)
|
||||
write_inheritable_array("#{condition}_invocation_interceptors", interceptors)
|
||||
end
|
||||
|
||||
def prepend_interceptors_to_chain(condition, interceptors)
|
||||
interceptors = interceptors + read_inheritable_attribute("#{condition}_invocation_interceptors")
|
||||
write_inheritable_attribute("#{condition}_invocation_interceptors", interceptors)
|
||||
end
|
||||
|
||||
def extract_conditions!(interceptors)
|
||||
return nil unless interceptors.last.is_a? Hash
|
||||
interceptors.pop
|
||||
end
|
||||
|
||||
def add_interception_conditions(interceptors, conditions)
|
||||
return unless conditions
|
||||
included, excluded = conditions[:only], conditions[:except]
|
||||
write_inheritable_hash("included_intercepted_methods", condition_hash(interceptors, included)) && return if included
|
||||
write_inheritable_hash("excluded_intercepted_methods", condition_hash(interceptors, excluded)) if excluded
|
||||
end
|
||||
|
||||
def condition_hash(interceptors, *methods)
|
||||
interceptors.inject({}) {|hash, interceptor| hash.merge(interceptor => methods.flatten.map {|method| method.to_s})}
|
||||
end
|
||||
end
|
||||
|
||||
module InstanceMethods # :nodoc:
|
||||
def self.append_features(base)
|
||||
super
|
||||
base.class_eval do
|
||||
alias_method :perform_invocation_without_interception, :perform_invocation
|
||||
alias_method :perform_invocation, :perform_invocation_with_interception
|
||||
end
|
||||
end
|
||||
|
||||
def perform_invocation_with_interception(invocation, &block)
|
||||
return if before_invocation(invocation.method_name, invocation.params, &block) == false
|
||||
result = perform_invocation_without_interception(invocation)
|
||||
after_invocation(invocation.method_name, invocation.params, result)
|
||||
result
|
||||
end
|
||||
|
||||
def perform_invocation(invocation)
|
||||
if invocation.concrete?
|
||||
unless self.respond_to?(invocation.method_name) && \
|
||||
self.class.service_api.has_api_method?(invocation.method_name)
|
||||
raise InvocationError, "no such service method '#{invocation.method_name}'"
|
||||
end
|
||||
end
|
||||
params = invocation.params
|
||||
if invocation.concrete? || invocation.unpublished_concrete?
|
||||
self.send(invocation.method_name, *params)
|
||||
else
|
||||
if invocation.block
|
||||
params = invocation.block_params + params
|
||||
invocation.block.call(invocation.public_method_name, *params)
|
||||
else
|
||||
self.send(invocation.method_name, *params)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def before_invocation(name, args, &block)
|
||||
call_interceptors(self.class.before_invocation_interceptors, [name, args], &block)
|
||||
end
|
||||
|
||||
def after_invocation(name, args, result)
|
||||
call_interceptors(self.class.after_invocation_interceptors, [name, args, result])
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def call_interceptors(interceptors, interceptor_args, &block)
|
||||
if interceptors and not interceptors.empty?
|
||||
interceptors.each do |interceptor|
|
||||
next if method_exempted?(interceptor, interceptor_args[0].to_s)
|
||||
result = case
|
||||
when interceptor.is_a?(Symbol)
|
||||
self.send(interceptor, *interceptor_args)
|
||||
when interceptor_block?(interceptor)
|
||||
interceptor.call(self, *interceptor_args)
|
||||
when interceptor_class?(interceptor)
|
||||
interceptor.intercept(self, *interceptor_args)
|
||||
else
|
||||
raise(
|
||||
InvocationError,
|
||||
"Interceptors need to be either a symbol, proc/method, or a class implementing a static intercept method"
|
||||
)
|
||||
end
|
||||
reason = nil
|
||||
if result.is_a?(Array)
|
||||
reason = result[1] if result[1]
|
||||
result = result[0]
|
||||
end
|
||||
if result == false
|
||||
block.call(reason) if block && reason
|
||||
return false
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def interceptor_block?(interceptor)
|
||||
interceptor.respond_to?("call") && (interceptor.arity == 3 || interceptor.arity == -1)
|
||||
end
|
||||
|
||||
def interceptor_class?(interceptor)
|
||||
interceptor.respond_to?("intercept")
|
||||
end
|
||||
|
||||
def method_exempted?(interceptor, method_name)
|
||||
case
|
||||
when self.class.included_intercepted_methods[interceptor]
|
||||
!self.class.included_intercepted_methods[interceptor].include?(method_name)
|
||||
when self.class.excluded_intercepted_methods[interceptor]
|
||||
self.class.excluded_intercepted_methods[interceptor].include?(method_name)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class InvocationRequest # :nodoc:
|
||||
attr_accessor :type
|
||||
attr :public_method_name
|
||||
attr_accessor :method_name
|
||||
attr_accessor :params
|
||||
attr_accessor :block
|
||||
attr :block_params
|
||||
|
||||
def initialize(type, public_method_name, method_name, params=nil)
|
||||
@type = type
|
||||
@public_method_name = public_method_name
|
||||
@method_name = method_name
|
||||
@params = params || []
|
||||
@block = nil
|
||||
@block_params = []
|
||||
end
|
||||
|
||||
def concrete?
|
||||
@type == ConcreteInvocation ? true : false
|
||||
end
|
||||
|
||||
def unpublished_concrete?
|
||||
@type == UnpublishedConcreteInvocation ? true : false
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
require 'action_service/protocol/abstract'
|
||||
require 'action_service/protocol/registry'
|
||||
require 'action_service/protocol/soap'
|
||||
require 'action_service/protocol/xmlrpc'
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
module ActionService # :nodoc:
|
||||
module Protocol # :nodoc:
|
||||
CheckedMessage = :checked
|
||||
UncheckedMessage = :unchecked
|
||||
|
||||
class ProtocolError < ActionService::ActionServiceError # :nodoc:
|
||||
end
|
||||
|
||||
class AbstractProtocol # :nodoc:
|
||||
attr :container_class
|
||||
|
||||
def initialize(container_class)
|
||||
@container_class = container_class
|
||||
end
|
||||
|
||||
def unmarshal_request(protocol_request)
|
||||
raise NotImplementedError
|
||||
end
|
||||
|
||||
def marshal_response(protocol_request, return_value)
|
||||
raise NotImplementedError
|
||||
end
|
||||
|
||||
def marshal_exception(exception)
|
||||
raise NotImplementedError
|
||||
end
|
||||
|
||||
def self.create_protocol_request(container_class, action_pack_request)
|
||||
nil
|
||||
end
|
||||
|
||||
def self.create_protocol_client(api, protocol_name, endpoint_uri, options)
|
||||
nil
|
||||
end
|
||||
end
|
||||
|
||||
class AbstractProtocolMessage # :nodoc:
|
||||
attr_accessor :signature
|
||||
attr_accessor :return_signature
|
||||
attr_accessor :type
|
||||
attr :options
|
||||
|
||||
def initialize(options={})
|
||||
@signature = @return_signature = nil
|
||||
@options = options
|
||||
@type = @options[:type] || CheckedMessage
|
||||
end
|
||||
|
||||
def signature=(value)
|
||||
return if value.nil?
|
||||
@signature = []
|
||||
value.each do |klass|
|
||||
if klass.is_a?(Hash)
|
||||
@signature << klass.values.shift
|
||||
else
|
||||
@signature << klass
|
||||
end
|
||||
end
|
||||
@signature
|
||||
end
|
||||
|
||||
def checked?
|
||||
@type == CheckedMessage
|
||||
end
|
||||
|
||||
def check_parameter_types(values, signature)
|
||||
return unless checked? && signature
|
||||
unless signature.length == values.length
|
||||
raise(ProtocolError, "Signature and parameter lengths mismatch")
|
||||
end
|
||||
(1..signature.length).each do |i|
|
||||
check_compatibility(signature[i-1], values[i-1].class)
|
||||
end
|
||||
end
|
||||
|
||||
def check_compatibility(expected_class, received_class)
|
||||
return if \
|
||||
(expected_class == TrueClass or expected_class == FalseClass) and \
|
||||
(received_class == TrueClass or received_class == FalseClass)
|
||||
unless received_class.ancestors.include?(expected_class) or \
|
||||
expected_class.ancestors.include?(received_class)
|
||||
raise(ProtocolError, "value of type #{received_class.name} is not " +
|
||||
"compatible with expected type #{expected_class.name}")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class ProtocolRequest < AbstractProtocolMessage # :nodoc:
|
||||
attr :protocol
|
||||
attr :raw_body
|
||||
|
||||
attr_accessor :service_name
|
||||
attr_accessor :public_method_name
|
||||
attr_accessor :content_type
|
||||
|
||||
def initialize(protocol, raw_body, service_name, public_method_name, content_type, options={})
|
||||
super(options)
|
||||
@protocol = protocol
|
||||
@raw_body = raw_body
|
||||
@service_name = service_name
|
||||
@public_method_name = public_method_name
|
||||
@content_type = content_type
|
||||
end
|
||||
|
||||
def unmarshal
|
||||
@protocol.unmarshal_request(self)
|
||||
end
|
||||
|
||||
def marshal(return_value)
|
||||
@protocol.marshal_response(self, return_value)
|
||||
end
|
||||
end
|
||||
|
||||
class ProtocolResponse < AbstractProtocolMessage # :nodoc:
|
||||
attr :protocol
|
||||
attr :raw_body
|
||||
|
||||
attr_accessor :content_type
|
||||
|
||||
def initialize(protocol, raw_body, content_type, options={})
|
||||
super(options)
|
||||
@protocol = protocol
|
||||
@raw_body = raw_body
|
||||
@content_type = content_type
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
module ActionService # :nodoc:
|
||||
module Protocol # :nodoc:
|
||||
HeaderAndBody = :header_and_body
|
||||
BodyOnly = :body_only
|
||||
|
||||
module Registry # :nodoc:
|
||||
def self.append_features(base) # :nodoc:
|
||||
super
|
||||
base.extend(ClassMethods)
|
||||
base.send(:include, ActionService::Protocol::Registry::InstanceMethods)
|
||||
end
|
||||
|
||||
module ClassMethods # :nodoc:
|
||||
def register_protocol(type, klass) # :nodoc:
|
||||
case type
|
||||
when HeaderAndBody
|
||||
write_inheritable_array("header_and_body_protocols", [klass])
|
||||
when BodyOnly
|
||||
write_inheritable_array("body_only_protocols", [klass])
|
||||
else
|
||||
raise(ProtocolError, "unknown protocol type #{type}")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
module InstanceMethods # :nodoc:
|
||||
private
|
||||
def probe_request_protocol(action_pack_request)
|
||||
(header_and_body_protocols + body_only_protocols).each do |protocol|
|
||||
protocol_request = protocol.create_protocol_request(self.class, action_pack_request)
|
||||
return protocol_request if protocol_request
|
||||
end
|
||||
raise(ProtocolError, "unsupported request message format")
|
||||
end
|
||||
|
||||
def probe_protocol_client(api, protocol_name, endpoint_uri, options)
|
||||
(header_and_body_protocols + body_only_protocols).each do |protocol|
|
||||
protocol_client = protocol.create_protocol_client(api, protocol_name, endpoint_uri, options)
|
||||
return protocol_client if protocol_client
|
||||
end
|
||||
raise(ProtocolError, "unsupported client protocol :#{protocol_name}")
|
||||
end
|
||||
|
||||
def header_and_body_protocols
|
||||
self.class.read_inheritable_attribute("header_and_body_protocols") || []
|
||||
end
|
||||
|
||||
def body_only_protocols
|
||||
self.class.read_inheritable_attribute("body_only_protocols") || []
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,484 @@
|
|||
require 'soap/processor'
|
||||
require 'soap/mapping'
|
||||
require 'soap/rpc/element'
|
||||
require 'xsd/datatypes'
|
||||
require 'xsd/ns'
|
||||
require 'singleton'
|
||||
|
||||
module ActionService # :nodoc:
|
||||
module Protocol # :nodoc:
|
||||
module Soap # :nodoc:
|
||||
class ProtocolError < ActionService::ActionServiceError # :nodoc:
|
||||
end
|
||||
|
||||
def self.append_features(base) # :nodoc:
|
||||
super
|
||||
base.register_protocol(HeaderAndBody, SoapProtocol)
|
||||
base.extend(ClassMethods)
|
||||
base.wsdl_service_name('ActionService')
|
||||
end
|
||||
|
||||
module ClassMethods
|
||||
# Specifies the WSDL service name to use when generating WSDL. Highly
|
||||
# recommended that you set this value, or code generators may generate
|
||||
# classes with very generic names.
|
||||
#
|
||||
# === Example
|
||||
# class MyController < ActionController::Base
|
||||
# wsdl_service_name 'MyService'
|
||||
# end
|
||||
def wsdl_service_name(name)
|
||||
write_inheritable_attribute("soap_mapper", SoapMapper.new("urn:#{name}"))
|
||||
end
|
||||
|
||||
def soap_mapper # :nodoc:
|
||||
read_inheritable_attribute("soap_mapper")
|
||||
end
|
||||
end
|
||||
|
||||
class SoapProtocol < AbstractProtocol # :nodoc:
|
||||
attr :mapper
|
||||
|
||||
def initialize(mapper)
|
||||
@mapper = mapper
|
||||
end
|
||||
|
||||
def self.create_protocol_request(container_class, action_pack_request)
|
||||
soap_action = extract_soap_action(action_pack_request)
|
||||
return nil unless soap_action
|
||||
service_name = action_pack_request.parameters['action']
|
||||
public_method_name = soap_action.gsub(/^[\/]+/, '').split(/[\/]+/)[-1]
|
||||
content_type = action_pack_request.env['HTTP_CONTENT_TYPE']
|
||||
content_type ||= 'text/xml'
|
||||
protocol = SoapProtocol.new(container_class.soap_mapper)
|
||||
ProtocolRequest.new(protocol,
|
||||
action_pack_request.raw_post,
|
||||
service_name.to_sym,
|
||||
public_method_name,
|
||||
content_type)
|
||||
end
|
||||
|
||||
def self.create_protocol_client(api, protocol_name, endpoint_uri, options)
|
||||
return nil unless protocol_name.to_s.downcase.to_sym == :soap
|
||||
ActionService::Client::Soap.new(api, endpoint_uri, options)
|
||||
end
|
||||
|
||||
def unmarshal_request(protocol_request)
|
||||
unmarshal = lambda do
|
||||
envelope = SOAP::Processor.unmarshal(protocol_request.raw_body)
|
||||
request = envelope.body.request
|
||||
values = request.collect{|k, v| request[k]}
|
||||
soap_to_ruby_array(values)
|
||||
end
|
||||
signature = protocol_request.signature
|
||||
if signature
|
||||
map_signature_types(signature)
|
||||
values = unmarshal.call
|
||||
signature = signature.map{|x|mapper.lookup(x).ruby_klass}
|
||||
protocol_request.check_parameter_types(values, signature)
|
||||
values
|
||||
else
|
||||
if protocol_request.checked?
|
||||
[]
|
||||
else
|
||||
unmarshal.call
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def marshal_response(protocol_request, return_value)
|
||||
marshal = lambda do |signature|
|
||||
mapping = mapper.lookup(signature[0])
|
||||
return_value = fixup_array_types(mapping, return_value)
|
||||
signature = signature.map{|x|mapper.lookup(x).ruby_klass}
|
||||
protocol_request.check_parameter_types([return_value], signature)
|
||||
param_def = [['retval', 'return', mapping.registry_mapping]]
|
||||
[param_def, ruby_to_soap(return_value)]
|
||||
end
|
||||
signature = protocol_request.return_signature
|
||||
param_def = nil
|
||||
if signature
|
||||
param_def, return_value = marshal.call(signature)
|
||||
else
|
||||
if protocol_request.checked?
|
||||
param_def, return_value = nil, nil
|
||||
else
|
||||
param_def, return_value = marshal.call([return_value.class])
|
||||
end
|
||||
end
|
||||
qname = XSD::QName.new(mapper.custom_namespace,
|
||||
protocol_request.public_method_name)
|
||||
response = SOAP::RPC::SOAPMethodResponse.new(qname, param_def)
|
||||
response.retval = return_value unless return_value.nil?
|
||||
ProtocolResponse.new(self, create_response(response), 'text/xml')
|
||||
end
|
||||
|
||||
def marshal_exception(exc)
|
||||
ProtocolResponse.new(self, create_exception_response(exc), 'text/xml')
|
||||
end
|
||||
|
||||
private
|
||||
def self.extract_soap_action(request)
|
||||
return nil unless request.method == :post
|
||||
content_type = request.env['HTTP_CONTENT_TYPE'] || 'text/xml'
|
||||
return nil unless content_type
|
||||
soap_action = request.env['HTTP_SOAPACTION']
|
||||
return nil unless soap_action
|
||||
soap_action.gsub!(/^"/, '')
|
||||
soap_action.gsub!(/"$/, '')
|
||||
soap_action.strip!
|
||||
return nil if soap_action.empty?
|
||||
soap_action
|
||||
end
|
||||
|
||||
def fixup_array_types(mapping, obj)
|
||||
mapping.each_attribute do |name, type, attr_mapping|
|
||||
if attr_mapping.custom_type?
|
||||
attr_obj = obj.send(name)
|
||||
new_obj = fixup_array_types(attr_mapping, attr_obj)
|
||||
obj.send("#{name}=", new_obj) unless new_obj.equal?(attr_obj)
|
||||
end
|
||||
end
|
||||
if mapping.is_a?(SoapArrayMapping)
|
||||
obj = mapping.ruby_klass.new(obj)
|
||||
# man, this is going to be slow for big arrays :(
|
||||
(1..obj.size).each do |i|
|
||||
i -= 1
|
||||
obj[i] = fixup_array_types(mapping.element_mapping, obj[i])
|
||||
end
|
||||
else
|
||||
if !mapping.generated_klass.nil? && mapping.generated_klass.respond_to?(:members)
|
||||
# have to map the publically visible structure of the class
|
||||
new_obj = mapping.generated_klass.new
|
||||
mapping.generated_klass.members.each do |name, klass|
|
||||
new_obj.send("#{name}=", obj.send(name))
|
||||
end
|
||||
obj = new_obj
|
||||
end
|
||||
end
|
||||
obj
|
||||
end
|
||||
|
||||
def map_signature_types(types)
|
||||
types.collect{|type| mapper.map(type)}
|
||||
end
|
||||
|
||||
def create_response(body)
|
||||
header = SOAP::SOAPHeader.new
|
||||
body = SOAP::SOAPBody.new(body)
|
||||
envelope = SOAP::SOAPEnvelope.new(header, body)
|
||||
SOAP::Processor.marshal(envelope)
|
||||
end
|
||||
|
||||
def create_exception_response(exc)
|
||||
detail = SOAP::Mapping::SOAPException.new(exc)
|
||||
body = SOAP::SOAPFault.new(
|
||||
SOAP::SOAPString.new('Server'),
|
||||
SOAP::SOAPString.new(exc.to_s),
|
||||
SOAP::SOAPString.new(self.class.name),
|
||||
SOAP::Mapping.obj2soap(detail))
|
||||
create_response(body)
|
||||
end
|
||||
|
||||
def ruby_to_soap(obj)
|
||||
SOAP::Mapping.obj2soap(obj, mapper.registry)
|
||||
end
|
||||
|
||||
def soap_to_ruby(obj)
|
||||
SOAP::Mapping.soap2obj(obj, mapper.registry)
|
||||
end
|
||||
|
||||
def soap_to_ruby_array(array)
|
||||
array.map{|x| soap_to_ruby(x)}
|
||||
end
|
||||
end
|
||||
|
||||
class SoapMapper # :nodoc:
|
||||
attr :registry
|
||||
attr :custom_namespace
|
||||
attr :custom_types
|
||||
|
||||
def initialize(custom_namespace)
|
||||
@custom_namespace = custom_namespace
|
||||
@registry = SOAP::Mapping::Registry.new
|
||||
@klass2map = {}
|
||||
@custom_types = {}
|
||||
@ar2klass = {}
|
||||
end
|
||||
|
||||
def lookup(klass)
|
||||
lookup_klass = klass.is_a?(Array) ? klass[0] : klass
|
||||
generated_klass = nil
|
||||
unless lookup_klass.respond_to?(:ancestors)
|
||||
raise(ProtocolError, "expected parameter type definition to be a Class")
|
||||
end
|
||||
if lookup_klass.ancestors.include?(ActiveRecord::Base)
|
||||
generated_klass = @ar2klass.has_key?(klass) ? @ar2klass[klass] : nil
|
||||
klass = generated_klass if generated_klass
|
||||
end
|
||||
return @klass2map[klass] if @klass2map.has_key?(klass)
|
||||
|
||||
custom_type = false
|
||||
|
||||
ruby_klass = select_class(lookup_klass)
|
||||
generated_klass = @ar2klass[lookup_klass] if @ar2klass.has_key?(lookup_klass)
|
||||
type_name = ruby_klass.name
|
||||
|
||||
# Array signatures generate a double-mapping and require generation
|
||||
# of an Array subclass to represent the mapping in the SOAP
|
||||
# registry
|
||||
array_klass = nil
|
||||
if klass.is_a?(Array)
|
||||
array_klass = Class.new(Array) do
|
||||
module_eval <<-END
|
||||
def self.name
|
||||
"#{type_name}Array"
|
||||
end
|
||||
END
|
||||
end
|
||||
end
|
||||
|
||||
mapping = @registry.find_mapped_soap_class(ruby_klass) rescue nil
|
||||
unless mapping
|
||||
# Custom structured type, generate a mapping
|
||||
info = { :type => XSD::QName.new(@custom_namespace, type_name) }
|
||||
@registry.add(ruby_klass,
|
||||
SOAP::SOAPStruct,
|
||||
SOAP::Mapping::Registry::TypedStructFactory,
|
||||
info)
|
||||
mapping = ensure_mapped(ruby_klass)
|
||||
custom_type = true
|
||||
end
|
||||
|
||||
array_mapping = nil
|
||||
if array_klass
|
||||
# Typed array always requires a custom type. The info of the array
|
||||
# is the info of its element type (in mapping[2]), falling back
|
||||
# to SOAP base types.
|
||||
info = mapping[2]
|
||||
info ||= {}
|
||||
info[:type] ||= soap_base_type_qname(mapping[0])
|
||||
@registry.add(array_klass,
|
||||
SOAP::SOAPArray,
|
||||
SOAP::Mapping::Registry::TypedArrayFactory,
|
||||
info)
|
||||
array_mapping = ensure_mapped(array_klass)
|
||||
end
|
||||
|
||||
if array_mapping
|
||||
@klass2map[ruby_klass] = SoapMapping.new(self,
|
||||
type_name,
|
||||
ruby_klass,
|
||||
generated_klass,
|
||||
mapping[0],
|
||||
mapping,
|
||||
custom_type)
|
||||
@klass2map[klass] = SoapArrayMapping.new(self,
|
||||
type_name,
|
||||
array_klass,
|
||||
array_mapping[0],
|
||||
array_mapping,
|
||||
@klass2map[ruby_klass])
|
||||
@custom_types[klass] = @klass2map[klass]
|
||||
@custom_types[ruby_klass] = @klass2map[ruby_klass] if custom_type
|
||||
else
|
||||
@klass2map[klass] = SoapMapping.new(self,
|
||||
type_name,
|
||||
ruby_klass,
|
||||
generated_klass,
|
||||
mapping[0],
|
||||
mapping,
|
||||
custom_type)
|
||||
@custom_types[klass] = @klass2map[klass] if custom_type
|
||||
end
|
||||
|
||||
@klass2map[klass]
|
||||
end
|
||||
alias :map :lookup
|
||||
|
||||
def map_container_services(container, &block)
|
||||
dispatching_mode = container.service_dispatching_mode
|
||||
services = nil
|
||||
case dispatching_mode
|
||||
when :direct
|
||||
api = container.class.service_api
|
||||
if container.respond_to?(:controller_class_name)
|
||||
service_name = container.controller_class_name.sub(/Controller$/, '').underscore
|
||||
else
|
||||
service_name = container.class.name.demodulize.underscore
|
||||
end
|
||||
services = { service_name => api }
|
||||
when :delegated
|
||||
services = {}
|
||||
container.class.services.each do |service_name, service_info|
|
||||
begin
|
||||
object = container.service_object(service_name)
|
||||
rescue Exception => e
|
||||
raise(ProtocolError, "failed to retrieve service object for mapping: #{e.message}")
|
||||
end
|
||||
services[service_name] = object.class.service_api
|
||||
end
|
||||
end
|
||||
services.each do |service_name, api|
|
||||
if api.nil?
|
||||
raise(ProtocolError, "no service API set while in :#{dispatching_mode} mode")
|
||||
end
|
||||
map_api(api) do |api_methods|
|
||||
yield service_name, api, api_methods if block_given?
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def map_api(api, &block)
|
||||
lookup_proc = lambda do |klass|
|
||||
mapping = lookup(klass)
|
||||
custom_mapping = nil
|
||||
if mapping.respond_to?(:element_mapping)
|
||||
custom_mapping = mapping.element_mapping
|
||||
else
|
||||
custom_mapping = mapping
|
||||
end
|
||||
if custom_mapping && custom_mapping.custom_type?
|
||||
# What gives? This is required so that structure types
|
||||
# referenced only by structures (and not signatures) still
|
||||
# have a custom type mapping in the registry (needed for WSDL
|
||||
# generation).
|
||||
custom_mapping.each_attribute{}
|
||||
end
|
||||
mapping
|
||||
end
|
||||
api_methods = block.nil?? nil : {}
|
||||
api.api_methods.each do |method_name, method_info|
|
||||
expects = method_info[:expects]
|
||||
expects_signature = nil
|
||||
if expects
|
||||
expects_signature = block ? [] : nil
|
||||
expects.each do |klass|
|
||||
lookup_klass = nil
|
||||
if klass.is_a?(Hash)
|
||||
lookup_klass = lookup_proc.call(klass.values[0])
|
||||
expects_signature << {klass.keys[0]=>lookup_klass} if block
|
||||
else
|
||||
lookup_klass = lookup_proc.call(klass)
|
||||
expects_signature << lookup_klass if block
|
||||
end
|
||||
end
|
||||
end
|
||||
returns = method_info[:returns]
|
||||
returns_signature = returns ? returns.map{|klass| lookup_proc.call(klass)} : nil
|
||||
if block
|
||||
api_methods[method_name] = {
|
||||
:expects => expects_signature,
|
||||
:returns => returns_signature
|
||||
}
|
||||
end
|
||||
end
|
||||
yield api_methods if block
|
||||
end
|
||||
|
||||
private
|
||||
def select_class(klass)
|
||||
return Integer if klass == Fixnum
|
||||
if klass.ancestors.include?(ActiveRecord::Base)
|
||||
new_klass = Class.new(ActionService::Struct)
|
||||
new_klass.class_eval <<-EOS
|
||||
def self.name
|
||||
"#{klass.name}"
|
||||
end
|
||||
EOS
|
||||
klass.columns.each do |column|
|
||||
next if column.klass.nil?
|
||||
new_klass.send(:member, column.name.to_sym, column.klass)
|
||||
end
|
||||
@ar2klass[klass] = new_klass
|
||||
return new_klass
|
||||
end
|
||||
klass
|
||||
end
|
||||
|
||||
def ensure_mapped(klass)
|
||||
mapping = @registry.find_mapped_soap_class(klass) rescue nil
|
||||
raise(ProtocolError, "failed to register #{klass.name}") unless mapping
|
||||
mapping
|
||||
end
|
||||
|
||||
def soap_base_type_qname(base_type)
|
||||
xsd_type = base_type.ancestors.find{|c| c.const_defined? 'Type'}
|
||||
xsd_type ? xsd_type.const_get('Type') : XSD::XSDAnySimpleType::Type
|
||||
end
|
||||
end
|
||||
|
||||
class SoapMapping # :nodoc:
|
||||
attr :ruby_klass
|
||||
attr :generated_klass
|
||||
attr :soap_klass
|
||||
attr :registry_mapping
|
||||
|
||||
def initialize(mapper, type_name, ruby_klass, generated_klass, soap_klass, registry_mapping,
|
||||
custom_type=false)
|
||||
@mapper = mapper
|
||||
@type_name = type_name
|
||||
@ruby_klass = ruby_klass
|
||||
@generated_klass = generated_klass
|
||||
@soap_klass = soap_klass
|
||||
@registry_mapping = registry_mapping
|
||||
@custom_type = custom_type
|
||||
end
|
||||
|
||||
def type_name
|
||||
@type_name
|
||||
end
|
||||
|
||||
def custom_type?
|
||||
@custom_type
|
||||
end
|
||||
|
||||
def qualified_type_name
|
||||
name = type_name
|
||||
if custom_type?
|
||||
"typens:#{name}"
|
||||
else
|
||||
xsd_type_for(@soap_klass)
|
||||
end
|
||||
end
|
||||
|
||||
def each_attribute(&block)
|
||||
if @ruby_klass.respond_to?(:members)
|
||||
@ruby_klass.members.each do |name, klass|
|
||||
name = name.to_s
|
||||
mapping = @mapper.lookup(klass)
|
||||
yield name, mapping.qualified_type_name, mapping
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def is_xsd_type?(klass)
|
||||
klass.ancestors.include?(XSD::NSDBase)
|
||||
end
|
||||
|
||||
def xsd_type_for(klass)
|
||||
ns = XSD::NS.new
|
||||
ns.assign(XSD::Namespace, SOAP::XSDNamespaceTag)
|
||||
xsd_klass = klass.ancestors.find{|c| c.const_defined?('Type')}
|
||||
return ns.name(XSD::AnyTypeName) unless xsd_klass
|
||||
ns.name(xsd_klass.const_get('Type'))
|
||||
end
|
||||
end
|
||||
|
||||
class SoapArrayMapping < SoapMapping # :nodoc:
|
||||
attr :element_mapping
|
||||
|
||||
def initialize(mapper, type_name, ruby_klass, soap_klass, registry_mapping, element_mapping)
|
||||
super(mapper, type_name, ruby_klass, nil, soap_klass, registry_mapping, true)
|
||||
@element_mapping = element_mapping
|
||||
end
|
||||
|
||||
def type_name
|
||||
super + "Array"
|
||||
end
|
||||
|
||||
def each_attribute(&block); end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,187 @@
|
|||
require 'xmlrpc/parser'
|
||||
require 'xmlrpc/create'
|
||||
require 'xmlrpc/config'
|
||||
require 'xmlrpc/utils'
|
||||
require 'singleton'
|
||||
|
||||
module XMLRPC # :nodoc:
|
||||
class XmlRpcHelper # :nodoc:
|
||||
include Singleton
|
||||
include ParserWriterChooseMixin
|
||||
|
||||
def parse_method_call(message)
|
||||
parser().parseMethodCall(message)
|
||||
end
|
||||
|
||||
def create_method_response(successful, return_value)
|
||||
create().methodResponse(successful, return_value)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
module ActionService # :nodoc:
|
||||
module Protocol # :nodoc:
|
||||
module XmlRpc # :nodoc:
|
||||
def self.append_features(base) # :nodoc:
|
||||
super
|
||||
base.register_protocol(BodyOnly, XmlRpcProtocol)
|
||||
end
|
||||
|
||||
class XmlRpcProtocol < AbstractProtocol # :nodoc:
|
||||
|
||||
public
|
||||
|
||||
def self.create_protocol_request(container_class, action_pack_request)
|
||||
helper = XMLRPC::XmlRpcHelper.instance
|
||||
service_name = action_pack_request.parameters['action']
|
||||
methodname, params = helper.parse_method_call(action_pack_request.raw_post)
|
||||
methodname.gsub!(/^[^\.]+\./, '') unless methodname =~ /^system\./ # XXX
|
||||
protocol = XmlRpcProtocol.new(container_class)
|
||||
content_type = action_pack_request.env['HTTP_CONTENT_TYPE']
|
||||
content_type ||= 'text/xml'
|
||||
request = ProtocolRequest.new(protocol,
|
||||
action_pack_request.raw_post,
|
||||
service_name.to_sym,
|
||||
methodname,
|
||||
content_type,
|
||||
:xmlrpc_values => params)
|
||||
request
|
||||
rescue
|
||||
nil
|
||||
end
|
||||
|
||||
def self.create_protocol_client(api, protocol_name, endpoint_uri, options)
|
||||
return nil unless protocol_name.to_s.downcase.to_sym == :xmlrpc
|
||||
ActionService::Client::XmlRpc.new(api, endpoint_uri, options)
|
||||
end
|
||||
|
||||
def initialize(container_class)
|
||||
super(container_class)
|
||||
container_class.write_inheritable_hash('default_system_methods', XmlRpcProtocol => method(:xmlrpc_default_system_handler))
|
||||
end
|
||||
|
||||
def unmarshal_request(protocol_request)
|
||||
values = protocol_request.options[:xmlrpc_values]
|
||||
signature = protocol_request.signature
|
||||
if signature
|
||||
values = self.class.transform_incoming_method_params(self.class.transform_array_types(signature), values)
|
||||
protocol_request.check_parameter_types(values, check_array_types(signature))
|
||||
values
|
||||
else
|
||||
protocol_request.checked? ? [] : values
|
||||
end
|
||||
end
|
||||
|
||||
def marshal_response(protocol_request, return_value)
|
||||
helper = XMLRPC::XmlRpcHelper.instance
|
||||
signature = protocol_request.return_signature
|
||||
if signature
|
||||
protocol_request.check_parameter_types([return_value], check_array_types(signature))
|
||||
return_value = self.class.transform_return_value(self.class.transform_array_types(signature), return_value)
|
||||
raw_response = helper.create_method_response(true, return_value)
|
||||
else
|
||||
# XML-RPC doesn't have the concept of a void method, nor does it
|
||||
# support a nil return value, so return true if we would have returned
|
||||
# nil
|
||||
if protocol_request.checked?
|
||||
raw_response = helper.create_method_response(true, true)
|
||||
else
|
||||
return_value = true if return_value.nil?
|
||||
raw_response = helper.create_method_response(true, return_value)
|
||||
end
|
||||
end
|
||||
ProtocolResponse.new(self, raw_response, 'text/xml')
|
||||
end
|
||||
|
||||
def marshal_exception(exception)
|
||||
helper = XMLRPC::XmlRpcHelper.instance
|
||||
exception = XMLRPC::FaultException.new(1, exception.message)
|
||||
raw_response = helper.create_method_response(false, exception)
|
||||
ProtocolResponse.new(self, raw_response, 'text/xml')
|
||||
end
|
||||
|
||||
class << self
|
||||
def transform_incoming_method_params(signature, params)
|
||||
(1..signature.size).each do |i|
|
||||
i -= 1
|
||||
params[i] = xmlrpc_to_ruby(params[i], signature[i])
|
||||
end
|
||||
params
|
||||
end
|
||||
|
||||
def transform_return_value(signature, return_value)
|
||||
ruby_to_xmlrpc(return_value, signature[0])
|
||||
end
|
||||
|
||||
def ruby_to_xmlrpc(param, param_class)
|
||||
if param_class.is_a?(XmlRpcArray)
|
||||
param.map{|p| ruby_to_xmlrpc(p, param_class.klass)}
|
||||
elsif param_class.ancestors.include?(ActiveRecord::Base)
|
||||
param.instance_variable_get('@attributes')
|
||||
elsif param_class.ancestors.include?(ActionService::Struct)
|
||||
struct = {}
|
||||
param_class.members.each do |name, klass|
|
||||
value = param.send(name)
|
||||
next if value.nil?
|
||||
struct[name.to_s] = value
|
||||
end
|
||||
struct
|
||||
else
|
||||
param
|
||||
end
|
||||
end
|
||||
|
||||
def xmlrpc_to_ruby(param, param_class)
|
||||
if param_class.is_a?(XmlRpcArray)
|
||||
param.map{|p| xmlrpc_to_ruby(p, param_class.klass)}
|
||||
elsif param_class.ancestors.include?(ActiveRecord::Base)
|
||||
raise(ProtocolError, "incoming ActiveRecord::Base types are not allowed")
|
||||
elsif param_class.ancestors.include?(ActionService::Struct)
|
||||
unless param.is_a?(Hash)
|
||||
raise(ProtocolError, "expected parameter to be a Hash")
|
||||
end
|
||||
new_param = param_class.new
|
||||
param_class.members.each do |name, klass|
|
||||
new_param.send('%s=' % name.to_s, param[name.to_s])
|
||||
end
|
||||
new_param
|
||||
else
|
||||
param
|
||||
end
|
||||
end
|
||||
|
||||
def transform_array_types(signature)
|
||||
signature.map{|x| x.is_a?(Array) ? XmlRpcArray.new(x[0]) : x}
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
def xmlrpc_default_system_handler(name, service_class, *args)
|
||||
case name
|
||||
when 'system.listMethods'
|
||||
methods = []
|
||||
api = service_class.service_api
|
||||
api.api_methods.each do |name, info|
|
||||
methods << api.public_api_method_name(name)
|
||||
end
|
||||
methods.sort
|
||||
else
|
||||
throw :try_default
|
||||
end
|
||||
end
|
||||
|
||||
def check_array_types(signature)
|
||||
signature.map{|x| x.is_a?(Array) ? Array : x}
|
||||
end
|
||||
|
||||
class XmlRpcArray
|
||||
attr :klass
|
||||
def initialize(klass)
|
||||
@klass = klass
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
require 'action_service/router/action_controller'
|
||||
require 'action_service/router/wsdl'
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
module ActionService # :nodoc:
|
||||
module Router # :nodoc:
|
||||
module ActionController # :nodoc:
|
||||
def self.append_features(base) # :nodoc:
|
||||
base.add_service_api_callback do |container_class, api|
|
||||
if container_class.service_dispatching_mode == :direct && !container_class.method_defined?(:api)
|
||||
container_class.class_eval <<-EOS
|
||||
def api
|
||||
process_action_service_request
|
||||
end
|
||||
EOS
|
||||
end
|
||||
end
|
||||
base.add_service_definition_callback do |klass, name, info|
|
||||
if klass.service_dispatching_mode == :delegated
|
||||
klass.class_eval <<-EOS
|
||||
def #{name}
|
||||
process_action_service_request
|
||||
end
|
||||
EOS
|
||||
end
|
||||
end
|
||||
base.send(:include, ActionService::Router::ActionController::InstanceMethods)
|
||||
end
|
||||
|
||||
module InstanceMethods # :nodoc:
|
||||
private
|
||||
def process_action_service_request
|
||||
protocol_request = nil
|
||||
begin
|
||||
begin
|
||||
protocol_request = probe_request_protocol(self.request)
|
||||
rescue Exception => e
|
||||
logger.error "Invalid request: #{e.message}"
|
||||
logger.error self.request.raw_post
|
||||
raise
|
||||
end
|
||||
if protocol_request
|
||||
log_request(protocol_request)
|
||||
protocol_response = dispatch_service_request(protocol_request)
|
||||
log_response(protocol_response)
|
||||
response_options = {
|
||||
:type => protocol_response.content_type,
|
||||
:disposition => 'inline'
|
||||
}
|
||||
send_data(protocol_response.raw_body, response_options)
|
||||
else
|
||||
logger.fatal "Invalid Action Service service or method requested"
|
||||
render_text 'Internal protocol error', "500 Invalid service/method"
|
||||
end
|
||||
rescue Exception => e
|
||||
log_error e unless logger.nil?
|
||||
exc_response = nil
|
||||
case service_dispatching_mode
|
||||
when :direct
|
||||
if self.class.service_exception_reporting
|
||||
exc_response = protocol_request.protocol.marshal_exception(e)
|
||||
end
|
||||
when :delegated
|
||||
service_object = service_object(protocol_request.service_name) rescue nil
|
||||
if service_object && service_object.class.service_exception_reporting
|
||||
exc_response = protocol_request.protocol.marshal_exception(e) rescue nil
|
||||
end
|
||||
end
|
||||
if exc_response
|
||||
response_options = {
|
||||
:type => exc_response.content_type,
|
||||
:disposition => 'inline'
|
||||
}
|
||||
log_response exc_response
|
||||
send_data(exc_response.raw_body, response_options)
|
||||
else
|
||||
render_text 'Internal protocol error', "500 #{e.message}"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def log_request(protocol_request)
|
||||
unless logger.nil?
|
||||
service_name = protocol_request.service_name
|
||||
method_name = protocol_request.public_method_name
|
||||
logger.info "\nProcessing Action Service Request: #{service_name}##{method_name}"
|
||||
logger.info "Raw Request Body:"
|
||||
logger.info protocol_request.raw_body
|
||||
end
|
||||
end
|
||||
|
||||
def log_response(protocol_response)
|
||||
unless logger.nil?
|
||||
logger.info "\nRaw Response Body:"
|
||||
logger.info protocol_response.raw_body
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,210 @@
|
|||
module ActionService # :nodoc:
|
||||
module Router # :nodoc:
|
||||
module Wsdl # :nodoc:
|
||||
def self.append_features(base) # :nodoc:
|
||||
base.class_eval do
|
||||
class << self
|
||||
alias_method :inherited_without_wsdl, :inherited
|
||||
end
|
||||
end
|
||||
base.extend(ClassMethods)
|
||||
end
|
||||
|
||||
module ClassMethods
|
||||
def inherited(child)
|
||||
inherited_without_wsdl(child)
|
||||
child.send(:include, ActionService::Router::Wsdl::InstanceMethods)
|
||||
end
|
||||
end
|
||||
|
||||
module InstanceMethods # :nodoc:
|
||||
XsdNs = 'http://www.w3.org/2001/XMLSchema'
|
||||
WsdlNs = 'http://schemas.xmlsoap.org/wsdl/'
|
||||
SoapNs = 'http://schemas.xmlsoap.org/wsdl/soap/'
|
||||
SoapEncodingNs = 'http://schemas.xmlsoap.org/soap/encoding/'
|
||||
SoapHttpTransport = 'http://schemas.xmlsoap.org/soap/http'
|
||||
|
||||
def wsdl
|
||||
case @request.method
|
||||
when :get
|
||||
begin
|
||||
host_name = @request.env['HTTP_HOST']||@request.env['SERVER_NAME']
|
||||
uri = "http://#{host_name}/#{controller_name}/"
|
||||
soap_action_base = "/#{controller_name}"
|
||||
xml = to_wsdl(self, uri, soap_action_base)
|
||||
send_data(xml, :type => 'text/xml', :disposition => 'inline')
|
||||
rescue Exception => e
|
||||
log_error e unless logger.nil?
|
||||
render_text('', "500 #{e.message}")
|
||||
end
|
||||
when :post
|
||||
render_text('', "500 POST not supported")
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
def to_wsdl(container, uri, soap_action_base)
|
||||
wsdl = ""
|
||||
|
||||
service_dispatching_mode = container.service_dispatching_mode
|
||||
mapper = container.class.soap_mapper
|
||||
namespace = mapper.custom_namespace
|
||||
wsdl_service_name = namespace.split(/:/)[1]
|
||||
|
||||
services = {}
|
||||
mapper.map_container_services(container) do |name, api, api_methods|
|
||||
services[name] = [api, api_methods]
|
||||
end
|
||||
custom_types = mapper.custom_types
|
||||
|
||||
|
||||
xm = Builder::XmlMarkup.new(:target => wsdl, :indent => 2)
|
||||
xm.instruct!
|
||||
|
||||
xm.definitions('name' => wsdl_service_name,
|
||||
'targetNamespace' => namespace,
|
||||
'xmlns:typens' => namespace,
|
||||
'xmlns:xsd' => XsdNs,
|
||||
'xmlns:soap' => SoapNs,
|
||||
'xmlns:soapenc' => SoapEncodingNs,
|
||||
'xmlns:wsdl' => WsdlNs,
|
||||
'xmlns' => WsdlNs) do
|
||||
|
||||
# Custom type XSD generation
|
||||
if custom_types.size > 0
|
||||
xm.types do
|
||||
xm.xsd(:schema, 'xmlns' => XsdNs, 'targetNamespace' => namespace) do
|
||||
custom_types.each do |klass, mapping|
|
||||
case
|
||||
when mapping.is_a?(ActionService::Protocol::Soap::SoapArrayMapping)
|
||||
xm.xsd(:complexType, 'name' => mapping.type_name) do
|
||||
xm.xsd(:complexContent) do
|
||||
xm.xsd(:restriction, 'base' => 'soapenc:Array') do
|
||||
xm.xsd(:attribute, 'ref' => 'soapenc:arrayType',
|
||||
'wsdl:arrayType' => mapping.element_mapping.qualified_type_name + '[]')
|
||||
end
|
||||
end
|
||||
end
|
||||
when mapping.is_a?(ActionService::Protocol::Soap::SoapMapping)
|
||||
xm.xsd(:complexType, 'name' => mapping.type_name) do
|
||||
xm.xsd(:all) do
|
||||
mapping.each_attribute do |name, type_name|
|
||||
xm.xsd(:element, 'name' => name, 'type' => type_name)
|
||||
end
|
||||
end
|
||||
end
|
||||
else
|
||||
raise(WsdlError, "unsupported mapping type #{mapping.class.name}")
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
services.each do |service_name, service_values|
|
||||
service_api, api_methods = service_values
|
||||
# Parameter list message definitions
|
||||
api_methods.each do |method_name, method_signature|
|
||||
gen = lambda do |msg_name, direction|
|
||||
xm.message('name' => msg_name) do
|
||||
sym = nil
|
||||
if direction == :out
|
||||
if method_signature[:returns]
|
||||
xm.part('name' => 'return', 'type' => method_signature[:returns][0].qualified_type_name)
|
||||
end
|
||||
else
|
||||
mapping_list = method_signature[:expects]
|
||||
i = 1
|
||||
mapping_list.each do |mapping|
|
||||
if mapping.is_a?(Hash)
|
||||
param_name = mapping.keys.shift
|
||||
mapping = mapping.values.shift
|
||||
else
|
||||
param_name = "param#{i}"
|
||||
end
|
||||
xm.part('name' => param_name, 'type' => mapping.qualified_type_name)
|
||||
i += 1
|
||||
end if mapping_list
|
||||
end
|
||||
end
|
||||
end
|
||||
public_name = service_api.public_api_method_name(method_name)
|
||||
gen.call(public_name, :in)
|
||||
gen.call("#{public_name}Response", :out)
|
||||
end
|
||||
|
||||
# Declare the port
|
||||
port_name = port_name_for(wsdl_service_name, service_name)
|
||||
xm.portType('name' => port_name) do
|
||||
api_methods.each do |method_name, method_signature|
|
||||
public_name = service_api.public_api_method_name(method_name)
|
||||
xm.operation('name' => public_name) do
|
||||
xm.input('message' => "typens:#{public_name}")
|
||||
xm.output('message' => "typens:#{public_name}Response")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# Bind the port to SOAP
|
||||
binding_name = binding_name_for(wsdl_service_name, service_name)
|
||||
xm.binding('name' => binding_name, 'type' => "typens:#{port_name}") do
|
||||
xm.soap(:binding, 'style' => 'rpc', 'transport' => SoapHttpTransport)
|
||||
api_methods.each do |method_name, method_signature|
|
||||
public_name = service_api.public_api_method_name(method_name)
|
||||
xm.operation('name' => public_name) do
|
||||
case service_dispatching_mode
|
||||
when :direct
|
||||
soap_action = soap_action_base + "/api/" + public_name
|
||||
when :delegated
|
||||
soap_action = soap_action_base \
|
||||
+ "/" + service_name.to_s \
|
||||
+ "/" + public_name
|
||||
end
|
||||
xm.soap(:operation, 'soapAction' => soap_action)
|
||||
xm.input do
|
||||
xm.soap(:body,
|
||||
'use' => 'encoded',
|
||||
'namespace' => namespace,
|
||||
'encodingStyle' => SoapEncodingNs)
|
||||
end
|
||||
xm.output do
|
||||
xm.soap(:body,
|
||||
'use' => 'encoded',
|
||||
'namespace' => namespace,
|
||||
'encodingStyle' => SoapEncodingNs)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# Define the service
|
||||
xm.service('name' => "#{wsdl_service_name}Service") do
|
||||
services.each do |service_name, service_values|
|
||||
port_name = port_name_for(wsdl_service_name, service_name)
|
||||
binding_name = binding_name_for(wsdl_service_name, service_name)
|
||||
case service_dispatching_mode
|
||||
when :direct
|
||||
binding_target = 'api'
|
||||
when :delegated
|
||||
binding_target = service_name.to_s
|
||||
end
|
||||
xm.port('name' => port_name, 'binding' => "typens:#{binding_name}") do
|
||||
xm.soap(:address, 'location' => "#{uri}#{binding_target}")
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def port_name_for(wsdl_service_name, service_name)
|
||||
"#{wsdl_service_name}#{service_name.to_s.camelize}Port"
|
||||
end
|
||||
|
||||
def binding_name_for(wsdl_service_name, service_name)
|
||||
"#{wsdl_service_name}#{service_name.to_s.camelize}Binding"
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
module ActionService
|
||||
# To send structured types across the wire, derive from ActionService::Struct,
|
||||
# and use +member+ to declare structure members.
|
||||
#
|
||||
# ActionService::Struct should be used in method signatures when you want to accept or return
|
||||
# structured types that have no Active Record model class representations, or you don't
|
||||
# want to expose your entire Active Record model to remote callers.
|
||||
#
|
||||
# === Example
|
||||
#
|
||||
# class Person < ActionService::Struct
|
||||
# member :id, :int
|
||||
# member :firstnames, [:string]
|
||||
# member :lastname, :string
|
||||
# member :email, :string
|
||||
# end
|
||||
#
|
||||
# Active Record model classes are already implicitly supported for method
|
||||
# return signatures. A structure containing its columns as members will be
|
||||
# automatically generated if its present in a signature.
|
||||
#
|
||||
# The structure
|
||||
class Struct
|
||||
|
||||
# If a Hash is given as argument to an ActionService::Struct constructor,
|
||||
# containing as key the member name, and its associated initial value
|
||||
def initialize(values={})
|
||||
if values.is_a?(Hash)
|
||||
values.map{|k,v| send('%s=' % k.to_s, v)}
|
||||
end
|
||||
end
|
||||
|
||||
# The member with the given name
|
||||
def [](name)
|
||||
send(name.to_s)
|
||||
end
|
||||
|
||||
class << self
|
||||
include ActionService::Signature
|
||||
|
||||
# Creates a structure member accessible using +name+. Generates
|
||||
# accessor methods for reading and writing the member value.
|
||||
def member(name, type)
|
||||
write_inheritable_hash("struct_members", name => signature_parameter_class(type))
|
||||
class_eval <<-END
|
||||
def #{name}; @#{name}; end
|
||||
def #{name}=(value); @#{name} = value; end
|
||||
END
|
||||
end
|
||||
|
||||
def members # :nodoc:
|
||||
read_inheritable_attribute("struct_members") || {}
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
class Class # :nodoc:
|
||||
def class_inheritable_option(sym, default_value=nil)
|
||||
write_inheritable_attribute sym, default_value
|
||||
class_eval <<-EOS
|
||||
def self.#{sym}(value=nil)
|
||||
if !value.nil?
|
||||
write_inheritable_attribute(:#{sym}, value)
|
||||
else
|
||||
read_inheritable_attribute(:#{sym})
|
||||
end
|
||||
end
|
||||
|
||||
def self.#{sym}=(value)
|
||||
write_inheritable_attribute(:#{sym}, value)
|
||||
end
|
||||
|
||||
def #{sym}
|
||||
self.class.#{sym}
|
||||
end
|
||||
|
||||
def #{sym}=(value)
|
||||
self.class.#{sym} = value
|
||||
end
|
||||
EOS
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
module ActionService # :nodoc:
|
||||
# Action Service parameter type specifiers may contain symbols or strings
|
||||
# instead of Class objects, for a limited set of base types.
|
||||
#
|
||||
# This provides an unambiguous way to specify that a given parameter
|
||||
# contains an integer or boolean value, for example.
|
||||
#
|
||||
# The allowed set of symbol/string aliases:
|
||||
#
|
||||
# [<tt>:int</tt>] any integer value
|
||||
# [<tt>:float</tt>] any floating point value
|
||||
# [<tt>:string</tt>] any string value
|
||||
# [<tt>:bool</tt>] any boolean value
|
||||
# [<tt>:time</tt>] any value containing both date and time
|
||||
# [<tt>:date</tt>] any value containing only a date
|
||||
module Signature
|
||||
class SignatureError < StandardError # :nodoc:
|
||||
end
|
||||
|
||||
private
|
||||
def canonical_signature(params)
|
||||
return nil if params.nil?
|
||||
params.map do |param|
|
||||
klass = signature_parameter_class(param)
|
||||
if param.is_a?(Hash)
|
||||
param[param.keys[0]] = klass
|
||||
param
|
||||
else
|
||||
klass
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def signature_parameter_class(param)
|
||||
param = param.is_a?(Hash) ? param.values[0] : param
|
||||
is_array = param.is_a?(Array)
|
||||
param = is_array ? param[0] : param
|
||||
param = param.is_a?(String) ? param.to_sym : param
|
||||
param = param.is_a?(Symbol) ? signature_ruby_class(param) : param
|
||||
is_array ? [param] : param
|
||||
end
|
||||
|
||||
|
||||
def canonical_signature_base_type(base_type)
|
||||
base_type = base_type.to_sym
|
||||
case base_type
|
||||
when :int, :integer, :fixnum, :bignum
|
||||
:int
|
||||
when :string, :base64
|
||||
:string
|
||||
when :bool, :boolean
|
||||
:bool
|
||||
when :float, :double
|
||||
:float
|
||||
when :time, :datetime, :timestamp
|
||||
:time
|
||||
when :date
|
||||
:date
|
||||
else
|
||||
raise(SignatureError, ":#{base_type} is not an ActionService base type")
|
||||
end
|
||||
end
|
||||
|
||||
def signature_ruby_class(base_type)
|
||||
case canonical_signature_base_type(base_type)
|
||||
when :int
|
||||
Integer
|
||||
when :string
|
||||
String
|
||||
when :bool
|
||||
TrueClass
|
||||
when :float
|
||||
Float
|
||||
when :time
|
||||
Time
|
||||
when :date
|
||||
Date
|
||||
end
|
||||
end
|
||||
|
||||
def signature_base_type(ruby_class)
|
||||
case ruby_class
|
||||
when Bignum, Integer, Fixnum
|
||||
:int
|
||||
when String
|
||||
:string
|
||||
when TrueClass, FalseClass
|
||||
:bool
|
||||
when Float, Numeric, Precision
|
||||
:float
|
||||
when Time, DateTime
|
||||
:time
|
||||
when Date
|
||||
:date
|
||||
else
|
||||
raise(SignatureError, "#{ruby_class.name} is not an ActionService base type")
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,124 @@
|
|||
require File.dirname(__FILE__) + '/abstract_unit'
|
||||
require 'webrick'
|
||||
require 'webrick/log'
|
||||
require 'singleton'
|
||||
|
||||
module ClientTest
|
||||
class Person < ActionService::Struct
|
||||
member :firstnames, [:string]
|
||||
member :lastname, :string
|
||||
|
||||
def ==(other)
|
||||
firstnames == other.firstnames && lastname == other.lastname
|
||||
end
|
||||
end
|
||||
|
||||
class API < ActionService::API::Base
|
||||
api_method :void
|
||||
api_method :normal, :expects => [:int, :int], :returns => [:int]
|
||||
api_method :array_return, :returns => [[Person]]
|
||||
api_method :struct_pass, :expects => [[Person]], :returns => [:bool]
|
||||
api_method :client_container, :returns => [:int]
|
||||
end
|
||||
|
||||
class NullLogOut
|
||||
def <<(*args); end
|
||||
end
|
||||
|
||||
class Container < ActionController::Base
|
||||
service_api API
|
||||
|
||||
attr :value_void
|
||||
attr :value_normal
|
||||
attr :value_array_return
|
||||
attr :value_struct_pass
|
||||
|
||||
def initialize
|
||||
@session = @assigns = {}
|
||||
@value_void = nil
|
||||
@value_normal = nil
|
||||
@value_array_return = nil
|
||||
@value_struct_pass = nil
|
||||
end
|
||||
|
||||
def void
|
||||
@value_void = @method_params
|
||||
end
|
||||
|
||||
def normal
|
||||
@value_normal = @method_params
|
||||
5
|
||||
end
|
||||
|
||||
def array_return
|
||||
person = Person.new
|
||||
person.firstnames = ["one", "two"]
|
||||
person.lastname = "last"
|
||||
@value_array_return = [person]
|
||||
end
|
||||
|
||||
def struct_pass
|
||||
@value_struct_pass = @method_params
|
||||
true
|
||||
end
|
||||
|
||||
def client_container
|
||||
50
|
||||
end
|
||||
|
||||
def protocol_request(request)
|
||||
probe_request_protocol(request)
|
||||
end
|
||||
|
||||
def dispatch_request(protocol_request)
|
||||
dispatch_service_request(protocol_request)
|
||||
end
|
||||
end
|
||||
|
||||
class AbstractClientLet < WEBrick::HTTPServlet::AbstractServlet
|
||||
def initialize(controller)
|
||||
@controller = controller
|
||||
end
|
||||
|
||||
def get_instance(*args)
|
||||
self
|
||||
end
|
||||
|
||||
def require_path_info?
|
||||
false
|
||||
end
|
||||
|
||||
def do_GET(req, res)
|
||||
raise WEBrick::HTTPStatus::MethodNotAllowed, "GET request not allowed."
|
||||
end
|
||||
|
||||
def do_POST(req, res)
|
||||
raise NotImplementedError
|
||||
end
|
||||
end
|
||||
|
||||
class AbstractServer
|
||||
include ClientTest
|
||||
include Singleton
|
||||
attr :container
|
||||
def initialize
|
||||
@container = Container.new
|
||||
@clientlet = create_clientlet(@container)
|
||||
log = WEBrick::BasicLog.new(NullLogOut.new)
|
||||
@server = WEBrick::HTTPServer.new(:Port => server_port, :Logger => log, :AccessLog => log)
|
||||
@server.mount('/', @clientlet)
|
||||
@thr = Thread.new { @server.start }
|
||||
until @server.status == :Running; end
|
||||
at_exit { @server.stop; @thr.join }
|
||||
end
|
||||
|
||||
protected
|
||||
def create_clientlet
|
||||
raise NotImplementedError
|
||||
end
|
||||
|
||||
def server_port
|
||||
raise NotImplementedError
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
require File.dirname(__FILE__) + '/abstract_unit'
|
||||
require 'soap/rpc/element'
|
||||
|
||||
class SoapTestError < StandardError
|
||||
end
|
||||
|
||||
class AbstractSoapTest < Test::Unit::TestCase
|
||||
def default_test
|
||||
end
|
||||
|
||||
protected
|
||||
def service_name
|
||||
raise NotImplementedError
|
||||
end
|
||||
|
||||
def do_soap_call(public_method_name, *args)
|
||||
mapper = @container.class.soap_mapper
|
||||
param_def = []
|
||||
i = 1
|
||||
args.each do |arg|
|
||||
mapping = mapper.lookup(arg.class)
|
||||
param_def << ["in", "param#{i}", mapping.registry_mapping]
|
||||
i += 1
|
||||
end
|
||||
qname = XSD::QName.new('urn:ActionService', public_method_name)
|
||||
request = SOAP::RPC::SOAPMethodRequest.new(qname, param_def)
|
||||
soap_args = []
|
||||
i = 1
|
||||
args.each do |arg|
|
||||
soap_args << ["param#{i}", SOAP::Mapping.obj2soap(arg)]
|
||||
i += 1
|
||||
end
|
||||
request.set_param(soap_args)
|
||||
header = SOAP::SOAPHeader.new
|
||||
body = SOAP::SOAPBody.new(request)
|
||||
envelope = SOAP::SOAPEnvelope.new(header, body)
|
||||
raw_request = SOAP::Processor.marshal(envelope)
|
||||
test_request = ActionController::TestRequest.new
|
||||
test_request.request_parameters['action'] = service_name
|
||||
test_request.env['REQUEST_METHOD'] = "POST"
|
||||
test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
|
||||
test_request.env['HTTP_SOAPACTION'] = "/soap/#{service_name}/#{public_method_name}"
|
||||
test_request.env['RAW_POST_DATA'] = raw_request
|
||||
test_response = ActionController::TestResponse.new
|
||||
response = yield test_request, test_response
|
||||
raw_body = response.respond_to?(:body) ? response.body : response.raw_body
|
||||
envelope = SOAP::Processor.unmarshal(raw_body)
|
||||
if envelope
|
||||
if envelope.body.response
|
||||
SOAP::Mapping.soap2obj(envelope.body.response)
|
||||
else
|
||||
nil
|
||||
end
|
||||
else
|
||||
raise(SoapTestError, "empty/invalid body from server")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
$:.unshift(File.dirname(__FILE__) + '/../lib')
|
||||
|
||||
require 'test/unit'
|
||||
require 'action_service'
|
||||
require 'action_controller'
|
||||
require 'action_controller/test_process'
|
||||
|
||||
ActionController::Base.logger = nil
|
||||
ActionController::Base.ignore_missing_templates = true
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
require File.dirname(__FILE__) + '/abstract_unit'
|
||||
|
||||
module APITest
|
||||
class API < ActionService::API::Base
|
||||
api_method :void
|
||||
api_method :expects_and_returns, :expects_and_returns => [:string]
|
||||
api_method :expects, :expects => [:int, :bool]
|
||||
api_method :returns, :returns => [:int, [:string]]
|
||||
api_method :named_signature, :expects => [{:appkey=>:int}, {:publish=>:bool}]
|
||||
api_method :string_types, :expects => ['int', 'string', 'bool']
|
||||
api_method :class_types, :expects => [TrueClass, Bignum, String]
|
||||
end
|
||||
end
|
||||
|
||||
class TC_API < Test::Unit::TestCase
|
||||
API = APITest::API
|
||||
|
||||
def test_api_method_declaration
|
||||
%w(
|
||||
void
|
||||
expects_and_returns
|
||||
expects
|
||||
returns
|
||||
named_signature
|
||||
string_types
|
||||
class_types
|
||||
).each do |name|
|
||||
name = name.to_sym
|
||||
public_name = API.public_api_method_name(name)
|
||||
assert(API.has_api_method?(name))
|
||||
assert(API.has_public_api_method?(public_name))
|
||||
assert(API.api_method_name(public_name) == name)
|
||||
assert(API.api_methods.has_key?(name))
|
||||
end
|
||||
end
|
||||
|
||||
def test_signature_canonicalization
|
||||
assert_equal({:expects=>nil, :returns=>nil}, API.api_methods[:void])
|
||||
assert_equal({:expects=>[String], :returns=>[String]}, API.api_methods[:expects_and_returns])
|
||||
assert_equal({:expects=>[Integer, TrueClass], :returns=>nil}, API.api_methods[:expects])
|
||||
assert_equal({:expects=>nil, :returns=>[Integer, [String]]}, API.api_methods[:returns])
|
||||
assert_equal({:expects=>[{:appkey=>Integer}, {:publish=>TrueClass}], :returns=>nil}, API.api_methods[:named_signature])
|
||||
assert_equal({:expects=>[Integer, String, TrueClass], :returns=>nil}, API.api_methods[:string_types])
|
||||
assert_equal({:expects=>[TrueClass, Bignum, String], :returns=>nil}, API.api_methods[:class_types])
|
||||
end
|
||||
|
||||
def test_not_instantiable
|
||||
assert_raises(NoMethodError) do
|
||||
API.new
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
require File.dirname(__FILE__) + '/abstract_unit'
|
||||
|
||||
module BaseTest
|
||||
class API < ActionService::API::Base
|
||||
api_method :add, :expects => [:int, :int], :returns => [:int]
|
||||
api_method :void
|
||||
end
|
||||
|
||||
class PristineAPI < ActionService::API::Base
|
||||
inflect_names false
|
||||
|
||||
api_method :add
|
||||
api_method :under_score
|
||||
end
|
||||
|
||||
class Service < ActionService::Base
|
||||
service_api API
|
||||
|
||||
def add(a, b)
|
||||
end
|
||||
|
||||
def void
|
||||
end
|
||||
end
|
||||
|
||||
class PristineService < ActionService::Base
|
||||
service_api PristineAPI
|
||||
|
||||
def add
|
||||
end
|
||||
|
||||
def under_score
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class TC_Base < Test::Unit::TestCase
|
||||
def test_options
|
||||
assert(BaseTest::PristineService.service_api.inflect_names == false)
|
||||
assert(BaseTest::Service.service_api.inflect_names == true)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
require File.dirname(__FILE__) + '/abstract_client'
|
||||
|
||||
|
||||
module ClientSoapTest
|
||||
PORT = 8998
|
||||
|
||||
class SoapClientLet < ClientTest::AbstractClientLet
|
||||
def do_POST(req, res)
|
||||
test_request = ActionController::TestRequest.new
|
||||
test_request.request_parameters['action'] = req.path.gsub(/^\//, '').split(/\//)[1]
|
||||
test_request.env['REQUEST_METHOD'] = "POST"
|
||||
test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
|
||||
test_request.env['HTTP_SOAPACTION'] = req.header['soapaction'][0]
|
||||
test_request.env['RAW_POST_DATA'] = req.body
|
||||
protocol_request = @controller.protocol_request(test_request)
|
||||
response = @controller.dispatch_request(protocol_request)
|
||||
res.header['content-type'] = 'text/xml'
|
||||
res.body = response.raw_body
|
||||
rescue Exception => e
|
||||
$stderr.puts e.message
|
||||
$stderr.puts e.backtrace.join("\n")
|
||||
end
|
||||
end
|
||||
|
||||
class ClientContainer < ActionController::Base
|
||||
client_api :client, :soap, "http://localhost:#{PORT}/client/api", :api => ClientTest::API
|
||||
|
||||
def get_client
|
||||
client
|
||||
end
|
||||
end
|
||||
|
||||
class SoapServer < ClientTest::AbstractServer
|
||||
def create_clientlet(controller)
|
||||
SoapClientLet.new(controller)
|
||||
end
|
||||
|
||||
def server_port
|
||||
PORT
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class TC_ClientSoap < Test::Unit::TestCase
|
||||
include ClientTest
|
||||
include ClientSoapTest
|
||||
|
||||
def setup
|
||||
@server = SoapServer.instance
|
||||
@container = @server.container
|
||||
@client = ActionService::Client::Soap.new(API, "http://localhost:#{@server.server_port}/client/api")
|
||||
end
|
||||
|
||||
def test_void
|
||||
assert(@container.value_void.nil?)
|
||||
@client.void
|
||||
assert(!@container.value_void.nil?)
|
||||
end
|
||||
|
||||
def test_normal
|
||||
assert(@container.value_normal.nil?)
|
||||
assert_equal(5, @client.normal(5, 6))
|
||||
assert_equal([5, 6], @container.value_normal)
|
||||
end
|
||||
|
||||
def test_array_return
|
||||
assert(@container.value_array_return.nil?)
|
||||
new_person = Person.new
|
||||
new_person.firstnames = ["one", "two"]
|
||||
new_person.lastname = "last"
|
||||
assert_equal([new_person], @client.array_return)
|
||||
assert_equal([new_person], @container.value_array_return)
|
||||
end
|
||||
|
||||
def test_struct_pass
|
||||
assert(@container.value_struct_pass.nil?)
|
||||
new_person = Person.new
|
||||
new_person.firstnames = ["one", "two"]
|
||||
new_person.lastname = "last"
|
||||
assert_equal(true, @client.struct_pass([new_person]))
|
||||
assert_equal([[new_person]], @container.value_struct_pass)
|
||||
end
|
||||
|
||||
def test_client_container
|
||||
assert_equal(50, ClientContainer.new.get_client.client_container)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,86 @@
|
|||
require File.dirname(__FILE__) + '/abstract_client'
|
||||
|
||||
|
||||
module ClientXmlRpcTest
|
||||
PORT = 8999
|
||||
|
||||
class XmlRpcClientLet < ClientTest::AbstractClientLet
|
||||
def do_POST(req, res)
|
||||
test_request = ActionController::TestRequest.new
|
||||
test_request.request_parameters['action'] = req.path.gsub(/^\//, '').split(/\//)[1]
|
||||
test_request.env['REQUEST_METHOD'] = "POST"
|
||||
test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
|
||||
test_request.env['RAW_POST_DATA'] = req.body
|
||||
protocol_request = @controller.protocol_request(test_request)
|
||||
response = @controller.dispatch_request(protocol_request)
|
||||
res.header['content-type'] = 'text/xml'
|
||||
res.body = response.raw_body
|
||||
rescue Exception => e
|
||||
$stderr.puts e.message
|
||||
$stderr.puts e.backtrace.join("\n")
|
||||
end
|
||||
end
|
||||
|
||||
class ClientContainer < ActionController::Base
|
||||
client_api :client, :xmlrpc, "http://localhost:#{PORT}/client/api", :api => ClientTest::API
|
||||
|
||||
def get_client
|
||||
client
|
||||
end
|
||||
end
|
||||
|
||||
class XmlRpcServer < ClientTest::AbstractServer
|
||||
def create_clientlet(controller)
|
||||
XmlRpcClientLet.new(controller)
|
||||
end
|
||||
|
||||
def server_port
|
||||
PORT
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class TC_ClientXmlRpc < Test::Unit::TestCase
|
||||
include ClientTest
|
||||
include ClientXmlRpcTest
|
||||
|
||||
def setup
|
||||
@server = XmlRpcServer.instance
|
||||
@container = @server.container
|
||||
@client = ActionService::Client::XmlRpc.new(API, "http://localhost:#{@server.server_port}/client/api")
|
||||
end
|
||||
|
||||
def test_void
|
||||
assert(@container.value_void.nil?)
|
||||
@client.void
|
||||
assert(!@container.value_void.nil?)
|
||||
end
|
||||
|
||||
def test_normal
|
||||
assert(@container.value_normal.nil?)
|
||||
assert_equal(5, @client.normal(5, 6))
|
||||
assert_equal([5, 6], @container.value_normal)
|
||||
end
|
||||
|
||||
def test_array_return
|
||||
assert(@container.value_array_return.nil?)
|
||||
new_person = Person.new
|
||||
new_person.firstnames = ["one", "two"]
|
||||
new_person.lastname = "last"
|
||||
assert_equal([new_person], @client.array_return)
|
||||
assert_equal([new_person], @container.value_array_return)
|
||||
end
|
||||
|
||||
def test_struct_pass
|
||||
assert(@container.value_struct_pass.nil?)
|
||||
new_person = Person.new
|
||||
new_person.firstnames = ["one", "two"]
|
||||
new_person.lastname = "last"
|
||||
assert_equal(true, @client.struct_pass([new_person]))
|
||||
assert_equal([[new_person]], @container.value_struct_pass)
|
||||
end
|
||||
|
||||
def test_client_container
|
||||
assert_equal(50, ClientContainer.new.get_client.client_container)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
require File.dirname(__FILE__) + '/abstract_unit'
|
||||
|
||||
module ContainerTest
|
||||
|
||||
$immediate_service = Object.new
|
||||
$deferred_service = Object.new
|
||||
|
||||
class DelegateContainer < ActionController::Base
|
||||
service_dispatching_mode :delegated
|
||||
|
||||
attr :flag
|
||||
attr :previous_flag
|
||||
|
||||
def initialize
|
||||
@previous_flag = nil
|
||||
@flag = true
|
||||
end
|
||||
|
||||
service :immediate_service, $immediate_service
|
||||
service(:deferred_service) { @previous_flag = @flag; @flag = false; $deferred_service }
|
||||
end
|
||||
|
||||
class DirectContainer < ActionController::Base
|
||||
service_dispatching_mode :direct
|
||||
end
|
||||
end
|
||||
|
||||
class TC_Container < Test::Unit::TestCase
|
||||
def setup
|
||||
@delegate_container = ContainerTest::DelegateContainer.new
|
||||
@direct_container = ContainerTest::DirectContainer.new
|
||||
end
|
||||
|
||||
def test_registration
|
||||
assert(ContainerTest::DelegateContainer.has_service?(:immediate_service))
|
||||
assert(ContainerTest::DelegateContainer.has_service?(:deferred_service))
|
||||
assert(!ContainerTest::DelegateContainer.has_service?(:fake_service))
|
||||
end
|
||||
|
||||
def test_service_object
|
||||
assert(@delegate_container.flag == true)
|
||||
assert(@delegate_container.service_object(:immediate_service) == $immediate_service)
|
||||
assert(@delegate_container.previous_flag.nil?)
|
||||
assert(@delegate_container.flag == true)
|
||||
assert(@delegate_container.service_object(:deferred_service) == $deferred_service)
|
||||
assert(@delegate_container.previous_flag == true)
|
||||
assert(@delegate_container.flag == false)
|
||||
end
|
||||
|
||||
def test_direct_container
|
||||
assert(ContainerTest::DirectContainer.service_dispatching_mode == :direct)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,158 @@
|
|||
require File.dirname(__FILE__) + '/abstract_unit'
|
||||
|
||||
module InvocationTest
|
||||
class API < ActionService::API::Base
|
||||
api_method :add, :expects => [:int, :int], :returns => [:int]
|
||||
api_method :transmogrify, :expects_and_returns => [:string]
|
||||
api_method :fail_with_reason
|
||||
api_method :fail_generic
|
||||
api_method :no_before
|
||||
api_method :no_after
|
||||
api_method :only_one
|
||||
api_method :only_two
|
||||
end
|
||||
|
||||
class Service < ActionService::Base
|
||||
service_api API
|
||||
|
||||
before_invocation :intercept_before, :except => [:no_before]
|
||||
after_invocation :intercept_after, :except => [:no_after]
|
||||
before_invocation :intercept_only, :only => [:only_one, :only_two]
|
||||
|
||||
attr_accessor :before_invoked
|
||||
attr_accessor :after_invoked
|
||||
attr_accessor :only_invoked
|
||||
attr_accessor :invocation_result
|
||||
|
||||
def initialize
|
||||
@before_invoked = nil
|
||||
@after_invoked = nil
|
||||
@only_invoked = nil
|
||||
@invocation_result = nil
|
||||
end
|
||||
|
||||
def add(a, b)
|
||||
a + b
|
||||
end
|
||||
|
||||
def transmogrify(str)
|
||||
str.upcase
|
||||
end
|
||||
|
||||
def fail_with_reason
|
||||
end
|
||||
|
||||
def fail_generic
|
||||
end
|
||||
|
||||
def no_before
|
||||
5
|
||||
end
|
||||
|
||||
def no_after
|
||||
end
|
||||
|
||||
def only_one
|
||||
end
|
||||
|
||||
def only_two
|
||||
end
|
||||
|
||||
def not_public
|
||||
end
|
||||
|
||||
protected
|
||||
def intercept_before(name, args)
|
||||
@before_invoked = name
|
||||
return [false, "permission denied"] if name == :fail_with_reason
|
||||
return false if name == :fail_generic
|
||||
end
|
||||
|
||||
def intercept_after(name, args, result)
|
||||
@after_invoked = name
|
||||
@invocation_result = result
|
||||
end
|
||||
|
||||
def intercept_only(name, args)
|
||||
raise "Interception error" unless name == :only_one || name == :only_two
|
||||
@only_invoked = name
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class TC_Invocation < Test::Unit::TestCase
|
||||
include ActionService::Invocation
|
||||
|
||||
def setup
|
||||
@service = InvocationTest::Service.new
|
||||
end
|
||||
|
||||
def test_invocation
|
||||
assert(perform_invocation(:add, 5, 10) == 15)
|
||||
assert(perform_invocation(:transmogrify, "hello") == "HELLO")
|
||||
assert_raises(InvocationError) do
|
||||
perform_invocation(:not_public)
|
||||
end
|
||||
assert_raises(InvocationError) do
|
||||
perform_invocation(:nonexistent_method_xyzzy)
|
||||
end
|
||||
end
|
||||
|
||||
def test_interceptor_registration
|
||||
assert(InvocationTest::Service.before_invocation_interceptors.length == 2)
|
||||
assert(InvocationTest::Service.after_invocation_interceptors.length == 1)
|
||||
end
|
||||
|
||||
def test_interception
|
||||
assert(@service.before_invoked.nil? && @service.after_invoked.nil? && @service.only_invoked.nil? && @service.invocation_result.nil?)
|
||||
perform_invocation(:add, 20, 50)
|
||||
assert(@service.before_invoked == :add)
|
||||
assert(@service.after_invoked == :add)
|
||||
assert(@service.invocation_result == 70)
|
||||
end
|
||||
|
||||
def test_interception_canceling
|
||||
reason = nil
|
||||
perform_invocation(:fail_with_reason){|r| reason = r}
|
||||
assert(@service.before_invoked == :fail_with_reason)
|
||||
assert(@service.after_invoked.nil?)
|
||||
assert(@service.invocation_result.nil?)
|
||||
assert(reason == "permission denied")
|
||||
reason = true
|
||||
@service.before_invoked = @service.after_invoked = @service.invocation_result = nil
|
||||
perform_invocation(:fail_generic){|r| reason = r}
|
||||
assert(@service.before_invoked == :fail_generic)
|
||||
assert(@service.after_invoked.nil?)
|
||||
assert(@service.invocation_result.nil?)
|
||||
assert(reason == true)
|
||||
end
|
||||
|
||||
def test_interception_except_conditions
|
||||
perform_invocation(:no_before)
|
||||
assert(@service.before_invoked.nil?)
|
||||
assert(@service.after_invoked == :no_before)
|
||||
assert(@service.invocation_result == 5)
|
||||
@service.before_invoked = @service.after_invoked = @service.invocation_result = nil
|
||||
perform_invocation(:no_after)
|
||||
assert(@service.before_invoked == :no_after)
|
||||
assert(@service.after_invoked.nil?)
|
||||
assert(@service.invocation_result.nil?)
|
||||
end
|
||||
|
||||
def test_interception_only_conditions
|
||||
assert(@service.only_invoked.nil?)
|
||||
perform_invocation(:only_one)
|
||||
assert(@service.only_invoked == :only_one)
|
||||
@service.only_invoked = nil
|
||||
perform_invocation(:only_two)
|
||||
assert(@service.only_invoked == :only_two)
|
||||
end
|
||||
|
||||
private
|
||||
def perform_invocation(method_name, *args, &block)
|
||||
public_method_name = @service.class.service_api.public_api_method_name(method_name)
|
||||
args ||= []
|
||||
request = InvocationRequest.new(ConcreteInvocation, public_method_name, method_name, args)
|
||||
@service.perform_invocation(request, &block)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
require File.dirname(__FILE__) + '/abstract_unit'
|
||||
|
||||
|
||||
module Foo
|
||||
include ActionService::Protocol
|
||||
|
||||
def self.append_features(base)
|
||||
super
|
||||
base.register_protocol(BodyOnly, FooMinimalProtocol)
|
||||
base.register_protocol(HeaderAndBody, FooMinimalProtocolTwo)
|
||||
base.register_protocol(HeaderAndBody, FooMinimalProtocolTwo)
|
||||
base.register_protocol(HeaderAndBody, FooFullProtocol)
|
||||
end
|
||||
|
||||
class FooFullProtocol < AbstractProtocol
|
||||
def self.create_protocol_request(klass, request)
|
||||
protocol = FooFullProtocol.new klass
|
||||
ActionService::Protocol::ProtocolRequest.new(protocol, '', '', '', '')
|
||||
end
|
||||
end
|
||||
|
||||
class FooMinimalProtocol < AbstractProtocol
|
||||
def self.create_protocol_request(klass, request)
|
||||
protocol = FooMinimalProtocol.new klass
|
||||
ActionService::Protocol::ProtocolRequest.new(protocol, '', '', '', '')
|
||||
end
|
||||
end
|
||||
|
||||
class FooMinimalProtocolTwo < AbstractProtocol
|
||||
end
|
||||
end
|
||||
|
||||
class ProtocolRegistry
|
||||
include ActionService::Protocol::Registry
|
||||
include Foo
|
||||
|
||||
def all_protocols
|
||||
header_and_body_protocols + body_only_protocols
|
||||
end
|
||||
|
||||
def protocol_request
|
||||
probe_request_protocol(nil)
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
class TC_ProtocolRegistry < Test::Unit::TestCase
|
||||
def test_registration
|
||||
registry = ProtocolRegistry.new
|
||||
assert(registry.all_protocols.length == 4)
|
||||
assert(registry.protocol_request.protocol.is_a?(Foo::FooFullProtocol))
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,226 @@
|
|||
require File.dirname(__FILE__) + '/abstract_soap'
|
||||
|
||||
module ProtocolSoapTest
|
||||
class Person < ActionService::Struct
|
||||
member :id, Integer
|
||||
member :names, [String]
|
||||
member :lastname, String
|
||||
member :deleted, TrueClass
|
||||
|
||||
def ==(other)
|
||||
id == other.id && names == other.names && lastname == other.lastname && deleted == other.deleted
|
||||
end
|
||||
end
|
||||
|
||||
class API < ActionService::API::Base
|
||||
api_method :argument_passing, :expects => [{:int=>:int}, {:string=>:string}, {:array=>[:int]}], :returns => [:bool]
|
||||
api_method :array_returner, :returns => [[:int]]
|
||||
api_method :nil_returner
|
||||
api_method :struct_array_returner, :returns => [[Person]]
|
||||
api_method :exception_thrower
|
||||
|
||||
default_api_method :default
|
||||
end
|
||||
|
||||
class Service < ActionService::Base
|
||||
service_api API
|
||||
|
||||
attr :int
|
||||
attr :string
|
||||
attr :array
|
||||
attr :values
|
||||
attr :person
|
||||
attr :default_args
|
||||
|
||||
def initialize
|
||||
@int = 20
|
||||
@string = "wrong string value"
|
||||
@default_args = nil
|
||||
end
|
||||
|
||||
def argument_passing(int, string, array)
|
||||
@int = int
|
||||
@string = string
|
||||
@array = array
|
||||
true
|
||||
end
|
||||
|
||||
def array_returner
|
||||
@values = [1, 2, 3]
|
||||
end
|
||||
|
||||
def nil_returner
|
||||
nil
|
||||
end
|
||||
|
||||
def struct_array_returner
|
||||
@person = Person.new
|
||||
@person.id = 5
|
||||
@person.names = ["one", "two"]
|
||||
@person.lastname = "test"
|
||||
@person.deleted = false
|
||||
[@person]
|
||||
end
|
||||
|
||||
def exception_thrower
|
||||
raise "Hi, I'm a SOAP error"
|
||||
end
|
||||
|
||||
def default(*args)
|
||||
@default_args = args
|
||||
nil
|
||||
end
|
||||
end
|
||||
|
||||
class AbstractContainer
|
||||
include ActionService::API
|
||||
include ActionService::Container
|
||||
include ActionService::Protocol::Registry
|
||||
include ActionService::Protocol::Soap
|
||||
|
||||
wsdl_service_name 'Test'
|
||||
|
||||
def protocol_request(request)
|
||||
probe_request_protocol(request)
|
||||
end
|
||||
|
||||
def dispatch_request(protocol_request)
|
||||
dispatch_service_request(protocol_request)
|
||||
end
|
||||
end
|
||||
|
||||
class DelegatedContainer < AbstractContainer
|
||||
service_dispatching_mode :delegated
|
||||
service :protocol_soap_service, Service.new
|
||||
end
|
||||
|
||||
class DirectContainer < AbstractContainer
|
||||
service_api API
|
||||
service_dispatching_mode :direct
|
||||
|
||||
attr :int
|
||||
attr :string
|
||||
attr :array
|
||||
attr :values
|
||||
attr :person
|
||||
attr :default_args
|
||||
|
||||
def initialize
|
||||
@int = 20
|
||||
@string = "wrong string value"
|
||||
@default_args = nil
|
||||
end
|
||||
|
||||
def argument_passing
|
||||
@int = @params['int']
|
||||
@string = @params['string']
|
||||
@array = @params['array']
|
||||
true
|
||||
end
|
||||
|
||||
def array_returner
|
||||
@values = [1, 2, 3]
|
||||
end
|
||||
|
||||
def nil_returner
|
||||
nil
|
||||
end
|
||||
|
||||
def struct_array_returner
|
||||
@person = Person.new
|
||||
@person.id = 5
|
||||
@person.names = ["one", "two"]
|
||||
@person.lastname = "test"
|
||||
@person.deleted = false
|
||||
[@person]
|
||||
end
|
||||
|
||||
def exception_thrower
|
||||
raise "Hi, I'm a SOAP error"
|
||||
end
|
||||
|
||||
def default
|
||||
@default_args = @method_params
|
||||
nil
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class TC_ProtocolSoap < AbstractSoapTest
|
||||
def setup
|
||||
@delegated_container = ProtocolSoapTest::DelegatedContainer.new
|
||||
@direct_container = ProtocolSoapTest::DirectContainer.new
|
||||
end
|
||||
|
||||
def test_argument_passing
|
||||
in_all_containers do
|
||||
assert(do_soap_call('ArgumentPassing', 5, "test string", [true, false]) == true)
|
||||
assert(service.int == 5)
|
||||
assert(service.string == "test string")
|
||||
assert(service.array == [true, false])
|
||||
end
|
||||
end
|
||||
|
||||
def test_array_returner
|
||||
in_all_containers do
|
||||
assert(do_soap_call('ArrayReturner') == [1, 2, 3])
|
||||
assert(service.values == [1, 2, 3])
|
||||
end
|
||||
end
|
||||
|
||||
def test_nil_returner
|
||||
in_all_containers do
|
||||
assert(do_soap_call('NilReturner') == nil)
|
||||
end
|
||||
end
|
||||
|
||||
def test_struct_array_returner
|
||||
in_all_containers do
|
||||
assert(do_soap_call('StructArrayReturner') == [service.person])
|
||||
end
|
||||
end
|
||||
|
||||
def test_exception_thrower
|
||||
in_all_containers do
|
||||
assert_raises(RuntimeError) do
|
||||
do_soap_call('ExceptionThrower')
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def test_default_api_method
|
||||
in_all_containers do
|
||||
assert(do_soap_call('NonExistentMethodName', 50, false).nil?)
|
||||
assert(service.default_args == [50, false])
|
||||
end
|
||||
end
|
||||
|
||||
def test_service_name_setting
|
||||
in_all_containers do
|
||||
assert(ProtocolSoapTest::DelegatedContainer.soap_mapper.custom_namespace == 'urn:Test')
|
||||
end
|
||||
end
|
||||
|
||||
protected
|
||||
def service_name
|
||||
@container == @direct_container ? 'api' : 'protocol_soap_service'
|
||||
end
|
||||
|
||||
def service
|
||||
@container == @direct_container ? @container : @container.service_object(:protocol_soap_service)
|
||||
end
|
||||
|
||||
def in_all_containers(&block)
|
||||
[@direct_container].each do |container|
|
||||
@container = container
|
||||
block.call
|
||||
end
|
||||
end
|
||||
|
||||
def do_soap_call(public_method_name, *args)
|
||||
super(public_method_name, *args) do |test_request, test_response|
|
||||
protocol_request = @container.protocol_request(test_request)
|
||||
@container.dispatch_request(protocol_request)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,157 @@
|
|||
require File.dirname(__FILE__) + '/abstract_unit'
|
||||
require 'xmlrpc/parser'
|
||||
require 'xmlrpc/create'
|
||||
require 'xmlrpc/config'
|
||||
|
||||
module XMLRPC
|
||||
class XmlRpcTestHelper
|
||||
include ParserWriterChooseMixin
|
||||
|
||||
def create_request(methodName, *args)
|
||||
create().methodCall(methodName, *args)
|
||||
end
|
||||
|
||||
def parse_response(response)
|
||||
parser().parseMethodResponse(response)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
module ProtocolXmlRpcTest
|
||||
class Person < ActionService::Struct
|
||||
member :firstname, String
|
||||
member :lastname, String
|
||||
member :active, TrueClass
|
||||
end
|
||||
|
||||
class API < ActionService::API::Base
|
||||
api_method :add, :expects => [Integer, Integer], :returns => [Integer]
|
||||
api_method :hash_returner, :returns => [Hash]
|
||||
api_method :array_returner, :returns => [[Integer]]
|
||||
api_method :something_hash, :expects => [Hash]
|
||||
api_method :struct_array_returner, :returns => [[Person]]
|
||||
|
||||
default_api_method :default
|
||||
end
|
||||
|
||||
class Service < ActionService::Base
|
||||
service_api API
|
||||
|
||||
attr :result
|
||||
attr :hashvalue
|
||||
attr :default_args
|
||||
|
||||
def initialize
|
||||
@result = nil
|
||||
@hashvalue = nil
|
||||
@default_args = nil
|
||||
end
|
||||
|
||||
def add(a, b)
|
||||
@result = a + b
|
||||
end
|
||||
|
||||
def something_hash(hash)
|
||||
@hashvalue = hash
|
||||
end
|
||||
|
||||
def array_returner
|
||||
[1, 2, 3]
|
||||
end
|
||||
|
||||
def hash_returner
|
||||
{'name' => 1, 'value' => 2}
|
||||
end
|
||||
|
||||
def struct_array_returner
|
||||
person = Person.new
|
||||
person.firstname = "John"
|
||||
person.lastname = "Doe"
|
||||
person.active = true
|
||||
[person]
|
||||
end
|
||||
|
||||
def default(*args)
|
||||
@default_args = args
|
||||
nil
|
||||
end
|
||||
end
|
||||
|
||||
$service = Service.new
|
||||
|
||||
class Container
|
||||
include ActionService::Container
|
||||
include ActionService::Protocol::Registry
|
||||
include ActionService::Protocol::Soap
|
||||
include ActionService::Protocol::XmlRpc
|
||||
|
||||
def protocol_request(request)
|
||||
probe_request_protocol(request)
|
||||
end
|
||||
|
||||
def dispatch_request(protocol_request)
|
||||
dispatch_service_request(protocol_request)
|
||||
end
|
||||
|
||||
service :xmlrpc, $service
|
||||
service_dispatching_mode :delegated
|
||||
end
|
||||
end
|
||||
|
||||
class TC_ProtocolXmlRpc < Test::Unit::TestCase
|
||||
def setup
|
||||
@helper = XMLRPC::XmlRpcTestHelper.new
|
||||
@container = ProtocolXmlRpcTest::Container.new
|
||||
end
|
||||
|
||||
def test_xmlrpc_request_dispatching
|
||||
retval = do_xmlrpc_call('Add', 50, 30)
|
||||
assert(retval == [true, 80])
|
||||
end
|
||||
|
||||
def test_array_returning
|
||||
retval = do_xmlrpc_call('ArrayReturner')
|
||||
assert(retval == [true, [1, 2, 3]])
|
||||
end
|
||||
|
||||
def test_hash_returning
|
||||
retval = do_xmlrpc_call('HashReturner')
|
||||
assert(retval == [true, {'name' => 1, 'value' => 2}])
|
||||
end
|
||||
|
||||
def test_struct_array_returning
|
||||
retval = do_xmlrpc_call('StructArrayReturner')
|
||||
assert(retval == [true, [{"firstname"=>"John", "lastname"=>"Doe", "active"=>true}]])
|
||||
end
|
||||
|
||||
def test_hash_parameter
|
||||
retval = do_xmlrpc_call('SomethingHash', {'name' => 1, 'value' => 2})
|
||||
assert(retval == [true, true])
|
||||
assert($service.hashvalue == {'name' => 1, 'value' => 2})
|
||||
end
|
||||
|
||||
def test_default_api_method
|
||||
retval = do_xmlrpc_call('SomeNonexistentMethod', 'test', [1, 2], {'name'=>'value'})
|
||||
assert(retval == [true, true])
|
||||
assert($service.default_args == ['test', [1, 2], {'name'=>'value'}])
|
||||
end
|
||||
|
||||
def test_xmlrpc_introspection
|
||||
retval = do_xmlrpc_call('system.listMethods', 'test', [1, 2], {'name'=>'value'})
|
||||
assert(retval == [true, ["Add", "ArrayReturner", "HashReturner", "SomethingHash", "StructArrayReturner"]])
|
||||
end
|
||||
|
||||
private
|
||||
def do_xmlrpc_call(public_method_name, *args)
|
||||
service_name = 'xmlrpc'
|
||||
raw_request = @helper.create_request(public_method_name, *args)
|
||||
test_request = ActionController::TestRequest.new
|
||||
test_request.request_parameters['action'] = service_name
|
||||
test_request.env['REQUEST_METHOD'] = "POST"
|
||||
test_request.env['HTTP_CONTENTTYPE'] = 'text/xml'
|
||||
test_request.env['RAW_POST_DATA'] = raw_request
|
||||
protocol_request = @container.protocol_request(test_request)
|
||||
response = @container.dispatch_request(protocol_request)
|
||||
@helper.parse_response(response.raw_body)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,139 @@
|
|||
require File.dirname(__FILE__) + '/abstract_soap'
|
||||
require 'wsdl/parser'
|
||||
|
||||
module RouterActionControllerTest
|
||||
class API < ActionService::API::Base
|
||||
api_method :add, :expects => [:int, :int], :returns => [:int]
|
||||
end
|
||||
|
||||
class Service < ActionService::Base
|
||||
service_api API
|
||||
|
||||
attr :added
|
||||
|
||||
def add(a, b)
|
||||
@added = a + b
|
||||
end
|
||||
end
|
||||
|
||||
class DelegatedController < ActionController::Base
|
||||
service_dispatching_mode :delegated
|
||||
|
||||
service(:test_service) { @service ||= Service.new; @service }
|
||||
end
|
||||
|
||||
class DirectAPI < ActionService::API::Base
|
||||
api_method :add, :expects => [{:a=>:int}, {:b=>:int}], :returns => [:int]
|
||||
api_method :before_filtered
|
||||
api_method :after_filtered, :returns => [:int]
|
||||
api_method :thrower
|
||||
end
|
||||
|
||||
class DirectController < ActionController::Base
|
||||
service_api DirectAPI
|
||||
service_dispatching_mode :direct
|
||||
|
||||
before_filter :alwaysfail, :only => [:before_filtered]
|
||||
after_filter :alwaysok, :only => [:after_filtered]
|
||||
|
||||
attr :added
|
||||
attr :before_filter_called
|
||||
attr :before_filter_target_called
|
||||
attr :after_filter_called
|
||||
attr :after_filter_target_called
|
||||
|
||||
def initialize
|
||||
@before_filter_called = false
|
||||
@before_filter_target_called = false
|
||||
@after_filter_called = false
|
||||
@after_filter_target_called = false
|
||||
end
|
||||
|
||||
def add
|
||||
@added = @params['a'] + @params['b']
|
||||
end
|
||||
|
||||
def before_filtered
|
||||
@before_filter_target_called = true
|
||||
end
|
||||
|
||||
def after_filtered
|
||||
@after_filter_target_called = true
|
||||
5
|
||||
end
|
||||
|
||||
def thrower
|
||||
raise "Hi, I'm a SOAP exception"
|
||||
end
|
||||
|
||||
protected
|
||||
def alwaysfail
|
||||
@before_filter_called = true
|
||||
false
|
||||
end
|
||||
|
||||
def alwaysok
|
||||
@after_filter_called = true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class TC_RouterActionController < AbstractSoapTest
|
||||
def test_direct_routing
|
||||
@container = RouterActionControllerTest::DirectController.new
|
||||
assert(do_soap_call('Add', 20, 50) == 70)
|
||||
assert(@container.added == 70)
|
||||
end
|
||||
|
||||
def test_direct_entrypoint
|
||||
@container = RouterActionControllerTest::DirectController.new
|
||||
assert(@container.respond_to?(:api))
|
||||
end
|
||||
|
||||
def test_direct_filtering
|
||||
@container = RouterActionControllerTest::DirectController.new
|
||||
assert(@container.before_filter_called == false)
|
||||
assert(@container.before_filter_target_called == false)
|
||||
assert(do_soap_call('BeforeFiltered').nil?)
|
||||
assert(@container.before_filter_called == true)
|
||||
assert(@container.before_filter_target_called == false)
|
||||
assert(@container.after_filter_called == false)
|
||||
assert(@container.after_filter_target_called == false)
|
||||
assert(do_soap_call('AfterFiltered') == 5)
|
||||
assert(@container.after_filter_called == true)
|
||||
assert(@container.after_filter_target_called == true)
|
||||
end
|
||||
|
||||
def test_delegated_routing
|
||||
@container = RouterActionControllerTest::DelegatedController.new
|
||||
assert(do_soap_call('Add', 50, 80) == 130)
|
||||
assert(service.added == 130)
|
||||
end
|
||||
|
||||
def test_exception_marshaling
|
||||
@container = RouterActionControllerTest::DirectController.new
|
||||
result = do_soap_call('Thrower')
|
||||
exception = result.detail
|
||||
assert(exception.cause.is_a?(RuntimeError))
|
||||
assert_equal("Hi, I'm a SOAP exception", exception.cause.message)
|
||||
@container.service_exception_reporting = false
|
||||
assert_raises(SoapTestError) do
|
||||
do_soap_call('Thrower')
|
||||
end
|
||||
end
|
||||
|
||||
protected
|
||||
def service_name
|
||||
@container.is_a?(RouterActionControllerTest::DelegatedController) ? 'test_service' : 'api'
|
||||
end
|
||||
|
||||
def service
|
||||
@container.service_object(:test_service)
|
||||
end
|
||||
|
||||
def do_soap_call(public_method_name, *args)
|
||||
super(public_method_name, *args) do |test_request, test_response|
|
||||
response = @container.process(test_request, test_response)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
require File.dirname(__FILE__) + '/abstract_unit'
|
||||
require 'wsdl/parser'
|
||||
|
||||
module RouterWsdlTest
|
||||
class Person < ActionService::Struct
|
||||
member :id, Integer
|
||||
member :names, [String]
|
||||
member :lastname, String
|
||||
member :deleted, TrueClass
|
||||
end
|
||||
|
||||
class API < ActionService::API::Base
|
||||
api_method :add, :expects => [{:a=>:int}, {:b=>:int}], :returns => [:int]
|
||||
api_method :find_people, :returns => [[Person]]
|
||||
api_method :nil_returner
|
||||
end
|
||||
|
||||
class Service < ActionService::Base
|
||||
service_api API
|
||||
|
||||
def add(a, b)
|
||||
a + b
|
||||
end
|
||||
|
||||
def find_people
|
||||
[]
|
||||
end
|
||||
|
||||
def nil_returner
|
||||
end
|
||||
end
|
||||
|
||||
class AbstractController < ActionController::Base
|
||||
def generate_wsdl(container, uri, soap_action_base)
|
||||
to_wsdl(container, uri, soap_action_base)
|
||||
end
|
||||
end
|
||||
|
||||
class DirectController < AbstractController
|
||||
service_api API
|
||||
|
||||
def add
|
||||
end
|
||||
|
||||
def find_people
|
||||
end
|
||||
|
||||
def nil_returner
|
||||
end
|
||||
end
|
||||
|
||||
class DelegatedController < AbstractController
|
||||
service_dispatching_mode :delegated
|
||||
service(:test_service) { Service.new }
|
||||
end
|
||||
end
|
||||
|
||||
class TC_RouterWsdl < Test::Unit::TestCase
|
||||
include RouterWsdlTest
|
||||
|
||||
def test_wsdl_generation
|
||||
ensure_valid_generation DelegatedController.new
|
||||
ensure_valid_generation DirectController.new
|
||||
end
|
||||
|
||||
def
|
||||
|
||||
def test_wsdl_action
|
||||
ensure_valid_wsdl_action DelegatedController.new
|
||||
ensure_valid_wsdl_action DirectController.new
|
||||
end
|
||||
|
||||
protected
|
||||
def ensure_valid_generation(controller)
|
||||
wsdl = controller.generate_wsdl(controller, 'http://localhost:3000/test/', '/test')
|
||||
ensure_valid_wsdl(wsdl)
|
||||
end
|
||||
|
||||
def ensure_valid_wsdl(wsdl)
|
||||
definitions = WSDL::Parser.new.parse(wsdl)
|
||||
assert(definitions.is_a?(WSDL::Definitions))
|
||||
definitions.bindings.each do |binding|
|
||||
assert(binding.name.name.index(':').nil?)
|
||||
end
|
||||
definitions.services.each do |service|
|
||||
service.ports.each do |port|
|
||||
assert(port.name.name.index(':').nil?)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def ensure_valid_wsdl_action(controller)
|
||||
test_request = ActionController::TestRequest.new({ 'action' => 'wsdl' })
|
||||
test_request.env['REQUEST_METHOD'] = 'GET'
|
||||
test_request.env['HTTP_HOST'] = 'localhost:3000'
|
||||
test_response = ActionController::TestResponse.new
|
||||
wsdl = controller.process(test_request, test_response).body
|
||||
ensure_valid_wsdl(wsdl)
|
||||
end
|
||||
end
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
require File.dirname(__FILE__) + '/abstract_unit'
|
||||
|
||||
module StructTest
|
||||
class Struct < ActionService::Struct
|
||||
member :id, Integer
|
||||
member :name, String
|
||||
member :items, [String]
|
||||
member :deleted, :bool
|
||||
member :emails, [:string]
|
||||
end
|
||||
end
|
||||
|
||||
class TC_Struct < Test::Unit::TestCase
|
||||
def test_members
|
||||
assert_equal(5, StructTest::Struct.members.size)
|
||||
assert_equal(Integer, StructTest::Struct.members[:id])
|
||||
assert_equal(String, StructTest::Struct.members[:name])
|
||||
assert_equal([String], StructTest::Struct.members[:items])
|
||||
assert_equal(TrueClass, StructTest::Struct.members[:deleted])
|
||||
assert_equal([String], StructTest::Struct.members[:emails])
|
||||
end
|
||||
|
||||
def test_initializer_and_lookup
|
||||
s = StructTest::Struct.new(:id => 5,
|
||||
:name => 'hello',
|
||||
:items => ['one', 'two'],
|
||||
:deleted => true,
|
||||
:emails => ['test@test.com'])
|
||||
assert_equal(5, s.id)
|
||||
assert_equal('hello', s.name)
|
||||
assert_equal(['one', 'two'], s.items)
|
||||
assert_equal(true, s.deleted)
|
||||
assert_equal(['test@test.com'], s.emails)
|
||||
assert_equal(5, s['id'])
|
||||
assert_equal('hello', s['name'])
|
||||
assert_equal(['one', 'two'], s['items'])
|
||||
assert_equal(true, s['deleted'])
|
||||
assert_equal(['test@test.com'], s['emails'])
|
||||
end
|
||||
end
|
||||
Loading…
Reference in New Issue