jro_apps/redmine Files · vendor/plugins/actionwebservice/README

Removes unused projects_count column from projects table....

Removes unused projects_count column from projects table. git-svn-id: svn+ssh://rubyforge.org/var/svn/redmine/trunk@2305 e93f8b46-1217-0410-a6f0-8f06a7374b81

Jean-Philippe Lang - - Load All Authors

File last commit:

r962:6d9490ddcc9c


                r2303:97e31c402614

Download file

             README
        
                    364 lines
            
             | 9.9 KiB
            
                | text/plain
            
             |
                TextLexer

/ vendor / plugins / actionwebservice / README

History | Source | Raw |Copy content |Copy permalink

Jean-Philippe Lang Merged Rails 2.0 compatibility changes....	r962	= Action Web Service -- Serving APIs on rails

		Action Web 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 Web 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
		ActionWebService::API::Base derivative, and then specify this API
		definition class wherever you want to use that API.

		The implementation of the methods is done separately from the API
		specification.


		==== Method name inflection

		Action Web 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
		ActionWebService::API::Base +inflect_names+ option.


		==== Inflection examples

		:add => Add
		:find_all => FindAll


		==== Disabling inflection

		class PersonAPI < ActionWebService::API::Base
		inflect_names false
		end


		==== API definition example

		class PersonAPI < ActionWebService::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
		web_service_api PersonAPI

		def add
		end

		def remove
		end
		end


		== Publishing your APIs

		Action Web 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, public controller instance methods
		implement the API methods, and parameters are passed through to the methods in
		accordance with the API specification.

		The return value of the method 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 method
		and send back the wrapped return value. <em>This action must not be
		overridden.</em>

		==== Direct dispatching example

		class PersonController < ApplicationController
		web_service_api PersonAPI

		def add
		end

		def remove
		end
		end

		class PersonAPI < ActionWebService::API::Base
		...
		end


		For this example, protocol requests for +Add+ and +Remove+ methods sent to
		<tt>/person/api</tt> will be routed to the controller methods +add+ and +remove+.


		=== Delegated dispatching

		This mode can be turned on by setting the +web_service_dispatching_mode+ option
		in a controller to <tt>:delegated</tt>.

		In this mode, the controller contains one or more web service objects (objects
		that implement an ActionWebService::API::Base definition). These web service
		objects are each mapped onto one controller action only.

		==== Delegated dispatching example

		class ApiController < ApplicationController
		web_service_dispatching_mode :delegated

		web_service :person, PersonService.new
		end

		class PersonService < ActionWebService::Base
		web_service_api PersonAPI

		def add
		end

		def remove
		end
		end

		class PersonAPI < ActionWebService::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 +web_service+
		method is called. <em>This action must not be overridden.</em>

		Other controller actions (actions that aren't the target of a +web_service+ call)
		are ignored for ActionWebService purposes, and can do normal action tasks.


		=== Layered dispatching

		This mode can be turned on by setting the +web_service_dispatching_mode+ option
		in a controller to <tt>:layered</tt>.

		This mode is similar to _delegated_ mode, in that multiple web service objects
		can be attached to one controller, however, all protocol requests are sent to a
		single endpoint.

		Use this mode when you want to share code between XML-RPC and SOAP clients,
		for APIs where the XML-RPC method names have prefixes. An example of such
		a method name would be <tt>blogger.newPost</tt>.


		==== Layered dispatching example


		class ApiController < ApplicationController
		web_service_dispatching_mode :layered

		web_service :mt, MovableTypeService.new
		web_service :blogger, BloggerService.new
		web_service :metaWeblog, MetaWeblogService.new
		end

		class MovableTypeService < ActionWebService::Base
		...
		end

		class BloggerService < ActionWebService::Base
		...
		end

		class MetaWeblogService < ActionWebService::API::Base
		...
		end


		For this example, an XML-RPC call for a method with a name like
		<tt>mt.getCategories</tt> will be sent to the <tt>getCategories</tt>
		method on the <tt>:mt</tt> service.


		== Customizing WSDL generation

		You can customize the names used for the SOAP bindings in the generated
		WSDL by using the wsdl_service_name option in a controller:

		class WsController < ApplicationController
		wsdl_service_name 'MyApp'
		end

		You can also customize the namespace used in the generated WSDL for
		custom types and message definition types:

		class WsController < ApplicationController
		wsdl_namespace 'http://my.company.com/app/wsapi'
		end

		The default namespace used is 'urn:ActionWebService', if you don't supply
		one.


		== ActionWebService and UTF-8

		If you're going to be sending back strings containing non-ASCII UTF-8
		characters using the <tt>:string</tt> data type, you need to make sure that
		Ruby is using UTF-8 as the default encoding for its strings.

		The default in Ruby is to use US-ASCII encoding for strings, which causes a string
		validation check in the Ruby SOAP library to fail and your string to be sent
		back as a Base-64 value, which may confuse clients that expected strings
		because of the WSDL.

		Two ways of setting the default string encoding are:

		* Start Ruby using the <tt>-Ku</tt> command-line option to the Ruby executable
		* Set the <tt>$KCODE</tt> flag in <tt>config/environment.rb</tt> to the
		string <tt>'UTF8'</tt>


		== Testing your APIs


		=== Functional testing

		You can perform testing of your APIs by creating a functional test for the
		controller dispatching the API, and calling #invoke in the test case to
		perform the invocation.

		Example:

		class PersonApiControllerTest < Test::Unit::TestCase
		def setup
		@controller = PersonController.new
		@request = ActionController::TestRequest.new
		@response = ActionController::TestResponse.new
		end

		def test_add
		result = invoke :remove, 1
		assert_equal true, result
		end
		end

		This example invokes the API method <tt>test</tt>, defined on
		the PersonController, and returns the result.


		=== Scaffolding

		You can also test your APIs with a web browser by attaching scaffolding
		to the controller.

		Example:

		class PersonController
		web_service_scaffold :invocation
		end

		This creates an action named <tt>invocation</tt> on the PersonController.

		Navigating to this action lets you select the method to invoke, supply the parameters,
		and view the result of the invocation.


		== Using the client support

		Action Web 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 Web 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 Web Service client
		support can only be guaranteed to work with a subset.


		==== Factory created client example

		class BlogManagerController < ApplicationController
		web_client_api :blogger, :xmlrpc, 'http://url/to/blog/api/RPC2', :handler_name => 'blogger'
		end

		class SearchingController < ApplicationController
		web_client_api :google, :soap, 'http://url/to/blog/api/beta', :service_name => 'GoogleSearch'
		end

		See ActionWebService::API::ActionController::ClassMethods for more details.

		==== Manually created client example

		class PersonAPI < ActionWebService::API::Base
		api_method :find_all, :returns => [[Person]]
		end

		soap_client = ActionWebService::Client::Soap.new(PersonAPI, "http://...")
		persons = soap_client.find_all

		class BloggerAPI < ActionWebService::API::Base
		inflect_names false
		api_method :getRecentPosts, :returns => [[Blog::Post]]
		end

		blog = ActionWebService::Client::XmlRpc.new(BloggerAPI, "http://.../xmlrpc", :handler_name => "blogger")
		posts = blog.getRecentPosts


		See ActionWebService::Client::Soap and ActionWebService::Client::XmlRpc for more details.

		== Dependencies

		Action Web 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 Web Service version can be downloaded from
		http://rubyforge.org/projects/actionservice


		== Installation

		You can install Action Web Service with the following command.

		% [sudo] ruby setup.rb


		== License

		Action Web 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

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages