ipc.pm

linux集群服务器软件代码包

Creates a Unix Domain Socket channel object using the provided path.

=cut

sub new {
	my ($class, $path) = @_;
	ref ($class) and croak "class name needed";

	my $self = { };
	
	my $h = heartbeat::cl_raw::simple_hash_new();
	
	heartbeat::cl_raw::simple_hash_insert($h,
		$heartbeat::cl_raw::IPC_PATH_ATTR,
		$path);
	$self->{raw} = heartbeat::cl_raw::ipc_channel_constructor(
                $heartbeat::cl_raw::IPC_DOMAIN_SOCKET,$h);
	heartbeat::cl_raw::simple_hash_destroy($h);
	
	bless $self, $class;

	return $self;	
}

# Undocumented on purpose, should be called externally, only from the
# WaitConnection wrapper!

sub new_from_raw {
	my ($class, $ch) = @_;
	ref ($class) and croak "class name needed";
	
	$ch =~ /^_p_IPC_Channel/o or 
		croak("Need to supply a raw IPC_Channel reference!");
	
	# By default, we assume we need to clean up after ourselves.
	my $self = { };
	
	$self->{raw} = $ch;

	bless $self, $class;
	return $self;
}

=item $ch-E<gt>initiate_connection();

Initiates the connection to the path given at creation time, and will
return the corresponding IPC error/success code.

=cut

sub initiate_connection {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";

	return heartbeat::cl_raw::ipc_ch_initiate_connection($self->{raw});
}

=item $ch-E<gt>verify_auth($auth);

Verifies the authentication of the connection vs the supplied IPC_Auth
object.

Not implemented yet. TODO.

=cut

sub verify_auth {
	my ($self, $auth) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	UNIVERSAL::isa($auth, "heartbeat::clplumbing::ipc::auth")
		or croak "Wrong object type, not an IPC Auth";

	croak("Not yet implemented.");
}

=item my ($rc, $msg) = $ch-E<gt>recv();

Tries to receive an IPC message from the channel, which is automatically
returned as a C<heartbeat::clplumbing::ipc::message> object.

Returns a list with the return code from the lower-level recv operation
and the message.

=cut

sub recv {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";

	my $msg_with_rc = 
		heartbeat::cl_raw::ipc_ch_recv($self->{raw});
	
	my $msg = heartbeat::clplumbing::ipc::message->new_from_raw(
		heartbeat::cl_rawc::IPC_MESSAGE_WITH_RC_msg_get($msg_with_rc)); 

	my $rc =
	heartbeat::cl_rawc::IPC_MESSAGE_WITH_RC_rc_get($msg_with_rc);
	
	heartbeat::cl_raw::ipc_ch_msg_with_rc_destroy($msg_with_rc);
	
	return ($rc, $msg);
}

=item my $rc = $ch-E<gt>send($msg);

Queues an IPC message for sending on the channel; you need to provide it
an C<heartbeat::clplumbing::ipc::message> object.

Returns the lower-level status code.

=cut
sub send {
	my ($self, $msg) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	UNIVERSAL::isa($msg, "heartbeat::clplumbing::ipc::message")
		or croak "Wrong object type, not an IPC message";

	# After the message has been sent, it will be cleaned up. We
	# MUST NOT do this ourselves - flip the switch inside the IPC
	# Message object for this.
	$msg->{cleanup} = 0;
	
	return heartbeat::cl_raw::ipc_ch_send($self->{raw},
		$msg->{raw});
}

=item $ch-E<gt>waitin();

Wait until input is available, also returns the lower-level status
code.

=cut
sub waitin {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	return heartbeat::cl_raw::ipc_ch_waitin($self->{raw});
}

=item $ch-E<gt>waitout();

Wait until all queued messages have been send or the channel is
disconnected. Also returns the lower-level status code.

=cut
sub waitout {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	return heartbeat::cl_raw::ipc_ch_waitout($self->{raw});
}

=item $ch-E<gt>iswconn();

Returns true if the channel is connected for writing.

=cut
sub iswconn {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	return heartbeat::cl_raw::ipc_ch_iswconn($self->{raw});
}

=item $ch-E<gt>isrconn();

Returns true if the channel is ready to be read from, ie either in
IPC_OK or IPC_DISC_PENDING.

=cut
sub isrconn {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	return heartbeat::cl_raw::ipc_ch_isrconn($self->{raw});
}

=item $ch-E<gt>status();

Returns ch_status.

=cut
sub status {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	return
	heartbeat::cl_rawc::IPC_CHANNEL_ch_status_get($self->{raw}); 
}

=item $ch-E<gt>is_message_pending();

Returns TRUE if a message can be read right now.

=cut
sub is_message_pending {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	return heartbeat::cl_raw::ipc_ch_is_message_pending($self->{raw});
}

=item $ch-E<gt>is_sending_blocked();

Returns true if the channel is connected and there is still a message in
the send queue.

=cut
sub is_sending_blocked {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	return heartbeat::cl_raw::ipc_ch_is_sending_blocked($self->{raw});
}

=item $ch-E<gt>resume_io();

Resume IO and return the status code.

=cut

sub resume_io {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	return heartbeat::cl_raw::ipc_ch_resume_io($self->{raw});
}

=item $ch-E<gt>get_send_select_fd();

Return the fd which can be used in the poll() function for the sending
side of the connection.

=cut
sub get_send_select_fd {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	return heartbeat::cl_raw::ipc_ch_get_send_select_fd($self->{raw});
}

=item $ch-E<gt>get_recv_select_fd();

Return the fd which can be used in the poll() function for the receiving
side of the connection.

=cut
sub get_recv_select_fd {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	return heartbeat::cl_raw::ipc_ch_get_recv_select_fd($self->{raw});
}

=item $ch-E<gt>set_send_qlen($i);

Set the sending queue len to C<$i>, which needs to be a positive
integer.

=cut
sub set_send_qlen {
	my ($self, $qlen) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	($qlen <= 0) and croak "send_qlen needs to be greater than 0";

	return heartbeat::cl_raw::ipc_ch_set_send_qlen($self->{raw},
		$qlen);
}

=item $ch-E<gt>set_recv_qlen($i);

Set the receiving queue len to C<$i>, which needs to be a positive
integer.

=cut
sub set_recv_qlen {
	my ($self, $qlen) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	($qlen <= 0) and croak "recv_qlen needs to be greater than 0";

	return heartbeat::cl_raw::ipc_ch_set_recv_qlen($self->{raw},
		$qlen);
}

sub DESTROY {
	my ($self) = @_;
	ref($self) or croak "Instance variable needed";
	UNIVERSAL::isa($self, "heartbeat::clplumbing::ipc::channel")
		or croak "Wrong object type, not an IPC channel";
	heartbeat::cl_raw::ipc_ch_destroy($self->{raw});
}

=back

=cut

1;
__END__

=head1 SEE ALSO

The IPC header files in heartbeat.

=head1 AUTHOR

Lars Marowsky-Bree, E<lt>[e-mail]<gt>

=head1 COPYRIGHT AND LICENSE

Copyright (C) 2004 by Lars Marowsky-Bree

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



=cut