lib/Frey/CouchAPI.pm

package Frey::CouchAPI;

=head1 DESCRIPTION

This is REST wrapper using following L<Mojo> implement Apache's CouchDB API


L<Mojo::URL>

L<Mojo::Transaction>


=head1 Supported HTTP API

=cut

use warnings;
use strict;

use JSON;
use Data::Dump qw/dump/;
use URI::Escape;
use File::Path qw(make_path remove_tree);
use Storable;

our $VERSION = '0.2';
$VERSION .= " (Frey $Frey::VERSION)" if $Frey::VERSION;

our $debug = $Frey::debug || 0;

sub rewrite_urls {
        my ( $self, $tx ) = @_;
        if ( $tx->req->url->path =~ m{/_utils/} ) {
                my $path = $tx->req->url->path;
                $path =~ s{(/_utils)/?$}{$1/index.html}; # poor man's DirectoryIndex
                $path =~  s{/_utils}{/static/futon};
                $tx->req->url->path( $path );
                my $url = $tx->req->url->to_string;
                my $old = $url;
                $url = $tx->req->url->to_string;
                warn "# rewrite $old -> $url\n";
        }
}

our $config = {
        path => '/data/webpac2/var/row',
};

my $p = $config->{path};
my @all_dbs = map {
        s{^\Q$p\E/*}{};
        $_;
} glob "$p/*/*";

my $regex_dbs = '[a-z][a-z0-9_\$\(\)\+\-/]+';

our $json = {};
our $status;

sub ok {
        $json = { ok => JSON::true };
        $status = 200;
        warn "ok from ",join(' ',caller),$/;
}

sub file_rev { (stat($_[0]))[9] } # mtime

sub dispatch {
        my ($self,$tx) = @_;

        $status = 500; # Internal Error

        my $url = $tx->req->url->to_string;
        $url = uri_unescape( $url );
        my $method = $tx->req->method;
        my $path = $config->{path};
        
        if ( $url eq '/' ) {
                $json = {
                        couchdb => "Welcome",
                        version => "CouchAPI $VERSION",
                };
                $status = 200;
        } elsif ( $url eq '/_all_dbs' ) {
                $json = [ @all_dbs ];
                $status = 200;
        } elsif ( $url =~ m{^/_config/?(.+)} ) {

                $json = { CouchAPI => $config };

                if ( $method eq 'PUT' ) {

                        my $part = $1;
                        warn "## part $part";

                        $part =~ s!^!->{'!;
                        $part =~ s!/!'}->{'!;
                        $part =~ s/$/'}/;

                        my $data = $tx->req->content->file->slurp;
                        $data = JSON->new->allow_nonref->decode( $data );
                        warn "## data ",dump( $data );
                        # poor man's transaction :-)
                        my $code = "\$json$part = \$data; \$config$part = \$data;";
                        eval $code;
                        if ( $@ ) {
                                warn "ERROR: $code -> $@";
                                $status = 500;
                        } else {
                                $status = 200;
                        }

warn "json ",dump( $json ), " config ", dump( $config );

                } elsif ( $method eq 'GET' ) {
                        $status = 200;
                } else {
                        $status = 501;
                }

=head2 Database

L<http://wiki.apache.org/couchdb/HTTP_database_API> except compaction

=cut

        } elsif (
                   $url =~ m{($regex_dbs)/$}
                # DELETE doesn't have trailing slash
                || $method eq 'DELETE' && $url =~ m{($regex_dbs)$}
        ) {

                my $database = $1;

                my $dir = "$path/$database";

                if ( $method eq 'GET' ) {
                        $json = database_get( $database );
                } elsif ( $method eq 'DELETE' ) {
                        if ( ! -e $dir ) {
                                $status = 404;
                        } else {
                                remove_tree($dir);
                                if ( ! -d $dir ) {
                                        ok;
                                } else {
                                        $status = 500;
                                }
                        }
                } elsif ( $method eq 'PUT' ) {
                        if ( -e $dir ) {
                                $status = 412;
                        } else {
                                make_path($dir);
                                if ( -e $path ) {
                                        ok;
                                        $status = 201;
                                } else {
                                        $status = 500;
                                }
                        }
                }

                warn "## database $database $status ",dump( $json );

        } elsif ( $url =~ m{($regex_dbs)/([^?]+)\??(.+)?$} ) {
                my ($database,$id,$args) = ($1,$2,$3);

=head2 Document

L<http://wiki.apache.org/couchdb/HTTP_Document_API>

=cut

                my $arg;
                if ( $args ) {
                        foreach my $a ( split(/[&;]/,$args) ) {
                                my ($n,$v) = split(/=/,$a);
                                $v =~ s{(["'])(.+)\1}{$2};
                                $arg->{$n} = $v;
                        }
                }

                warn "ERROR: path $path doesn't exist\n" unless -e $path;

                my $p = "$path/$database/$id";
                warn "## database: $database id: $id -> $p ", dump( $arg ),"\n";


                if ( $id =~ m{_all_docs(\w*)$} ) {

                        my $by = $1;
                        my $offset = 0;
                        my $startkey = delete $arg->{startkey};
                        my $endkey   = delete $arg->{endkey};
                        my $limit    = delete $arg->{limit};
                        my $total_rows = 0;

                        my @docs = grep { length $_ } map {

                                if ( $limit > 0 && $total_rows == $limit ) {
                                        '';
                                } else {
        
                                        s{^$path/$database/}{};

                                        if ( defined $endkey && $_ gt $endkey ) {
                                                '';
                                        } elsif ( $startkey ) {
                                                if ( $_ ge $startkey ) {
                                                        $total_rows++;
                                                        $_;
                                                } else {
                                                        $offset++;
                                                        '';
                                                }
                                        } else {
                                                $total_rows++;
                                                $_;
                                        }
                                }

                        } glob( "$path/$database/*" );


                        warn "## docs $startkey -> $endkey limit $limit ", dump( @docs ); # if $debug;

                        $json = {
                                total_rows =>  $total_rows,
                                offset => $offset,
                                rows => [],
                        };

                        my $rows;
                        my @ids;

                        foreach my $id ( @docs ) {
                                warn "++ $id\n" if $debug;
                                my $p = "$path/$database/$id";
                                my $data = eval { Storable::retrieve( $p ) };
                                if ( $@ ) {
                                        warn "ERROR: $p | $@\n";
                                        next;
                                }
                                push @ids, $id;
                                $rows->{$id} = {
                                        id => $id,
                                        key => $id,
                                        value => {
                                                rev => file_rev $p,
                                        }
                                };
                        }

                        my $descending = delete $arg->{descending};
                        my @sorted = sort @ids;

                        warn "creating rows in ", $descending ? "descending" : "", " order\n";

                        foreach my $id ( $descending ? reverse @sorted : @sorted ) {
                                warn ">> $id ", $descending ? 'desc' : 'asc', "\n" if $debug;
                                push @{ $json->{rows} }, $rows->{$id};
                        }

                        $status = 200;

                } elsif ( $method eq 'PUT' ) {
        
                        warn "## ",dump( $tx->req ) if $debug;

                        my $data = $tx->req->content->file->slurp;

                        my $db_path = "$path/$database";
                        make_path $db_path unless -e $db_path;

                        Storable::store( from_json($data), $p );
                        my $rev = file_rev $p;
                        warn "store $p $rev size ", -s $p, " bytes | $data\n";

                        $status = 201; # Created
                        $json = {
                                id => $id,
                                ok => JSON::true,
                                rev => $rev,
                        };

                } elsif ( $method eq 'GET' ) {
                        if ( ! -e $p ) {
                                $status = 404;
                        } else {
                                warn "retrive $p ", -s $p, " bytes\n";
                                $json = Storable::retrieve( $p );
                                if ( delete $arg->{revs_info} ) {
                                        my $rev = file_rev $p;
                                        $json->{_rev} = $rev;
                                        $json->{_revs_info} = [
                                                { rev => $rev, status => 'available' }
                                        ];
                                }
                                $status = 200;

                        }
                } elsif ( $method eq 'DELETE' ) {
                        if ( -e $p ) {
                                unlink $p && ok || { $status = 500 };
                        } else {
                                $status = 404;
                        }
                } elsif ( $method eq 'POST' ) {
                        $json = { total_rows => 0, offset => 0 };
                        $status = 202; # FIXME implement real view server and return 200
                } else {
                        $status = 501;
                }

                if ( keys %$arg ) {
                        warn "WARNING: arg left from $url = ",dump( $arg ),$/;
                        $status = 501;
                }

        }

        $json = { error => 'not_found', reason => 'Missing' } if $status == 404;

        if ( $method =~ m{(DELETE|PUT)} ) {
                $tx->res->headers->add_line( 'Location' => $tx->req->url->to_abs );
        }

        $tx->res->code( $status );
        $tx->res->headers->content_type( 'text/plain;charset=utf-8' );
        my $body = to_json $json;
        $tx->res->body( $body );
        $tx->res->headers->add_line( 'Cache-Control' => 'must-revalidate' );
        $tx->res->headers->add_line( 'Server' => "Frey::CouchAPI/$VERSION" );

        print "$method $url $status\n$body\n";

        warn "## headers ", $tx->res->headers->to_string;

        return $tx;

}

sub database_get {
        my ($db_name) = @_;
        my $path = $config->{path};
        warn "# collecting docs from $path/$db_name/*\n";
        my @docs = glob "$path/$db_name/*";
        my $json = {
                db_name => $db_name,
                doc_count => $#docs + 1,
                doc_del_count => 0,
                update_seq => 0,
                purge_seq => 0,
                capacity_running => JSON::false,
                disk_size => 0,
                instance_start_time => time(),
        };

        warn "## calculating disk_size\n";
        $json->{disk_size} += -s $_ foreach @docs;
        $status = 200;
        return $json;
}

1;
__END__

=head1 SEE ALSO

L<http://wiki.apache.org/couchdb/Reference>

1	dpavlin	1046	package Frey::CouchAPI;
2
3	dpavlin	1051	=head1 DESCRIPTION
4
5	dpavlin	1052	This is REST wrapper using following L<Mojo> implement Apache's CouchDB API
6	dpavlin	1051
7	dpavlin	1052
8			L<Mojo::URL>
9
10			L<Mojo::Transaction>
11
12
13	dpavlin	1051	=head1 Supported HTTP API
14
15			=cut
16
17	dpavlin	1049	use warnings;
18			use strict;
19
20	dpavlin	1046	use JSON;
21			use Data::Dump qw/dump/;
22			use URI::Escape;
23	dpavlin	1047	use File::Path qw(make_path remove_tree);
24			use Storable;
25	dpavlin	1046
26	dpavlin	1053	our $VERSION = '0.2';
27			$VERSION .= " (Frey $Frey::VERSION)" if $Frey::VERSION;
28	dpavlin	1049
29			our $debug = $Frey::debug \|\| 0;
30
31	dpavlin	1046	sub rewrite_urls {
32			my ( $self, $tx ) = @_;
33			if ( $tx->req->url->path =~ m{/_utils/} ) {
34			my $path = $tx->req->url->path;
35			$path =~ s{(/_utils)/?$}{$1/index.html}; # poor man's DirectoryIndex
36			$path =~ s{/_utils}{/static/futon};
37			$tx->req->url->path( $path );
38			my $url = $tx->req->url->to_string;
39			my $old = $url;
40			$url = $tx->req->url->to_string;
41			warn "# rewrite $old -> $url\n";
42			}
43			}
44
45	dpavlin	1050	our $config = {
46			path => '/data/webpac2/var/row',
47			};
48
49			my $p = $config->{path};
50	dpavlin	1046	my @all_dbs = map {
51	dpavlin	1050	s{^\Q$p\E/*}{};
52	dpavlin	1046	$_;
53	dpavlin	1050	} glob "$p//";
54	dpavlin	1046
55	dpavlin	1047	my $regex_dbs = '[a-z][a-z0-9_\$\(\)\+\-/]+';
56	dpavlin	1046
57	dpavlin	1047	our $json = {};
58	dpavlin	1052	our $status;
59	dpavlin	1047
60			sub ok {
61			$json = { ok => JSON::true };
62			$status = 200;
63	dpavlin	1054	warn "ok from ",join(' ',caller),$/;
64	dpavlin	1047	}
65
66	dpavlin	1054	sub file_rev { (stat($_[0]))[9] } # mtime
67	dpavlin	1050
68	dpavlin	1046	sub dispatch {
69			my ($self,$tx) = @_;
70
71	dpavlin	1052	$status = 500; # Internal Error
72
73	dpavlin	1046	my $url = $tx->req->url->to_string;
74			$url = uri_unescape( $url );
75	dpavlin	1047	my $method = $tx->req->method;
76	dpavlin	1054	my $path = $config->{path};
77	dpavlin	1050
78	dpavlin	1046	if ( $url eq '/' ) {
79			$json = {
80	dpavlin	1047	couchdb => "Welcome",
81	dpavlin	1050	version => "CouchAPI $VERSION",
82	dpavlin	1052	};
83			$status = 200;
84	dpavlin	1046	} elsif ( $url eq '/_all_dbs' ) {
85			$json = [ @all_dbs ];
86	dpavlin	1047	$status = 200;
87	dpavlin	1050	} elsif ( $url =~ m{^/_config/?(.+)} ) {
88
89			$json = { CouchAPI => $config };
90
91			if ( $method eq 'PUT' ) {
92
93			my $part = $1;
94			warn "## part $part";
95
96			$part =~ s!^!->{'!;
97			$part =~ s!/!'}->{'!;
98			$part =~ s/$/'}/;
99
100			my $data = $tx->req->content->file->slurp;
101			$data = JSON->new->allow_nonref->decode( $data );
102			warn "## data ",dump( $data );
103			# poor man's transaction :-)
104			my $code = "\$json$part = \$data; \$config$part = \$data;";
105			eval $code;
106			if ( $@ ) {
107			warn "ERROR: $code -> $@";
108			$status = 500;
109			} else {
110			$status = 200;
111	dpavlin	1049	}
112	dpavlin	1050
113			warn "json ",dump( $json ), " config ", dump( $config );
114
115			} elsif ( $method eq 'GET' ) {
116			$status = 200;
117			} else {
118			$status = 501;
119			}
120
121	dpavlin	1051	=head2 Database
122
123			L<http://wiki.apache.org/couchdb/HTTP_database_API> except compaction
124
125			=cut
126
127	dpavlin	1059	} elsif (
128			$url =~ m{($regex_dbs)/$}
129			# DELETE doesn't have trailing slash
130			\|\| $method eq 'DELETE' && $url =~ m{($regex_dbs)$}
131			) {
132
133	dpavlin	1047	my $database = $1;
134
135	dpavlin	1054	my $dir = "$path/$database";
136
137	dpavlin	1047	if ( $method eq 'GET' ) {
138			$json = database_get( $database );
139			} elsif ( $method eq 'DELETE' ) {
140			if ( ! -e $dir ) {
141			$status = 404;
142			} else {
143	dpavlin	1054	remove_tree($dir);
144			if ( ! -d $dir ) {
145			ok;
146			} else {
147			$status = 500;
148			}
149	dpavlin	1047	}
150			} elsif ( $method eq 'PUT' ) {
151	dpavlin	1054	if ( -e $dir ) {
152			$status = 412;
153	dpavlin	1047	} else {
154	dpavlin	1054	make_path($dir);
155			if ( -e $path ) {
156			ok;
157			$status = 201;
158			} else {
159			$status = 500;
160			}
161	dpavlin	1047	}
162			}
163
164	dpavlin	1059	warn "## database $database $status ",dump( $json );
165
166	dpavlin	1049	} elsif ( $url =~ m{($regex_dbs)/([^?]+)\??(.+)?$} ) {
167			my ($database,$id,$args) = ($1,$2,$3);
168
169	dpavlin	1051	=head2 Document
170
171			L<http://wiki.apache.org/couchdb/HTTP_Document_API>
172
173			=cut
174
175	dpavlin	1049	my $arg;
176			if ( $args ) {
177			foreach my $a ( split(/[&;]/,$args) ) {
178			my ($n,$v) = split(/=/,$a);
179			$v =~ s{(["'])(.+)\1}{$2};
180			$arg->{$n} = $v;
181			}
182			}
183	dpavlin	1050
184			warn "ERROR: path $path doesn't exist\n" unless -e $path;
185
186	dpavlin	1047	my $p = "$path/$database/$id";
187	dpavlin	1051	warn "## database: $database id: $id -> $p ", dump( $arg ),"\n";
188	dpavlin	1047
189
190	dpavlin	1057	if ( $id =~ m{_all_docs(\w*)$} ) {
191	dpavlin	1049
192			my $by = $1;
193			my $offset = 0;
194			my $startkey = delete $arg->{startkey};
195	dpavlin	1051	my $endkey = delete $arg->{endkey};
196			my $limit = delete $arg->{limit};
197	dpavlin	1049	my $total_rows = 0;
198
199			my @docs = grep { length $_ } map {
200	dpavlin	1057
201			if ( $limit > 0 && $total_rows == $limit ) {
202			'';
203			} else {
204	dpavlin	1051
205	dpavlin	1057	s{^$path/$database/}{};
206	dpavlin	1051
207	dpavlin	1057	if ( defined $endkey && $_ gt $endkey ) {
208			'';
209			} elsif ( $startkey ) {
210			if ( $_ ge $startkey ) {
211			$total_rows++;
212			$_;
213			} else {
214			$offset++;
215			'';
216			}
217			} else {
218	dpavlin	1049	$total_rows++;
219			$_;
220			}
221			}
222	dpavlin	1051
223	dpavlin	1047	} glob( "$path/$database/*" );
224
225	dpavlin	1057
226	dpavlin	1051	warn "## docs $startkey -> $endkey limit $limit ", dump( @docs ); # if $debug;
227	dpavlin	1047
228			$json = {
229	dpavlin	1049	total_rows => $total_rows,
230			offset => $offset,
231	dpavlin	1047	rows => [],
232			};
233
234	dpavlin	1049	my $rows;
235			my @ids;
236
237	dpavlin	1047	foreach my $id ( @docs ) {
238	dpavlin	1049	warn "++ $id\n" if $debug;
239	dpavlin	1047	my $p = "$path/$database/$id";
240	dpavlin	1049	my $data = eval { Storable::retrieve( $p ) };
241			if ( $@ ) {
242			warn "ERROR: $p \| $@\n";
243			next;
244			}
245			push @ids, $id;
246			$rows->{$id} = {
247	dpavlin	1047	id => $id,
248			key => $id,
249			value => {
250	dpavlin	1054	rev => file_rev $p,
251	dpavlin	1047	}
252			};
253			}
254
255	dpavlin	1049	my $descending = delete $arg->{descending};
256			my @sorted = sort @ids;
257
258	dpavlin	1050	warn "creating rows in ", $descending ? "descending" : "", " order\n";
259
260	dpavlin	1049	foreach my $id ( $descending ? reverse @sorted : @sorted ) {
261	dpavlin	1050	warn ">> $id ", $descending ? 'desc' : 'asc', "\n" if $debug;
262	dpavlin	1049	push @{ $json->{rows} }, $rows->{$id};
263			}
264
265	dpavlin	1057	$status = 200;
266
267	dpavlin	1047	} elsif ( $method eq 'PUT' ) {
268
269	dpavlin	1059	warn "## ",dump( $tx->req ) if $debug;
270	dpavlin	1047
271			my $data = $tx->req->content->file->slurp;
272
273	dpavlin	1059	my $db_path = "$path/$database";
274			make_path $db_path unless -e $db_path;
275
276	dpavlin	1047	Storable::store( from_json($data), $p );
277	dpavlin	1054	my $rev = file_rev $p;
278			warn "store $p $rev size ", -s $p, " bytes \| $data\n";
279
280	dpavlin	1052	$status = 201; # Created
281	dpavlin	1054	$json = {
282			id => $id,
283			ok => JSON::true,
284			rev => $rev,
285			};
286
287	dpavlin	1047	} elsif ( $method eq 'GET' ) {
288	dpavlin	1049	if ( ! -e $p ) {
289			$status = 404;
290			} else {
291			warn "retrive $p ", -s $p, " bytes\n";
292			$json = Storable::retrieve( $p );
293	dpavlin	1055	if ( delete $arg->{revs_info} ) {
294			my $rev = file_rev $p;
295			$json->{_rev} = $rev;
296			$json->{_revs_info} = [
297			{ rev => $rev, status => 'available' }
298			];
299			}
300			$status = 200;
301
302	dpavlin	1049	}
303			} elsif ( $method eq 'DELETE' ) {
304			if ( -e $p ) {
305	dpavlin	1054	unlink $p && ok \|\| { $status = 500 };
306	dpavlin	1049	} else {
307			$status = 404;
308			}
309	dpavlin	1056	} elsif ( $method eq 'POST' ) {
310			$json = { total_rows => 0, offset => 0 };
311			$status = 202; # FIXME implement real view server and return 200
312	dpavlin	1047	} else {
313			$status = 501;
314			}
315
316	dpavlin	1059	if ( keys %$arg ) {
317			warn "WARNING: arg left from $url = ",dump( $arg ),$/;
318			$status = 501;
319			}
320	dpavlin	1049
321	dpavlin	1046	}
322
323	dpavlin	1052	$json = { error => 'not_found', reason => 'Missing' } if $status == 404;
324
325			if ( $method =~ m{(DELETE\|PUT)} ) {
326			$tx->res->headers->add_line( 'Location' => $tx->req->url->to_abs );
327	dpavlin	1047	}
328
329			$tx->res->code( $status );
330	dpavlin	1053	$tx->res->headers->content_type( 'text/plain;charset=utf-8' );
331	dpavlin	1047	my $body = to_json $json;
332			$tx->res->body( $body );
333	dpavlin	1053	$tx->res->headers->add_line( 'Cache-Control' => 'must-revalidate' );
334			$tx->res->headers->add_line( 'Server' => "Frey::CouchAPI/$VERSION" );
335	dpavlin	1052
336	dpavlin	1054	print "$method $url $status\n$body\n";
337	dpavlin	1053
338	dpavlin	1052	warn "## headers ", $tx->res->headers->to_string;
339
340	dpavlin	1046	return $tx;
341
342			}
343
344	dpavlin	1047	sub database_get {
345			my ($db_name) = @_;
346	dpavlin	1050	my $path = $config->{path};
347	dpavlin	1047	warn "# collecting docs from $path/$db_name/*\n";
348			my @docs = glob "$path/$db_name/*";
349			my $json = {
350			db_name => $db_name,
351			doc_count => $#docs + 1,
352			doc_del_count => 0,
353			update_seq => 0,
354			purge_seq => 0,
355			capacity_running => JSON::false,
356			disk_size => 0,
357			instance_start_time => time(),
358			};
359
360			warn "## calculating disk_size\n";
361	dpavlin	1049	$json->{disk_size} += -s $_ foreach @docs;
362	dpavlin	1047	$status = 200;
363			return $json;
364			}
365
366	dpavlin	1046	1;
367	dpavlin	1051	__END__
368
369			=head1 SEE ALSO
370
371			L<http://wiki.apache.org/couchdb/Reference>
372