Perl in the Internet of Things

PPeerrll iinn tthhee
IInntteerrnneett ooff
TThhiinnggss
Dave Cross
Magnum Solutions Ltd
dave@mag-sol.com

 9:10 (ish) – Part 1
 11:00 – Coffee
 11:30 – Part 2
 11:50 – End
LPW
Schedule
 Possibly cupcakes
8th November 2014 2

 Perl and the IoT
 Web Client Primer
 Web APIs with Dancer
 Introduction to REST
 REST APIs in Perl
LPW
What We Will Cover
8th November 2014 3

PPeerrll aanndd tthhee
IInntteerrnneett ooff
TThhiinnggss

 Things
 On the Internet
 Providing useful services
LPW
The Internet of Things
8th November 2014 5

LPW
The Internet of Things
8th November 2014 6

 Cutting edge interactions
 Latest technologies
 Modern languages
LPW
The Hype
 Scala
 Erlang
8th November 2014 7

 It's just HTTP
 Some event triggers action
 Thing makes an HTTP request
 Server sends response
 Thing does something
LPW
The Reality
 Usually
8th November 2014 8

 Any language works
 Perl just as effective as other languages
 Perl has a long history of writing HTTP
servers
 And HTTP clients
 Many useful modules
LPW
The Reality
 Of course
8th November 2014 9

 Your “thing” is an HTTP client
 But its interface will be unusual
 Limited input/output channels
 Hardware sensors
 Device::SerialPort
 Device::BCM2835
 Arduino workshop
LPW
Hardware
8th November 2014 10

 Your “thing” won't be displaying web pages
 So returning HTML is probably unhelpful
 Data-rich representation
LPW
HTTP Response
 JSON

WWeebb CClliieenntt
PPrriimmeerr

 We're used to writing web server
applications in Perl
 But we can write web clients too
 Programs that act like a browser
 Make an HTTP request
 Parse the HTTP reponse
 Take some action
LPW
Web Clients
 And we'll cover more about that later

 Most people would reach for LWP
 LWP is “libwww-perl”
 Library for writing web clients in Perl
 Powerful and flexible HTTP client
 Install from CPAN
LPW
LWP

 Small web client library for Perl
 Part of standard Perl installation
 Tiny is good for IoT
LPW
HTTP::Tiny
 Since Perl 5.14

 use HTTP::Tiny;
LPW
Using HTTP::Tiny
my $response =
HTTP::Tiny->new->get('http://example.com/');
die "Failed!n" unless $response->{success};
print "$response->{status} $response->{reason}n";
while (my ($k, $v) = each %{$response->{headers}}) {
for (ref $v eq 'ARRAY' ? @$v : $v) {
print "$k: $_n";
}
}
print $response->{content}
if length $response->{content};

 Create a new user agent object (“browser”)
with new()
 Various configuration options
 my $ua = HTTP::Tiny->new(%options);
LPW
HTTP::Tiny->new

 agent – user agent string
 cookie_jar – HTTP::CookieJar object
 default_headers – hashref
LPW
Options
 Or equivalent

 local_address
 keep_alive
 max_redirect
 max_size
 timeout
LPW
Low-Level Options
 Of response

 http_proxy
 https_proxy
 proxy
 no_proxy
 Environment variables
LPW
Proxy Options

 verify_SSL – default is false
 SSL_options – passed to IO::Socket::SSL
LPW
SSL Options

 Use the request() method
 $resp = $ua->request(
 Useful options
LPW
Making Requests
$method, $url, %options
);
 headers
 content

 Response is a hash
 success – true if status is 2xx
 url – URL that returned response
 status
 reason
 content
 headers
LPW
Responses
 Not an object

 Higher level functions for HTTP requests
 get
 head
 post
 put
 delete
LPW
Easier Requests

 Each is a shorthand way to call request()
 $resp = $ua->get($url, %options)
 $resp = $ua->request(
 Same options
 Same response hash
LPW
Easier Requests
'get', $url, %options
)

 $ua->request('post', $url,
 $ua->post($url, %options)
 Where do post parameters go?
 In %options
LPW
POSTing Data
%options)
 content key
 Build it yourself
 www_form_urlencode()

 $ua->post_form($url, $form_data)
 $form_data can be hash ref
 Or array ref
 Sort order
LPW
POSTing Data
 { key1 => 'value1', key2 => 'value2' }
 [ key1 => 'value1', key2 => 'value2' ]

 HTTP::Tiny::UA
 HTTP::Thin
 HTTP::Tiny::Mech
