GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  CATALYST::CONTROLLER::REST (3)

.ds Aq ’

NAME

Catalyst::Controller::REST - A RESTful controller

CONTENTS

SYNOPSIS



    package Foo::Controller::Bar;
    use Moose;
    use namespace::autoclean;

    BEGIN { extends Catalyst::Controller::REST }

    sub thing : Local : ActionClass(REST) { }

    # Answer GET requests to "thing"
    sub thing_GET {
       my ( $self, $c ) = @_;

       # Return a 200 OK, with the data in entity
       # serialized in the body
       $self->status_ok(
            $c,
            entity => {
                some => data,
                foo  => is real bar-y,
            },
       );
    }

    # Answer PUT requests to "thing"
    sub thing_PUT {
        my ( $self, $c ) = @_;

        $radiohead = $c->req->data->{radiohead};

        $self->status_created(
            $c,
            location => $c->req->uri,
            entity => {
                radiohead => $radiohead,
            }
        );
    }



DESCRIPTION

Catalyst::Controller::REST implements a mechanism for building RESTful services in Catalyst. It does this by extending the normal Catalyst dispatch mechanism to allow for different subroutines to be called based on the HTTP Method requested, while also transparently handling all the serialization/deserialization for you.

This is probably best served by an example. In the above controller, we have declared a Local Catalyst action on sub thing, and have used the ActionClass(’REST’).

Below, we have declared thing_GET and thing_PUT. Any GET requests to thing will be dispatched to thing_GET, while any PUT requests will be dispatched to thing_PUT.

Any unimplemented HTTP methods will be met with a 405 Method Not Allowed response, automatically containing the proper list of available methods. You can override this behavior through implementing a custom thing_not_implemented method.

If you do not provide an OPTIONS handler, we will respond to any OPTIONS requests with a 200 OK, populating the Allowed header automatically.

Any data included in $c->stash->{rest} will be serialized for you. The serialization format will be selected based on the content-type of the incoming request. It is probably easier to use the STATUS HELPERS, which are described below.

"The HTTP POST, PUT, and OPTIONS methods will all automatically deserialize the contents of $c->request->body into the $c->request->data hashref", based on the request’s Content-type header. A list of understood serialization formats is below.

If we do not have (or cannot run) a serializer for a given content-type, a 415 Unsupported Media Type error is generated.

To make your Controller RESTful, simply have it



  BEGIN { extends Catalyst::Controller::REST }



CONFIGURATION

See CONFIGURATION in Catalyst::Action::Serialize. Note that the serialize key has been deprecated.

SERIALIZATION

Catalyst::Controller::REST will automatically serialize your responses, and deserialize any POST, PUT or OPTIONS requests. It evaluates which serializer to use by mapping a content-type to a Serialization module. We select the content-type based on:
<B>The Content-Type HeaderB> If the incoming HTTP Request had a Content-Type header set, we will use it.
<B>The content-type Query ParameterB> If this is a GET request, you can supply a content-type query parameter.
<B>Evaluating the Accept HeaderB> Finally, if the client provided an Accept header, we will evaluate it and use the best-ranked choice.

AVAILABLE SERIALIZERS

A given serialization mechanism is only available if you have the underlying modules installed. For example, you can’t use XML::Simple if it’s not already installed.

In addition, each serializer has its quirks in terms of what sorts of data structures it will properly handle. Catalyst::Controller::REST makes no attempt to save you from yourself in this regard. :)
o text/x-yaml => YAML::Syck

Returns YAML generated by YAML::Syck.

o text/html => YAML::HTML

This uses YAML::Syck and URI::Find to generate YAML with all URLs turned to hyperlinks. Only usable for Serialization.

o application/json => JSON

Uses JSON to generate JSON output. It is strongly advised to also have JSON::XS installed. The text/x-json content type is supported but is deprecated and you will receive warnings in your log.

You can also add a hash in your controller config to pass options to the json object. For instance, to relax permissions when deserializing input, add:
__PACKAGE__->config(
json_options => { relaxed => 1 }
)

o text/javascript => JSONP

If a callback=? parameter is passed, this returns javascript in the form of: $callback($serializedJSON);

Note - this is disabled by default as it can be a security risk if you are unaware.

The usual MIME types for this serialization format are: ’text/javascript’, ’application/x-javascript’, ’application/javascript’.

