POE/Component/LookupService.pm

## ------------------------------------------------------------------------
##  $Id: WebCache.pm,v 1.3 2003/06/25 23:37:04 joko Exp $
## ------------------------------------------------------------------------
##  $Log: WebCache.pm,v $
## ------------------------------------------------------------------------


package POE::Component::LookupService;

use strict;
use warnings;

use POE qw( Component::RPCXML::Server Component::StorageAgent Component::ServiceRegistrar );
use RPC::XML;
use Data::Dumper;


sub new {
  my $classname = shift;
  my @args = @_;
  
  my $self = {};
  bless $self, $classname;

  $self->{options} = { @args };

  #my $event_handler = lookupd->new();
  POE::Session->create( 
    object_states => [
      $self => [qw( _start _stop boot_intercom boot_storage boot_registrar handle_request send_response )]
    ]
  );

}

# This is not a POE method. It's a plain OO one.
sub debug {
  my $self = shift;
  my $msg = shift;
  $msg ||= '';
  print STDERR __PACKAGE__ . ": " . $msg, "\n";
}

# Controller's event handlers

sub _start {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("_start");
  
  #$kernel->alias_set("controller");

  #$kernel->post( controller => 'start_daemon' );
  $kernel->yield( 'boot_storage' );
  $kernel->yield( 'boot_registrar' );
  $kernel->yield( 'boot_intercom' );
  #$_[HEAP]->{subsession} = POE::Session->create( inline_states => { _start => sub { print "WORKER!", "\n"; } } );
  #$_[HEAP]->{subsession}->yield(

};

sub _stop {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("_stop");
};

sub boot_intercom {

  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("boot_intercom");

  # Server component - encapsulates some session(s) and/or wheel(s)?
  
  # V1 - windy?!
  # - dies on empty payloads
  # - requires addressing of "session"-parameter inside url (security flaw?)
  # + method publishing/rescinding
  #POE::Component::Server::XMLRPC->new( alias => "xmlrpc", port  => 3332 );
  
  # V2 - seems to be times more robust! i.e. offers these features:
  #  + doesn't die on empty xml-payloads in request
  #  + doesn't require session addressing through url
  #  + more flexible event dispatching
  #  - no remote method publishing and/or rescinding
  #  + doesn't even call the dispatching method on empty payloads! ("method-missing", etc.)
  POE::Component::RPCXML::Server->new(
    'Alias' => 'rpcxml-server',
    'Port'  => $self->{options}->{daemon}->{port},
    'DispatchEvent' => 'handle_request',
    'Debug' => 0,
  );

  # V3 - IKC
  # Don't do that here! It doesn't work!
  #use POE::Component::IKC::Server;
  #create_ikc_server( port => 30, name => 'LookupService' );

};

sub boot_storage {

  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("boot_storage");
  
  #print Dumper($self->{options}->{storage});
  $heap->{db} = POE::Component::StorageAgent->new( $self->{options}->{storage} );
  
}

sub boot_registrar {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("boot_registrar");
  $heap->{reg} = POE::Component::ServiceRegistrar->new();
}

sub handle_request {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];

  my $request = $_[ARG0];
  my $wheel = $_[ARG1];
  
  #print Dumper($request);
  $self->debug("handle_request: method='$request->{name}'");

  #my $payload = {};
  
  my $method = $request->{name};
  if ($method eq 'ServiceRegistrar.register') {
    #$payload->{msg} = 'Registration running';
    my $authenticated = 1;
    if ($authenticated) {
      # send response back to client
      #my $response = RPC::XML::response->new($payload);
      $kernel->yield( send_response => $wheel => 'ok' );
      
      # handle registration
      my $query = {
        'abc' => 'def',
      };
      $kernel->post( storage => 'query' => $query );
    }
  } elsif ($method eq 'ServiceRegistrar.list') {
  } elsif ($method eq 'Lease.renew') {
  } elsif ($method eq 'system.shutdown') {
    exit;
    #$kernel->signal( 'TERM' );
  } elsif ($method eq 'storage.deploy') {
    $kernel->post( storage => 'deploy' );
  }

  #my $response = RPC::XML::response->new('ok');
  #POE::Component::RPCXML::Server->send_resp($wheel, $response->as_string);
  #$kernel->yield( send_response => $response, $wheel );
  
};

sub send_response {
  my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
  $self->debug("send_response");
  my $wheel = $_[ARG0];
  my $response = $_[ARG1];
  if (ref $response ne 'RPC::XML::response') {
    print "NEW!", "\n";
    $response = RPC::XML::response->new( $response );
  }
  POE::Component::RPCXML::Server->send_resp($wheel, $response->as_string);
}