LPW
See Also
 Higher level UA features
 Wrapper adds HTTP::Request/HTTP::Response
compatibility
 WWW::Mechanize wrapper for HTTP::Tiny

WWeebb AAPPIIss WWiitthh
DDaanncceerr

LPW
8th November 2014
Dancer
 Dancer is a simple route-based web
framework for Perl
 Easy to get web application up and running
 See Andrew Solomon's class at 12:00
 We're actually going to be using Dancer2

LPW
8th November 2014
Simple API
 Return information about MP3s
 GET /mp3
 List MP3s
 GET /mp3/1
 Info about a single MP3

LPW
8th November 2014
Database
 CREATE TABLE mp3 (
id integer primary key,
title varchar(200),
artist varchar(200),
filename varchar(200)
);

LPW
8th November 2014
DBIx::Class
 $ dbicdump -o dump_directory=./lib
MP3::Schema dbi:SQLite:mp3.db
Dumping manual schema for MP3::Schema to
directory ./lib ...
Schema dump completed.
 $ find lib/
lib/
lib/MP3
lib/MP3/Schema.pm
lib/MP3/Schema
lib/MP3/Schema/Result
lib/MP3/Schema/Result/Mp3.pm

LPW
8th November 2014
Create Application
 $ dancer2 gen -a MP3
 + MP3
[ ... ]
+ MP3/config.yml
[ ... ]
+ MP3/lib
+ MP3/lib/MP3.pm
+ MP3/bin
+ MP3/bin/app.pl

LPW
8th November 2014
Run Application
 $ MP3/bin/app.pl
 >> Dancer2 v0.153002 server
6219 listening on
http://0.0.0.0:3000

LPW
8th November 2014
Run Application

LPW
8th November 2014
Implement Routes
 Our application doesn't do anything
 Need to implement routes
 Routes are defined in MP3/lib/MP3.pm
 get '/' => sub {
template 'index';
};

LPW
8th November 2014
/mp3 Route
 Display a list of MP3s
 Get them from the database
 Use Dancer2::Plugin::DBIC
 In config.yml
 Plugins:
DBIC:
default:
dsn: dbi:SQLite:dbname=mp3.db

LPW
8th November 2014
/mp3 Route
 In MP3/lib/MP3.pm
 get '/mp3' => sub {
my @mp3s = schema->resultset('Mp3')->all;
content_type 'text/plain';
return join "n",
map { $_->title . ' / ' . $_->artist }
@mp3s;
};

LPW
8th November 2014
/mp3 Route

LPW
8th November 2014
/mp3/:id Route
 Display details of one MP3
 Dancer gives us parameters from path
 $value = param($name)

LPW
8th November 2014
/mp3/:id Route
 get '/mp3/:id' => sub {
my $mp3 =
schema->resultset('Mp3')
->find(param('id'));
unless ($mp3) {
status 404;
return 'Not found';
}
content_type 'text/plain';
return $mp3->title . "n" .
$mp3->artist . "n" .
$mp3->filename;
};

LPW
8th November 2014
/mp3/:id Route

LPW
8th November 2014
Plain Text?
 Yes, plain text is bad
 Easy fix
 Serializer: JSON
 In config.yml
 Rewrite routes to return data structures
 Dancer serialises them as JSON

LPW
8th November 2014
Return Data
 get '/mp3' => sub {
my @mp3s = schema->
resultset('Mp3')->all;
return { mp3s => [
map { {
title => $_->title,
artist => $_->artist
} } @mp3s
] };
};

LPW
8th November 2014
Return Data
my $mp3 = schema->
resultset('Mp3')->find(param('id'));
unless ($mp3) {
status 404;
return 'Not found';
}
return {
title => $mp3->title,
artist => $mp3->artist,
filename => $mp3->filename,
};
};

LPW
8th November 2014
Return Data
my $mp3 = schema->
resultset('Mp3')->find(param('id'));
unless ($mp3) {
status 404;
return 'Not found';
}
return { $mp3->get_columns };
};

LPW
8th November 2014
URLs
 It's good practice to return URLs when you
can
 Easier for clients to browse our data
 We can do that for our list

LPW
8th November 2014
URLs
 get '/mp3' => sub {
my @mp3s = schema->resultset('Mp3')->all;
my $url = uri_for('/mp3') . '/';
return { mp3s => [
map { {
title => $_->title,
artist => $_->artist,
url => $url . $_->id,
} } @mp3s
] };
};

