view release on metacpan or  search on metacpan

lib/POE/Declare/Log/File.pm  view on Meta::CPAN

		return 1;
	}

	# Initiate a flush event if we aren't doing one already
	if ( $self->{state} eq 'IDLE' ) {
		$self->{state} = 'BUSY';
		$self->post('flush');
		return 1;
	}

	# Message is delayed
	return 0;
}





######################################################################
# Event Methods

sub startup : Event {
	if ( $_[SELF]->Lazy ) {
		if ( defined $_[SELF]->{buffer} ) {
			# Open the file immediately
			$_[SELF]->{Handle} = $_[SELF]->_handle;
		} else {
			# Switch to lazy start mode
			$_[SELF]->{state} = 'LAZY';
			return;
		}
	}

	# Connect to the handle
	$_[SELF]->post('connect');
}

sub connect : Event {
	# Create the read/write wheel on the filehandle
	$_[SELF]->{wheel} = POE::Wheel::ReadWrite->new(
		Handle       => $_[SELF]->Handle,
		Filter       => POE::Filter::Stream->new,
		AutoFlush    => 1,
		FlushedEvent => 'flush',
		ErrorEvent   => 'error',
	);
	$_[SELF]->{state} = 'IDLE';

	# Do an initial queue flush if we have anything
	if ( defined $_[SELF]->{buffer} ) {
		$_[SELF]->{state} = 'BUSY';
		$_[SELF]->post('flush');
	}

	return;
}

sub flush : Event {
	if ( defined $_[SELF]->{buffer} ) {
		# Almost all the time we should arrive here already
		# busy. But if we do arrive IDLE accidentally, set as well.
		if ( $_[SELF]->{state} eq 'IDLE' ) {
			$_[SELF]->{state} = 'BUSY';
		}

		# Merge the queued messages ourself to prevent having to use a heavier
		# POE line filter in the Read/Write wheel.
		$_[SELF]->{wheel}->put( delete $_[SELF]->{buffer} );
		$_[SELF]->{buffer} = undef;

	} else {
		# Nothing (left) to do
		if ( $_[SELF]->{state} eq 'HALT' ) {
			$_[SELF]->{state} = 'STOP';
			$_[SELF]->finish;
			$_[SELF]->ShutdownEvent;

		} else {
			$_[SELF]->{state} = 'IDLE';
		}
	}

	return;
}

sub error : Event {
	$_[SELF]->{state} = 'CRASH';

	# Prevent additional message and flush queue
	delete $_[SELF]->{buffer};

	# Clean up streaming resources
	$_[SELF]->clean;

	return;
}

sub shutdown : Event {
	my $state = $_[SELF]->{state};

	# Superfluous crash shutdown
	if ( $state eq 'CRASH' ) {
		$_[SELF]->finish;
		$_[SELF]->ShutdownEvent;
		return;
	}

	# Shutdown with nothing pending to write
	if ( $state eq 'IDLE' or $state eq 'LAZY') {
		$_[SELF]->{state} = 'STOP';
		$_[SELF]->finish;
		$_[SELF]->ShutdownEvent;
		return;
	}

	# Shutdown while writing
	if ( $state eq 'BUSY' ) {
		# Signal we want to stop as soon as the queue is empty,
		# but otherwise just wait for the natural end.
		$_[SELF]->{state} = 'HALT';
		return;