o text/x-data-dumper => Data::Serializer

Uses the Data::Serializer module to generate Data::Dumper output.

o text/x-data-denter => Data::Serializer

Uses the Data::Serializer module to generate Data::Denter output.

o text/x-data-taxi => Data::Serializer

Uses the Data::Serializer module to generate Data::Taxi output.

o text/x-config-general => Data::Serializer

Uses the Data::Serializer module to generate Config::General output.

o text/x-php-serialization => Data::Serializer

Uses the Data::Serializer module to generate PHP::Serialization output.

o text/xml => XML::Simple

Uses XML::Simple to generate XML output. This is probably not suitable for any real heavy XML work. Due to XML::Simples requirement that the data you serialize be a HASHREF, we transform outgoing data to be in the form of:



  { data => $yourdata }



o View

Uses a regular Catalyst view. For example, if you wanted to have your text/html and text/xml views rendered by TT, set:



  __PACKAGE__->config(
      map => {
          text/html => [ View, TT ],
          text/xml  => [ View, XML ],
      }
  );



Your views should have a process method like this:



  sub process {
      my ( $self, $c, $stash_key ) = @_;

      my $output;
      eval {
          $output = $self->serialize( $c->stash->{$stash_key} );
      };
      return $@ if $@;

      $c->response->body( $output );
      return 1;  # important
  }

  sub serialize {
      my ( $self, $data ) = @_;

      my $serialized = ... process $data here ...

      return $serialized;
  }



o Callback

For infinite flexibility, you can provide a callback for the deserialization/serialization steps.



  __PACKAGE__->config(
      map => {
          text/xml  => [ Callback, { deserialize => \&parse_xml, serialize => \&render_xml } ],
      }
  );



The deserialize callback is passed a string that is the body of the request and is expected to return a scalar value that results from the deserialization. The serialize callback is passed the data structure that needs to be serialized and must return a string suitable for returning in the HTTP response. In addition to receiving the scalar to act on, both callbacks are passed the controller object and the context (i.e. $c) as the second and third arguments.

By default, Catalyst::Controller::REST will return a 415 Unsupported Media Type response if an attempt to use an unsupported content-type is made. You can ensure that something is always returned by setting the default config option:



  __PACKAGE__->config(default => text/x-yaml);



would make it always fall back to the serializer plugin defined for text/x-yaml.

CUSTOM SERIALIZERS

Implementing new Serialization formats is easy! Contributions are most welcome! If you would like to implement a custom serializer, you should create two new modules in the Catalyst::Action::Serialize and Catalyst::Action::Deserialize namespace. Then assign your new class to the content-type’s you want, and you’re done.

See Catalyst::Action::Serialize and Catalyst::Action::Deserialize for more information.

STATUS HELPERS

Since so much of REST is in using HTTP, we provide these Status Helpers. Using them will ensure that you are responding with the proper codes, headers, and entities.

These helpers try and conform to the HTTP 1.1 Specification. You can refer to it at: <http://www.w3.org/Protocols/rfc2616/rfc2616.txt>. These routines are all implemented as regular subroutines, and as such require you pass the current context ($c) as the first argument.
status_ok Returns a 200 OK response. Takes an entity to serialize.

Example:



  $self->status_ok(
    $c,
    entity => {
        radiohead => "Is a good band!",
    }
  );



status_created Returns a 201 CREATED response. Takes an entity to serialize, and a location where the created object can be found.

Example:



  $self->status_created(
    $c,
    location => $c->req->uri,
    entity => {
        radiohead => "Is a good band!",
    }
  );



In the above example, we use the requested URI as our location. This is probably what you want for most PUT requests.

status_accepted Returns a 202 ACCEPTED response. Takes an entity to serialize. Also takes optional location for queue type scenarios.

Example:



  $self->status_accepted(
    $c,
    location => $c->req->uri,
    entity => {
        status => "queued",
    }
  );



status_no_content Returns a 204 NO CONTENT response.
status_multiple_choices Returns a 300 MULTIPLE CHOICES response. Takes an entity to serialize, which should provide list of possible locations. Also takes optional location for preferred choice.
status_found Returns a 302 FOUND response. Takes an entity to serialize. Also takes optional location.
status_bad_request Returns a 400 BAD REQUEST response. Takes a message argument as a scalar, which will become the value of error in the serialized response.