LPW
8th November 2014
URLs
 $ GET http://localhost:3000/mp3
 {"mp3s":[
{
"url":"http://localhost:3000/mp3/1",
"title":"Royals","artist":"Lorde"
},
{
"artist":"Chvrches","title":"The Mother We Share"
},
{
"artist":"Haim","title":"Falling"
}
]}

LPW
8th November 2014
More on URLs
 Currently our system has only one resource
 mp3
 It's usual to have links to other resources
 MP3s have artists
 Link to other resources using URLs
 Make it easier for clients to walk our data
model

LPW
8th November 2014
More on URLs
 In our MP3 JSON we have this
 “artist”:”Lorde”
 It would be better to have
 “artist_name”:”Lorde”
“artist_url”:”http://localhost:3000/artist/1”
 Perhaps add a url() method to all of our
objects

LPW
8th November 2014
Other GET Actions
 Getting lists of objects is easy
 Other things to consider
 Searching
 Sorting
 Paging
 Filtering
 CGI Parameters to DBIC to SQL to JSON

LPW
8th November 2014
Other Actions
 We will want to to other things to our data
 Add objects
 Update objects
 Delete objects
 CRUD operations

LPW
8th November 2014
Other Actions
 Use HTTP methods
 POST /mp3
 Create
 GET /mp3/:id
 Read
 PUT /mp3/:id
 Update
 DELETE /mp3/:id
 Delete

LPW
8th November 2014
Other Actions
 Easy to write Dancer handlers for these
 delete '/mp3/:id' => sub {
schema->resultset('Mp3')->
find(param('id'))->
delete;
}
 But it can be hard to get right
 What should we return here?
 Is there a better way?

 Representational State Transfer
 Abstraction of web architecture
 Dissertation by Roy Fielding, 2000
 Particularly applicable to web services
LPW
REST

 Base URI for service
 Defined media type
 HTTP methods for interaction
 Hypertext links for resources
 Hypertext links for related resources
LPW
RESTful Web Services

RESTful vs Non-RESTful
 Good test
 Which HTTP methods does it use?
 Web services often use only GET and POST
 GET /delete/mp3/1
 GET /mp3/1/delete
 Not RESTful
 DELETE /mp3/1
 Might be RESTful
LPW

 Dancer has a REST plugin
 Dancer2::Plugin::REST
 Makes our live much easier
LPW
RESTful Dancer

 Does three things for us
 Creates routes
 Utility functions for return values
 Returns data in different formats
LPW
Dancer2::Plugin::REST

 resource mp3 =>
LPW
Creates Routes
get => sub { ... },
create => sub { ... },
delete => sub { ... },
update => sub { ... };

 post '/mp3'
 get '/mp3/:id'
 put '/mp3/:id'
 delete '/mp3/:id'
LPW
CRUD Routes
 Create
 Read
 Update
 Delete

 resource mp3 =>
LPW
Creates Routes
get => sub {
my $mp3 =
schema->resultset('Mp3')->
find(params->{id});
if ($mp3) {
status_ok( { $mp3->get_columns } );
} else {
status_not_found('MP3 Not Found');
}
};

 Note: Still have to create main listing route
 /mp3
LPW
Creates Routes

 Simple status_* functions for return
values
 status_ok(%resource)
 status_not_found($message)
 status_created(%new_resource)
LPW
Utility Functions

 Allow user to choose data format
 By changing the URL
 get '/mp3/:id'
 get '/mp3:id.:format'
 YAML, JSON, Data::Dumper support built-in
LPW
Format Options

