lib/Sack/Client.pm

#!/usr/bin/perl

package Sack::Client;

use warnings;
use strict;

use IO::Socket::INET;
use IO::Select;
use Storable qw();

use lib '/srv/Sack/lib';
use Data::Dump qw(dump);
use Sack::View;

my $port = shift @ARGV;
my $debug = 0;

my $sock = IO::Socket::INET->new(
        PeerAddr => '127.0.0.1',
        PeerPort => $port,
        Proto => 'tcp',
) || die $!;

my $sel = IO::Select->new($sock);
$sel->add($sock);

my $data;

while (1) {
        for my $sock ($sel->can_read(1)) {
                my $request = eval { Storable::fd_retrieve($sock) };
                if ( $@ ) {
                        warn "[$port] FATAL: $@\n";
                        next;
                }
                warn "[$port] <<<< ", dump( keys %$request ), $/ if $debug;
                my $response = { port => $port };
                if ( $request->{ping} ) {
                        $response->{ping} = 'pong';
                } elsif ( $request->{load} ) {
                        $response->{load} = 'shard';
                } elsif ( defined $request->{shard} ) {
                        $data->{ $request->{path} } = $request->{shard};
                        $response->{load} = 'shard';
                        $response->{shard} = $request->{path};
                } elsif ( my $code = $request->{view} ) {
                        Sack::View->code( $code );
                        foreach my $path ( keys %$data ) {
                                warn "view $request->{path} on shard $path\n";
                                die "data->{$path} not array but ",dump( $data->{$path} ) unless ref $data->{$path} eq 'ARRAY';
                                Sack::View->on_shard( $data->{$path} );
                                push @{ $response->{on_shard} }, $path;
                        }
                        $response->{out} = Sack::View->out;
                } elsif ( defined $request->{debug} ) {
                        if ( my $eval = $request->{debug} ) {
                                warn "EVAL $eval ", dump( eval($eval) );
                        } else {
                                warn "XX data ", dump $data;
                        }
                } elsif ( $request->{clean} ) {
                        $data = {};
                } else {
                        $response->{error}->{unknown} = $request;
                }
                Storable::store_fd( $response, $sock );
                warn "[$port] >>>> ", dump($response), $/ if $debug;
        }
}
1	dpavlin	163	#!/usr/bin/perl
2
3	dpavlin	181	package Sack::Client;
4
5	dpavlin	163	use warnings;
6			use strict;
7
8			use IO::Socket::INET;
9			use IO::Select;
10			use Storable qw();
11	dpavlin	168
12			use lib '/srv/Sack/lib';
13	dpavlin	202	use Data::Dump qw(dump);
14	dpavlin	199	use Sack::View;
15	dpavlin	163
16			my $port = shift @ARGV;
17	dpavlin	228	my $debug = 0;
18	dpavlin	163
19			my $sock = IO::Socket::INET->new(
20			PeerAddr => '127.0.0.1',
21			PeerPort => $port,
22			Proto => 'tcp',
23			) \|\| die $!;
24
25			my $sel = IO::Select->new($sock);
26			$sel->add($sock);
27
28	dpavlin	192	my $data;
29
30	dpavlin	163	while (1) {
31			for my $sock ($sel->can_read(1)) {
32	dpavlin	225	my $request = eval { Storable::fd_retrieve($sock) };
33			if ( $@ ) {
34			warn "[$port] FATAL: $@\n";
35			next;
36			}
37	dpavlin	228	warn "[$port] <<<< ", dump( keys %$request ), $/ if $debug;
38	dpavlin	163	my $response = { port => $port };
39	dpavlin	192	if ( $request->{ping} ) {
40			$response->{ping} = 'pong';
41			} elsif ( $request->{load} ) {
42			$response->{load} = 'shard';
43			} elsif ( defined $request->{shard} ) {
44	dpavlin	199	$data->{ $request->{path} } = $request->{shard};
45	dpavlin	192	$response->{load} = 'shard';
46	dpavlin	199	$response->{shard} = $request->{path};
47			} elsif ( my $code = $request->{view} ) {
48			Sack::View->code( $code );
49			foreach my $path ( keys %$data ) {
50			warn "view $request->{path} on shard $path\n";
51			die "data->{$path} not array but ",dump( $data->{$path} ) unless ref $data->{$path} eq 'ARRAY';
52			Sack::View->on_shard( $data->{$path} );
53			push @{ $response->{on_shard} }, $path;
54			}
55			$response->{out} = Sack::View->out;
56			} elsif ( defined $request->{debug} ) {
57			if ( my $eval = $request->{debug} ) {
58			warn "EVAL $eval ", dump( eval($eval) );
59			} else {
60			warn "XX data ", dump $data;
61			}
62	dpavlin	203	} elsif ( $request->{clean} ) {
63			$data = {};
64	dpavlin	192	} else {
65			$response->{error}->{unknown} = $request;
66			}
67	dpavlin	163	Storable::store_fd( $response, $sock );
68	dpavlin	228	warn "[$port] >>>> ", dump($response), $/ if $debug;
69	dpavlin	163	}
70			}