Example:



  $self->status_bad_request(
    $c,
    message => "Cannot do what you have asked!",
  );



status_forbidden Returns a 403 FORBIDDEN response. Takes a message argument as a scalar, which will become the value of error in the serialized response.

Example:



  $self->status_forbidden(
    $c,
    message => "access denied",
  );



status_not_found Returns a 404 NOT FOUND response. Takes a message argument as a scalar, which will become the value of error in the serialized response.

Example:



  $self->status_not_found(
    $c,
    message => "Cannot find what you were looking for!",
  );



gone Returns a 41O GONE response. Takes a message argument as a scalar, which will become the value of error in the serialized response.

Example:



  $self->status_gone(
    $c,
    message => "The document have been deleted by foo",
  );



status_see_other Returns a 303 See Other response. Takes an optional entity to serialize, and a location where the client should redirect to.

Example:



  $self->status_see_other(
    $c,
    location => $some_other_url,
    entity => {
        radiohead => "Is a good band!",
    }
  );



status_moved Returns a 301 MOVED response. Takes an entity to serialize, and a location where the created object can be found.

Example:



 $self->status_moved(
   $c,
   location => /somewhere/else,
   entity => {
     radiohead => "Is a good band!",
   },
 );



MANUAL RESPONSES

If you want to construct your responses yourself, all you need to do is put the object you want serialized in $c->stash->{’rest’}.

IMPLEMENTATION DETAILS

This Controller ties together Catalyst::Action::REST, Catalyst::Action::Serialize and Catalyst::Action::Deserialize. It should be suitable for most applications. You should be aware that it:
Configures the Serialization Actions This class provides a default configuration for Serialization. It is currently:



  __PACKAGE__->config(
      stash_key => rest,
      map       => {
         text/html          => YAML::HTML,
         text/xml           => XML::Simple,
         text/x-yaml        => YAML,
         application/json   => JSON,
         text/x-json        => JSON,
         text/x-data-dumper => [ Data::Serializer, Data::Dumper ],
         text/x-data-denter => [ Data::Serializer, Data::Denter ],
         text/x-data-taxi   => [ Data::Serializer, Data::Taxi   ],
         application/x-storable   => [ Data::Serializer, Storable ],
         application/x-freezethaw => [ Data::Serializer, FreezeThaw ],
         text/x-config-general    => [ Data::Serializer, Config::General ],
         text/x-php-serialization => [ Data::Serializer, PHP::Serialization ],
      },
  );



You can read the full set of options for this configuration block in Catalyst::Action::Serialize.

Sets a begin and end method for you The begin method uses Catalyst::Action::Deserialize. The end method uses Catalyst::Action::Serialize. If you want to override either behavior, simply implement your own begin and end actions and forward to another action with the Serialize and/or Deserialize action classes:



  package Foo::Controller::Monkey;
  use Moose;
  use namespace::autoclean;

  BEGIN { extends Catalyst::Controller::REST }

  sub begin : Private {
    my ($self, $c) = @_;
    ... do things before Deserializing ...
    $c->forward(deserialize);
    ... do things after Deserializing ...
  }

  sub deserialize : ActionClass(Deserialize) {}

  sub end :Private {
    my ($self, $c) = @_;
    ... do things before Serializing ...
    $c->forward(serialize);
    ... do things after Serializing ...
  }

  sub serialize : ActionClass(Serialize) {}



If you need to deserialize multipart requests (i.e. REST data in one part and file uploads in others) you can do so by using the Catalyst::Action::DeserializeMultiPart action class.

A MILD WARNING

I have code in production using Catalyst::Controller::REST. That said, it is still under development, and it’s possible that things may change between releases. I promise to not break things unnecessarily. :)

SEE ALSO

Catalyst::Action::REST, Catalyst::Action::Serialize, Catalyst::Action::Deserialize

For help with REST in general:

The HTTP 1.1 Spec is required reading. http://www.w3.org/Protocols/rfc2616/rfc2616.txt

Wikipedia! http://en.wikipedia.org/wiki/Representational_State_Transfer

The REST Wiki: http://rest.blueoxen.net/cgi-bin/wiki.pl?FrontPage

AUTHORS

See Catalyst::Action::REST for authors.

LICENSE

You may distribute this code under the same terms as Perl itself.
Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 CATALYST::CONTROLLER::REST (3) 2015-10-29

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.