Format Options - JSON
 $ GET http://localhost:3000/mp3/1.json
 {"id":1,"filename":"music/lorde/pure-heroine/
LPW
royals.mp3","title":"Royals","ar
tist":"Lorde"}

 $ GET http://localhost:3000/mp3/1.yml
 ---
artist: Lorde
filename: music/lorde/pure-heroine/
LPW
Format Options -YAML
royals.mp3
id: 1
title: Royals

 $ GET http://localhost:3000/mp3/1.dump
 $VAR1 = {
LPW
Format Options -YAML
'filename' => 'music/lorde/pure-heroine/
royals.mp3',
'title' => 'Royals',
'artist' => 'Lorde',
'id' => 1
};

 Dancer and Dancer2::Plugin::REST make
simple REST easy
 But full REST support is more complex
 Here's a REST state machine
LPW
More Complex REST
 Other frameworks do the same

LPW
Read a Good Book

 There's a lot to think about when getting
REST right
 Can CPAN help?
 Web::Machine
 WebAPI::DBIC
LPW
CPAN to the Rescue

 Perl port of Erlang webmachine
 You write subclasses of
Web::Machine::Resource
 Override methods where necessary
 See Stevan Little's YAPC::NA 2012 talk
LPW
Web::Machine
 With bits stolen from Ruby and Javascript
versions too

 use Web::Machine;
LPW
Example
{
package WasteOfTime::Resource;
use parent 'Web::Machine::Resource';
use JSON::XS qw(encode_json);
sub content_types_provided {
[{ 'application/json' => 'to_json' }]
}
sub to_json {
encode_json({ time => scalar localtime })
}
}
Web::Machine->new(
resource => 'WasteOfTime::Resource'
)->to_app;

 $ plackup time.psgi
 $ curl -v http://0:5000
LPW
Example
HTTP::Server::PSGI: Accepting connections at
http://0:5000/
[ ... ]
< HTTP/1.0 200 OK
< Date: Sat, 08 Nov 2014 11:34:02 GMT
< Server: HTTP::Server::PSGI
< Content-Length: 35
< Content-Type: application/json
<
* Closing connection #0
{"time":"Sat Nov 8 11:34:02 2014"}

 $ curl -v http://0:5000 -H'Accept: text/html'
LPW
Example
[ ... ]
< HTTP/1.0 406 Not Acceptable
< Date: Sat, 08 Nov 2014 11:34:02 GMT
<
Not Acceptable

 sub content_types_provided { [
LPW
Example
{ 'application/json' => 'to_json' },
{ 'text/html' => 'to_html' },
] }

LPW
Example
] }

 sub to_html {
LPW
Example
] }
my $time = localtime;
return “<html>
<head><title>The Time Now Is:</title></head>
<body>
<h1>$time</h1>
</body>
</html>”;
}

 $ curl -v http://0:5000 -H'Accept: text/html'
LPW
Example
[ ... ]
< HTTP/1.0 200 OK
< Date: Sun, 09 Dec 2012 02:26:39 GMT
< Vary: Accept
< Content-Type: text/html
<
<html><head><title>The Time Now
Is:</title></head><body><h1>Sat Nov 8 11:34:02
2014</h1></body></html>

 “WebAPI::DBIC provides the parts you need
to build a feature-rich RESTful JSON web
service API backed by DBIx::Class
schemas.”
 REST API in a box
LPW
WebAPI::DBIC

 Built on top of Web::Machine
 And Path::Router
 And Plack
 Uses JSON+HAL
LPW
WebAPI::DBIC
 Hypertext Application Language

 $ git clone https://github.com/timbunce/WebAPI-DBIC.
 $ cd WebAPI-DBIC
 $ cpanm Module::CPANfile
 $ cpanm --installdeps . # wait ...
 $ export WEBAPI_DBIC_SCHEMA=DummyLoadedSchema
 $ plackup -Ilib -It/lib webapi-dbic-any.psgi
 ... open a web browser on port 5000 to
browse the API
LPW
Try It Out
git

Try It Out (Your Schema)
 $ export WEBAPI_DBIC_SCHEMA=Foo::Bar
 $ export WEBAPI_DBIC_HTTP_AUTH_TYPE=none
 $ export DBI_DSN=dbi:Driver:...
 $ export DBI_USER=...
 $ export DBI_PASS=...
 $ plackup -Ilib webapi-dbic-any.psgi
 ... open a web browser on port 5000 to
browse the API
LPW

 Perl is great for the Internet of Things
 Perl is great for text processing
 Perl is great for network processing
 IoT apps are often mainly HTTP transactions
LPW
Conclusion
 And Perl is good at those

 Perl Training
 Central London
 Next week
 Intermediate Perl
 Advanced Perl
 See advert in brochure
LPW
Sponsor's Message
 11/12 Nov
 13/14 Nov

TThhaatt''ss AAllll FFoollkkss
• Any Questions?

Perl in the Internet of Things

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (14)

Similar to Perl in the Internet of Things

Similar to Perl in the Internet of Things (20)

More from Dave Cross

More from Dave Cross (20)

Recently uploaded

Recently uploaded (20)

Perl in the Internet of Things