1;
__END__
1	joko	1.1	## ------------------------------------------------------------------------
2			## $Id: WebCache.pm,v 1.3 2003/06/25 23:37:04 joko Exp $
3			## ------------------------------------------------------------------------
4			## $Log: WebCache.pm,v $
5			## ------------------------------------------------------------------------
6
7
8			package POE::Component::LookupService;
9
10			use strict;
11			use warnings;
12
13			use POE qw( Component::RPCXML::Server Component::StorageAgent Component::ServiceRegistrar );
14			use RPC::XML;
15			use Data::Dumper;
16
17
18			sub new {
19			my $classname = shift;
20			my @args = @_;
21
22			my $self = {};
23			bless $self, $classname;
24
25			$self->{options} = { @args };
26
27			#my $event_handler = lookupd->new();
28			POE::Session->create(
29			object_states => [
30			$self => [qw( _start _stop boot_intercom boot_storage boot_registrar handle_request send_response )]
31			]
32			);
33
34			}
35
36			# This is not a POE method. It's a plain OO one.
37			sub debug {
38			my $self = shift;
39			my $msg = shift;
40			$msg \|\|= '';
41			print STDERR __PACKAGE__ . ": " . $msg, "\n";
42			}
43
44			# Controller's event handlers
45
46			sub _start {
47			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
48			$self->debug("_start");
49
50			#$kernel->alias_set("controller");
51
52			#$kernel->post( controller => 'start_daemon' );
53			$kernel->yield( 'boot_storage' );
54			$kernel->yield( 'boot_registrar' );
55			$kernel->yield( 'boot_intercom' );
56			#$_[HEAP]->{subsession} = POE::Session->create( inline_states => { _start => sub { print "WORKER!", "\n"; } } );
57			#$_[HEAP]->{subsession}->yield(
58
59			};
60
61			sub _stop {
62			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
63			$self->debug("_stop");
64			};
65
66			sub boot_intercom {
67
68			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
69			$self->debug("boot_intercom");
70
71			# Server component - encapsulates some session(s) and/or wheel(s)?
72
73			# V1 - windy?!
74			# - dies on empty payloads
75			# - requires addressing of "session"-parameter inside url (security flaw?)
76			# + method publishing/rescinding
77			#POE::Component::Server::XMLRPC->new( alias => "xmlrpc", port => 3332 );
78
79			# V2 - seems to be times more robust! i.e. offers these features:
80			# + doesn't die on empty xml-payloads in request
81			# + doesn't require session addressing through url
82			# + more flexible event dispatching
83			# - no remote method publishing and/or rescinding
84			# + doesn't even call the dispatching method on empty payloads! ("method-missing", etc.)
85			POE::Component::RPCXML::Server->new(
86			'Alias' => 'rpcxml-server',
87			'Port' => $self->{options}->{daemon}->{port},
88			'DispatchEvent' => 'handle_request',
89			'Debug' => 0,
90			);
91
92			# V3 - IKC
93			# Don't do that here! It doesn't work!
94			#use POE::Component::IKC::Server;
95			#create_ikc_server( port => 30, name => 'LookupService' );
96
97			};
98
99			sub boot_storage {
100
101			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
102			$self->debug("boot_storage");
103
104			#print Dumper($self->{options}->{storage});
105			$heap->{db} = POE::Component::StorageAgent->new( $self->{options}->{storage} );
106
107			}
108
109			sub boot_registrar {
110			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
111			$self->debug("boot_registrar");
112			$heap->{reg} = POE::Component::ServiceRegistrar->new();
113			}
114
115			sub handle_request {
116			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
117
118			my $request = $_[ARG0];
119			my $wheel = $_[ARG1];
120
121			#print Dumper($request);
122			$self->debug("handle_request: method='$request->{name}'");
123
124			#my $payload = {};
125
126			my $method = $request->{name};
127			if ($method eq 'ServiceRegistrar.register') {
128			#$payload->{msg} = 'Registration running';
129			my $authenticated = 1;
130			if ($authenticated) {
131			# send response back to client
132			#my $response = RPC::XML::response->new($payload);
133			$kernel->yield( send_response => $wheel => 'ok' );
134
135			# handle registration
136			my $query = {
137			'abc' => 'def',
138			};
139			$kernel->post( storage => 'query' => $query );
140			}
141			} elsif ($method eq 'ServiceRegistrar.list') {
142			} elsif ($method eq 'Lease.renew') {
143			} elsif ($method eq 'system.shutdown') {
144			exit;
145			#$kernel->signal( 'TERM' );
146			} elsif ($method eq 'storage.deploy') {
147			$kernel->post( storage => 'deploy' );
148			}
149
150			#my $response = RPC::XML::response->new('ok');
151			#POE::Component::RPCXML::Server->send_resp($wheel, $response->as_string);
152			#$kernel->yield( send_response => $response, $wheel );
153
154			};
155
156			sub send_response {
157			my ( $self, $kernel, $heap ) = @_[ OBJECT, KERNEL, HEAP ];
158			$self->debug("send_response");
159			my $wheel = $_[ARG0];
160			my $response = $_[ARG1];
161			if (ref $response ne 'RPC::XML::response') {
162			print "NEW!", "\n";
163			$response = RPC::XML::response->new( $response );
164			}
165			POE::Component::RPCXML::Server->send_resp($wheel, $response->as_string);
166			}
167
168			1;
169			__END__
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26