In 6th Grade, I was accepted into a Private Catholic School.  I was a good
student for the rest of my Middle and High School careers, but not
exceptional.  In grade school, I had asked and received answers to my
toughest questions.  In Middle and High School, the questions became
increasingly complex and more subversive to the Dogma.  My questions were
discouraged, or worse punished, and I fell out of love with school.

In 10th Grade, I took my first “Biology” Class.  Biology in quotes because
this was a Catholic High School.  We learned about cells, cell structures,
dissected disgusting owl pellets, and covered Evolution.  It wasn’t really
emphasized, and questions about it’s conflict with the Bible were glossed
over by the generic “Helping Hand” Argument.  For an aspiring Devotee to
Catholicism and Diligent Seeker of the Truth, this idea seemed amazingly
beautiful and perfect.

There needs to be a distinction here between “Helping Hand” and “Intelligent
Design.”  Intelligent Design is uneducated rubbish.  Had ID been
presented to me at age 14, I would’ve laughed it straight out of the
classroom.  ID looks at Life Forms and finds intricate, beautiful pieces of
those organisms that seem unlikely to have arisen from pure, unadulterated
random chance.  The eye and the Bombardier Beetle are prime examples of ID’s
misinformation.

The convincing “Helping Hand” argument irresponsibly pitched to me by a
well-meaning Biology Teacher essentially stated “God started the
evolutionary process and made sure that the correct random mutations were
selected for by shaping the environment in which our evolutionary ancestors
arose.”  The fact that the ID Camp has not latched onto this concept
demonstrates just how astoundingly stupid they are.  As a political idea,
this “Helping Hand” argument appears to be a harmless means for religion to
reconcile it’s Dark Age, Anti-Intellectual Dogma to modern science’s most
powerful ideas.

So, why is this idea dangerous, idiotic, and offensive?  It’s simple.  The
“Helping Hand” concept is irresponsible because it’s not necessary.  More
than unnecessary, it exposes dangerous flaws in the Religion itself.
Consider that religions consider God to be a fairly “Perfect” being.  Often
God receives All-Knowing, All-Powerful, Ever Present status.  If that’s the
case, then the “Helping Hand” argument serves only to expose God as an
incompetent hack.

If there were intelligence behind the Evolutionary Process we should be able
to see it in Humans.  After all, we are created in His image?  That doesn’t
appear to be the case.  As products of Evolution, you and I are scarcely
prepared to exist in the Modern World.  Our tongues sense Salt, a necessary
mineral to help us maintain our overwhelmingly liquid existence.  We crave
sugars, some of the most efficient mechanisms for transferring energy.  We
sense bitterness, because in our evolutionary past bitterness often
indicated poisons.  We crave savoriness because the protein of meat has
encouraged the rapid, outpacing expansion of our brain.  We also taste and
sense sourness, which identify acidic compounds necessary to maintain the
alkalinity of the body.

All of these evolutionary processes served our ancestors incredibly well.
They are indispensable in the shaping of Homo Sapiens.  This might seem
neutral in our “Helping Hand” vs Natural Selection argument.  But, that’s
not the case.  These cravings served us well in the past, but how are they
affecting us these days?  Imagine this process was aided by an All-Knowing,
All-Powerful Creator, targeting the emergence of Homo Sapiens as he zapped
Reptiles and Bacteria from a cloud, patiently paving the road for us.  The
Hands guiding us to where we were in 1 CE.

And then what?  These very simple and basic taste sensations that were
necessary for a caloric scarce existence in the past, are literally killing
us en masse in our Caloric Rich “Industrialized” existence today.  Has He
stopped paying attention?  Did He get bored?  Hello, is this thing on?

By inserting the “Helping Hand” idea into Evolutionary Biology, theologians
have created far more serious problems than they answered.  Taste is but one
small, fairly simple demonstration of this fallacy.  Consider the #1 killer
in America, Heart Disease.  The problem is compounded by our taste for
calorie rich food, but that is overshadowed by the catastrophic design
failure of the magnificent Human Heart.  If there was someone nudging
evolution, who could see the future, surely they saw this problem coming.
Back then, it would’ve been trivial to correct.  I’m not a Cardiologist, or
Evolutionary Biologist.  I’m a Software Developer and System Administrator,
so I’ll have to invoke one of the first design problems I was taught in my
limited schooling: Single Point of Failure.   The Human Heart has 1 Major
Artery into, and out of the Heart.

If I were designing, or nudging the process of Human Evolution, as an
imperfect, under-educated, simplistic, narrow-minded Human Being, I’d say
“maybe we should have some redundancy in such a critical element!”  Surely,
that adaptation could be demonstrated to be benevolent and useful.  Surely
it would exhibit the foresight of some intelligent being edging towards a
perfect being.

The lack of foresight in such an obvious and enormous problem as Heart
Disease, is Yet Another demonstration of the logical fallacies committed by
the most well-meaning religious people.  It doesn’t need to be there.  It
doesn’t answer any questions, it only creates more questions.  Science can
only deal with questions that can be answered.  The “Unmoved Mover,”
“Creationism,” “Intelligent Design,” and “Helping Hand” in-dignify the
amazing brilliance of Human understanding, creativity, and intelligence.

If you’re reading this, and you’ve reconciled your faith with science in the
same way I did in High School with this ludicrous idea of “Helping Hand”
evolution, please stop deluding yourself, your neighbors, your friends, and
most importantly your children.  You may think you’re helping, but you’re
not.  The fact is, you’re lying and deceiving everyone.

I finally started to use my Twitter account. I’ve noticed the majority of tweets regarding Perl refer to it as torturous or antiquated or both. These tweets are not coming from the Perl echo-chamber of Perl Monks, Perl Mongers, and Perl Conference attendees, but from programmers exposed to Perl against their will. This leaves a bad taste in their mouth, and when they hear “Perl,” their frame of reference is sadly the Matt’s Scripts Era of Perl Development.

I’m using TweetDeck, and I’ve created a search column for “perl.” It gets a decent amount of traffic everyday. I don’t have the time to respond to or even read every tweet about Perl, but I skim them maybe 4 or 5 times a day to find people with Perl problems or Perl frustration and point them in a better direction. If you’re comfortable providing this type of assistance, I’d recommend TweetDeck with the “perl” Search Column as an interesting way to proselytize for Perl. It does mean you’ll be subjected to the occasional teen ranting about “Perl Jam,” and of course you’ll likely writhe in agony at the number of times you see Perl referred to as “PERL.” But if enough of the echo chamber is inundating the Twitterverse with intelligent, modern Perl advice, we might gain even more traction in the Social Media arena.

If you do tweet about Perl, follow HashTags and tag your tweet with “#perl“.

Just a thought, as I haven’t been able to hack in Perl in a few weeks due to other more pressing issues.

The main difference between Perl and PHP, is writing maintainable, intelligent Perl is only slightly more work at first than writing horrible Matt’s Scripts style Perl. With PHP, writing decent PHP is possible, but it’s incredibly difficult. The majority of the PHP I’ve come across is code written by a web developer with no programming experience and the language design and direction accommodate that demographic. PHP’s language design gets in the way of writing sane, maintainable code. It’s not impossible, but you have to really, really want it.

When you write good Perl, the programming experience becomes easier, and more fun.

I’m trying to get back to my programming projects, and thus back to writing more on Perl. For now, understand that if you think Perl and PHP are the same beast, you’re wrong. I’ve been paid to develop both for periods of years. Perl is much more eloquent, evolutionary, and intelligent.

Syslog-ng facilitates easy integration with Perl binaries as the Perl program is spawned once during the daemon start up and a handle to that program’s STDIN is maintained for dispatching of messages. Using POE, we can turn this into an event driven model, making additional complexity simple.

In this example, we’ll create a POE Master session that receives all of the syslog-ng input from STDIN. Using off the shelf components, we’ll run a TCP Server on port 9514 that will allow clients to connect and subscribe to feeds based on the “program” name of the message being dispatched.

Anytime I’m using Regular Expressions over and over, I like to “precook” them. This compiles the regular expression, and lets the engine skip that step each time they’re used. Doing so is simply a matter of declaring the regex with the qr// operator:

my %cooked = (
	program => qr/\s+\d+:\d+:\d+\s+\S+\s+([^:\s]+)(:|\s)/,
);

Initialization

Next we’ll create the administrative session in charge of dispatching the messages to the proper channels:

# Dispatcher Master Session
POE::Session->create(
	inline_states => {
		_start					=> \&dispatcher_start,
		_stop					=> sub { print "SESSION ", $_[SESSION]->ID, " stopped.\n"; },
		register_client			=> \&register_client,
		subscribe_client		=> \&subscribe_client,
		hangup_client			=> \&hangup_client,

		dispatch_message		=> \&dispatch_message,
	},
);

We’ll define those subroutines shortly, but we need to setup the rest of our sessions. Next, we’ll need a TCP Server to handle the client connections, we can get that using POE::Component::Server::TCP:

# TCP Session Master
POE::Component::Server::TCP->new(
		Alias		=> 'server',
		Address		=> '127.0.0.1',
		Port		=> 9514,

		ClientConnected		=> \&client_connect,
		ClientInput			=> \&client_input,

		ClientDisconnected	=> \&client_term,
		ClientError			=> \&client_term,

		InlineStates		=> {
			client_print		=> \&client_print,
		},
);

The final session will handle the Input on STDIN from syslog-ng:

# Syslog-ng Stream Master
POE::Session->create(
		inline_states => {
			_start		=> \&stream_start,
			_stop		=> sub { print "SESSION ", $_[SESSION]->ID, " stopped.\n"; },
			stream_line		=> \&stream_line,
		},
);

Now we have to define the subroutines that we’ll be dispatching events to. The heavy lifting is done by POE, and we’re left to handle simple things.

Session Routines: dispatcher

This session is going to managing which clients receive which messages. The actual input is handled by the stream session, and the sending of the messages to the client by the server session. As we have a raw POE::Session, our first subroutine dispatcher_start is just going to do some basic preparation:

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

	$kernel->alias_set( 'dispatcher' );  # allow named dispatch to this session.

	$heap->{subscribers} = {};
        $heap->{clients} = {};

}

Next event to be handled is the register_client event which is fired anytime a connection is established to the server session. All the dispatcher does is register it’s session_id into an internal heap. Nothing happens with it, but if we needed to send a message to all clients, we could loop over this hash and broadcast message.

sub register_client {
    # ARG0 => TCP Client Session ID
    my ($kernel,$heap,$sid) = @_[KERNEL,HEAP,ARG0];

    $heap->{clients}{$sid} = 1;
}

Clients can subscribe to a program name, which they do by entering “sub dhcpd, dnsmasq” into the TCP Server. It’s not fancy, but man is it convenient for debugging and development purposes. The server session determines that the subscription is occurring and passes it’s argument string to the dispatcher session via the subscribe_client event. This subroutine is called:

sub subscribe_client {
    # ARG0 => SID of Client
    # ARG1 => Argument String of the subscribe
	my ($kernel,$heap,$sid,$argstr) = @_[KERNEL,HEAP,ARG0,ARG1];

    # Split the input at commas or spaces into words:
	my @progs = map { lc } split /[\s,]+/, $argstr;
    # Add the SID to the list of Subscribed Clients for that program
	foreach my $prog (@progs) {
		$heap->{subscribers}{$prog}{$sid} = 1;
	}

    # Inform the client they've subscribed via client_print
	$kernel->post( $sid => 'client_print' => 'Subscribed to : ' . join(', ', @progs ) );
}

If a client disconnects, we remove it from the message dispatching hash:

sub hangup_client {
    # ARG0 => SID of Client Disconnecting
	my ($kernel,$heap,$sid) = @_[KERNEL,HEAP,ARG0];

	delete $heap->{clients}{$sid};

	foreach my $p ( keys %{ $heap->{subscribers} } ) {
		delete $heap->{subscribers}{$p}{$sid}
			if exists $heap->{subscribers}{$p}{$sid};
	}
}

Now comes the most important event the dispatcher handles, dispatch_message. In this event, we have a message from syslog-ng that needs to go to interested parties. This event determines the “program” and it’s subscribers and sends that message along appropriately:

sub dispatch_message {
    # ARG0 => The raw message from syslog-ng
	my ($kernel,$heap,$msg) = @_[KERNEL,HEAP,ARG0];

    # Determine the program name
	if( my ($program) = map { lc } ($msg =~ /$cooked{program}/) ) {
		# remove the sub process and PID from the program
		$program =~ s/\(.*//g;
		$program =~ s/\[.*//g;

        # If we have subscribers, send them the message.
		if( exists $heap->{subscribers}{$program} ) {
			foreach my $sid (keys %{ $heap->{subscribers}{$program} }) {
				$kernel->post( $sid => 'client_print' => $msg );
			}
		}
}

You'll notice on line 14 above, the post( $sid => client_print => $msg ) sends the event to the appropriate client and calls the client_print event on itself. This is all the dispatcher needs to do. The rest is handled by other other sessions.

Session Routines: server

This session accepts new tcp clients and handles writing to the sockets. We'll take a look at a few subroutines here. Fist we'll look at the ClientConnect event.

sub client_connect {
    # SESSION is the client's session object
	my ($kernel,$heap,$ses) = @_[KERNEL,HEAP,SESSION];

	my $SID = $ses->ID;

    # Register the Client with the Dispatcher
	$kernel->post( 'dispatcher' => 'register_client' => $SID );

    # Store the current entry for 'client' in the heap so we can communicate later
	$heap->{clients}{ $SID } = $heap->{client};

	# Say hello to the client.
	$heap->{client}->put( "Hello Client: $SID" );
}

We also need a disconnect event:

sub client_term {
	my ($kernel,$heap,$ses) = @_[KERNEL,HEAP,SESSION];
	my $sid = $ses->ID;

    # Delete the Client's Dispatch Table
	delete $heap->{dispatch}{$sid};
    # Tell the dispatcher session we're through
	$kernel->post( 'dispatcher' => 'hangup_client' =>  $sid );
}

Next we’ll handle sending message to the client, which is incredibly easy:

sub client_print {
    # ARG0 => Message to Send to the Client
	my ($kernel,$heap,$ses,$mesg) = @_[KERNEL,HEAP,SESSION,ARG0];

	$heap->{clients}{$ses->ID}->put($mesg);
}

Now we a routine to handle the ClientInput event. This event will take commands from the clients and do something with them. We’ll use an internal dispatch table in the form of a hash to handle translating commands. This will allow us to expand our API if we need to.

sub client_input {
    # SESSION is the Client Session Object with input
    # ARG0 => Input waiting from that client
	my ($kernel,$heap,$ses,$msg) = @_[KERNEL,HEAP,SESSION,ARG0];
	my $sid = $ses->ID;

    # Build a Dispatch Table if one does not exists in the heap for this entry.
	if( !exists $heap->{dispatch}{$sid} ) {
		$heap->{dispatch}{$sid} = {

			subscribe		=> {
				re			=> qr/^sub(?:scribe)? (.*)/,
				callback	=> sub {
					$kernel->post( 'dispatcher' => 'subscribe_client' => $sid, shift );
				},
			},
            # FUTURE API for Clients receiving every message!
			#fullfeed		=> {
			#	re			=> qr/^(fullfeed)/,
			#	callback	=> sub {
			#		$kernel->post( 'dispatcher' => 'fullfeed_client' => $sid );
			#	},
			#},
		};
	}

	#
	# Check for messages:
	my $handled = 0;
    # Get Our Dispatch Table
	my $dispatch = $heap->{dispatch}{$sid};
    # Look up and take action according to our dispatch table
	foreach my $evt ( keys %{ $dispatch } ) {
		if( my($args) = ($msg =~ /$dispatch->{$evt}{re}/)) {
			$handled = 1;
			$dispatch->{$evt}{callback}->($args);
			last;
		}
	}

    # Inform the client that their command was not understood.
	if( !$handled ) {
		$kernel->post( $sid => 'client_print' => 'UNKNOWN COMMAND, Ignored.' );
	}
}

That’s the most complicated routine in the program, but it does allow us to morph the dispatch tables for individual clients. Lines 12-15 build a dispatch table entry with the regular expression to match the command, followed by a callback subroutine reference which handles the command. Lines 34 and 36 are where these rules are applied to the input from the client.

Session Routines: stream

The last session is very simple. This session maintains the connection to STDIN from syslog-ng and dispatches those lines as events to the dispatcher session. There is a startup routine:

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

	$kernel->alias_set( 'stream' );

	#
	# Initialize the connection to STDIN as a POE::Wheel
	my $stdin = IO::Handle->new_from_fd( \*STDIN, 'r' );
	my $stderr = IO::Handle->new_from_fd( \*STDERR, 'w' );

	$heap->{stream} = POE::Wheel::ReadWrite->new(
		InputHandle		=> $stdin,
		OutputHandle	=> $stderr,
		InputEvent		=> 'stream_line',
	);
}

And the stream_line event which sends the incoming syslog messages to the dispatcher session for processing:

#--------------------------------------------------------------------------#
sub stream_line {
    # ARG0 => Line from STDIN, New line delimited.
	my ($kernel,$msg) = @_[KERNEL,ARG0];

	return unless length $msg;

	$kernel->post( 'dispatcher' => 'dispatch_message' => $msg );

}

Setting it up with syslog-ng

If we store our POE program in /usr/local/bin/poe-syslog-ng.pl, in the syslog-ng.conf we need to specify it as a program:

#
# Subscriber Feeds
destination d_subscribers {
	program("/usr/local/bin/poe-syslog-ng.pl");
};

Then you can feed it based on filters, just like the rest of the destination macros in syslog-ng:

#
# SUBSCRIPTION SERVICE:
log { source(s_ext); source(s_udp); filter(f_database); destination(d_subscribers); };

The whole #!

For those interested, I’ve written a program that expands this example with enhanced functionality. The full source is available here:

#!/usr/bin/perl
#
# This is the POE Master Server.
#  1) Take all the syslog input
#  2) Listen for parsers
#  3) Filter streams to parsers
#  TODO: 4) Maintain Parser State, restarting on crash

use strict;
use warnings;

use Socket;
use Regexp::Common qw(net);

sub POE::Kernel::ASSERT_DEFAULT (){ 1 }
#sub POE::Kernel::TRACE_DEFAULT (){ 1 }
use POE qw(
	Wheel::ReadWrite
	Component::Server::TCP
);

my %cooked = (
	program => qr/\s+\d+:\d+:\d+\s+\S+\s+([^:\s]+)(:|\s)/,
);

#--------------------------------------------------------------------------#
# POE Session Initialization

# Dispatcher Master Session
POE::Session->create(
	inline_states => {
		_start					=> \&dispatcher_start,
		_stop					=> sub { print "SESSION ", $_[SESSION]->ID, " stopped.\n"; },
		register_client			=> \&register_client,
		subscribe_client		=> \&subscribe_client,
		unsubscribe_client		=> \&unsubscribe_client,
		fullfeed_client			=> \&fullfeed_client,
		dispatch_message		=> \&dispatch_message,
		broadcast				=> \&broadcast,
		hangup_client			=> \&hangup_client,
		server_shutdown			=> \&server_shutdown,
		debug_client			=> \&debug_client,
		nobug_client			=> \&nobug_client,
		debug_message			=> \&debug_message,
	},
);

# TCP Session Master
POE::Component::Server::TCP->new(
		Alias		=> 'server',
		Address		=> '127.0.0.1',
		Port		=> 9514,

		ClientConnected		=> \&client_connect,
		ClientInput			=> \&client_input,

		ClientDisconnected	=> \&client_term,
		ClientError			=> \&client_term,

		InlineStates		=> {
			client_print		=> \&client_print,
		},
);

# Syslog-ng Stream Master
POE::Session->create(
		inline_states => {
			_start		=> \&stream_start,
			_stop		=> sub { print "SESSION ", $_[SESSION]->ID, " stopped.\n"; },

			stream_line		=> \&stream_line,
			stream_error	=> \&stream_error,
		},
);

#--------------------------------------------------------------------------#

#--------------------------------------------------------------------------#
# POE Main Loop
POE::Kernel->run();
exit 0;
#--------------------------------------------------------------------------#

#--------------------------------------------------------------------------#
# POE Event Functions
#--------------------------------------------------------------------------#

#--------------------------------------------------------------------------#
sub debug {
	my $msg = shift;
	chomp($msg);
	$poe_kernel->post( 'dispatcher' => 'debug_message' => $msg );
	print "[debug] $msg\n";
}
#--------------------------------------------------------------------------#
sub dispatcher_start {
	my ($kernel, $heap) = @_[KERNEL, HEAP];

	$kernel->alias_set( 'dispatcher' );

	$heap->{subscribers} = { };
	$heap->{full} = { };
	$heap->{debug} = { };
}

#--------------------------------------------------------------------------#
sub register_client {
	my ($kernel,$heap,$sid) = @_[KERNEL,HEAP,ARG0];

	$heap->{clients}{$sid} = 1;
}

#--------------------------------------------------------------------------#
sub debug_client {
	my ($kernel,$heap,$sid) = @_[KERNEL,HEAP,ARG0];

	if( exists $heap->{full}{$sid} ) {  return;  }

	$heap->{debug}{$sid} = 1;
	$kernel->post( $sid => 'client_print' => 'Debugging enabled.' );
}

#--------------------------------------------------------------------------#
sub nobug_client {
	my ($kernel,$heap,$sid) = @_[KERNEL,HEAP,ARG0];

	delete $heap->{debug}{$sid}
		if exists $heap->{debug}{$sid};
	$kernel->post( $sid => 'client_print' => 'Debugging disabled.' );
}

#--------------------------------------------------------------------------#
sub fullfeed_client {
	my ($kernel,$heap,$sid) = @_[KERNEL,HEAP,ARG0];

	#
	# Remove from normal subscribers.
	foreach my $prog (keys %{ $heap->{subscribers} }) {
		delete $heap->{subscribers}{$prog}{$sid}
			if exists $heap->{subscribers}{$prog}{$sid};
	}

	#
	# Turn off DEBUG
	if( exists $heap->{debug}{$sid} ) {
		delete $heap->{debug}{$sid};
	}

	#
	# Add to fullfeed:
	$heap->{full}{$sid} = 1;

	$kernel->post( $sid => 'client_print' => 'Full feed enabled, all other functions disabled.');
}

#--------------------------------------------------------------------------#
sub subscribe_client {
	my ($kernel,$heap,$sid,$argstr) = @_[KERNEL,HEAP,ARG0,ARG1];

	if( exists $heap->{full}{$sid} ) {  return;  }

	my @progs = map { lc } split /[\s,]+/, $argstr;
	foreach my $prog (@progs) {
		$heap->{subscribers}{$prog}{$sid} = 1;
	}

	$kernel->post( $sid => 'client_print' => 'Subscribed to : ' . join(', ', @progs ) );
}
#--------------------------------------------------------------------------#
sub unsubscribe_client {
	my ($kernel,$heap,$sid,$argstr) = @_[KERNEL,HEAP,ARG0,ARG1];

	my @progs = map { lc } split /[\s,]+/, $argstr;
	foreach my $prog (@progs) {
		delete $heap->{subscribers}{$prog}{$sid};
	}

	$kernel->post( $sid => 'client_print' => 'Subscription removed for : ' . join(', ', @progs ) );
}

#--------------------------------------------------------------------------#
sub hangup_client {
	my ($kernel,$heap,$sid) = @_[KERNEL,HEAP,ARG0];

	delete $heap->{clients}{$sid};

	foreach my $p ( keys %{ $heap->{subscribers} } ) {
		delete $heap->{subscribers}{$p}{$sid}
			if exists $heap->{subscribers}{$p}{$sid};
	}

	if( exists $heap->{debug}{$sid} ) {
		delete $heap->{debug}{$sid};
	}

	if( exists $heap->{full}{$sid} ) {
		delete $heap->{full}{$sid};
	}

	debug("Client Termination Posted: $sid\n");

}

#--------------------------------------------------------------------------#
sub stream_start {
	my ($kernel, $heap) = @_[KERNEL, HEAP];

	$kernel->alias_set( 'stream' );

	#
	# Initialize the connection to STDIN as a POE::Wheel
	my $stdin = IO::Handle->new_from_fd( \*STDIN, 'r' );
	my $stderr = IO::Handle->new_from_fd( \*STDERR, 'w' );

	$heap->{stream} = POE::Wheel::ReadWrite->new(
		InputHandle		=> $stdin,
		OutputHandle	=> $stderr,
		InputEvent		=> 'stream_line',
		ErrorEvent		=> 'stream_error',
	);
}

#--------------------------------------------------------------------------#
sub stream_line {
	my ($kernel,$msg) = @_[KERNEL,ARG0];

	return unless length $msg;

	$kernel->post( 'dispatcher' => 'dispatch_message' => $msg );

}

#--------------------------------------------------------------------------#
sub stream_error {
	my ($kernel) = $_[KERNEL];

	debug("STREAM ERROR!!!!!!!!!!\n");
	$kernel->call( 'dispatcher' => 'server_shutdown' => 'Stream lost' );
}

#--------------------------------------------------------------------------#
sub server_shutdown {
	my ($kernel,$heap,$msg) = @_[KERNEL,HEAP,ARG0];

	$kernel->call( dispatcher => 'broadcast' => 'SERVER DISCONNECTING: ' . $msg );
	$kernel->call( 'server' => 'shutdown' );
	exit;
}

#--------------------------------------------------------------------------#
sub client_connect {
	my ($kernel,$heap,$ses) = @_[KERNEL,HEAP,SESSION];

	my $KID = $kernel->ID();
	my $CID = $heap->{client}->ID;
	my $SID = $ses->ID;

	$kernel->post( 'dispatcher' => 'register_client' => $SID );

	$heap->{clients}{ $SID } = $heap->{client};
	#
	# Say hello to the client.
	$heap->{client}->put( "EHLO Streamer (KERNEL: $KID:$SID)" );
}

#--------------------------------------------------------------------------#
sub client_print {
	my ($kernel,$heap,$ses,$mesg) = @_[KERNEL,HEAP,SESSION,ARG0];

	$heap->{clients}{$ses->ID}->put($mesg);
}

#--------------------------------------------------------------------------#
sub broadcast {
	my ($kernel,$heap,$msg) = @_[KERNEL,HEAP,ARG0];

	foreach my $sid (keys %{ $heap->{clients} }) {
		$kernel->post( $sid => 'client_print' => $msg );
	}
}
#--------------------------------------------------------------------------#
sub dispatch_message {
	my ($kernel,$heap,$msg) = @_[KERNEL,HEAP,ARG0];

	foreach my $sid ( keys %{ $heap->{full} } ) {
		$kernel->post( $sid => 'client_print' => $msg );
	}

	if( my ($program) = map { lc } ($msg =~ /$cooked{program}/) ) {
		# remove the sub process and PID from the program
		$program =~ s/\(.*//g;
		$program =~ s/\[.*//g;

		debug("DISPATCHING MESSAGE [$program]");

		if( exists $heap->{subscribers}{$program} ) {
			foreach my $sid (keys %{ $heap->{subscribers}{$program} }) {
				$kernel->post( $sid => 'client_print' => $msg );
			}
		}
		else {
			debug("Message discarded, no listeners.");
		}
	}
	else {
			debug("Message discarded, format not understood.");
	}
}

#--------------------------------------------------------------------------#
sub debug_message {
	my ($kernel,$heap,$msg) = @_[KERNEL,HEAP,ARG0];

	foreach my $sid (keys %{ $heap->{debug} }) {
		$kernel->post( $sid => 'client_print' => '[debug] ' . $msg );
	}
}

#--------------------------------------------------------------------------#
sub client_input {
	my ($kernel,$heap,$ses,$msg) = @_[KERNEL,HEAP,SESSION,ARG0];
	my $sid = $ses->ID;

	if( !exists $heap->{dispatch}{$sid} ) {
		$heap->{dispatch}{$sid} = {
			fullfeed		=> {
				re			=> qr/^(fullfeed)/,
				callback	=> sub {
					$kernel->post( 'dispatcher' => 'fullfeed_client' => $sid );
				},
			},
			subscribe		=> {
				re			=> qr/^sub(?:scribe)? (.*)/,
				callback	=> sub {
					$kernel->post( 'dispatcher' => 'subscribe_client' => $sid, shift );
				},
			},
			unsubscribe 	=> {
				re			=> qr/^unsub(?:scribe)? (.*)/,
				callback	=> sub {
					$kernel->post( 'dispatcher' => 'unsubscribe_client' => $sid, shift );
				},
			},
			debug 	=> {
				re			=> qr/^(debug)/i,
				callback	=> sub {
					$kernel->post( 'dispatcher' => 'debug_client' => $sid, shift );
				},
			},
			nobug 	=> {
				re			=> qr/^(no(de)?bug)/i,
				callback	=> sub {
					$kernel->post( 'dispatcher' => 'nobug_client' => $sid, shift );
				},
			},
			#quit			=> {
			#	re			=> qr/(exit)|q(uit)?/,
			#	callback	=> sub {
			#			$kernel->post( $sid => 'client_print' => 'Terminating connection on your request.');
			#			$kernel->post( $sid => 'shutdown' );
			#	},
			#},
			#status			=> {
			#	re			=> qr/^status/,
			#	callback	=> sub {
			#		my $cnt = scalar( keys %{ $heap->{clients} } );
			#		my $subcnt = scalar( keys %{ $heap->{subscribers} });
			#		my $msg = "Currently $cnt connections, $subcnt subscribed.";
			#		$kernel->post( $sid, 'client_print', $msg );
			#	},
			#},
		};
	}

	#
	# Check for messages:
	my $handled = 0;
	my $dispatch = $heap->{dispatch}{$sid};
	foreach my $evt ( keys %{ $dispatch } ) {
		if( my($args) = ($msg =~ /$dispatch->{$evt}{re}/)) {
			$handled = 1;
			$dispatch->{$evt}{callback}->($args);
			last;
		}
	}

	if( !$handled ) {
		$kernel->post( $sid => 'client_print' => 'UNKNOWN COMMAND, Ignored.' );
	}
}

#--------------------------------------------------------------------------#
sub client_term {
	my ($kernel,$heap,$ses) = @_[KERNEL,HEAP,SESSION];
	my $sid = $ses->ID;

	delete $heap->{dispatch}{$sid};
	$kernel->post( 'dispatcher' => 'hangup_client' =>  $sid );

	debug("SERVER, client $sid disconnected.\n");
}

#--------------------------------------------------------------------------#

Overall the conference was a fantastic success. There were highs and lows, and I just wanted to take an opportunity to thank the conference organizers!! They did a wonderful job putting together another spectacular conference.

Also wanted to thank all the speakers as I know firsthand how much work goes into presenting at a conference like YAPC. All the talks I attended were great, however several stood out as exceptional:

• Trapped in a Room with Schwern – Michael Schwern is an excellent speaker, and this free room talk with back and forth between him and members of the community at all levels of mastery provided insight into projects I was unaware of, as well as some relief that most of my concerns about Perl 5 were being discussed by people far smarter than myself.
• The Future of DBIx::Class – Matt S Trout (MST) is a speaker for the real programmers. His volume, accent, and excessive use of profanity actually keep people listening. Getting yelled at by Matt Trout was the highlight of this conference for me. He has good ideas and opinions and he’s not afraid to beat them into your head. Kid gloving is great for Managers, but his presentation style and content really clicks with the people who don’t have their heads so far up their own asses to understand things need to change. Excellent talk about the past, present, and future of DBIx::Class which is the most significant ORM in the Perl Community currently.
• Take Advantage of Modern Perl – chromatic’s speaking style is the complete opposite of MST’s, but his message synced with Schwern, MST, and the The Enlightened Perl Organisation: Encourage people to write better Perl. Write Better Perl. Teach others how to write better Perl. Embrace the language where it is now, and transition away from the bad things in the past. Fantastic Talk.
• perl5i: Perl 5 Improved – Michael Schwern echoing chromatic’s plea for leveraging the best of what Perl 5 offers today. He’s got a module on cpan, perl5i, which implements the best of Perl 5 Tribal Knowledge.
• Catching an ::Std – MST again. He very honestly covered the trials, tribulations, and evolution of “Best Practices” in the Perl community.
• Drop in REPL for CGI Applications – Brock Wilcox floored everyone demonstrating his ridiculously cool module CGI::Inspect. I went in expecting “neat” and found “amazing.” We’ll be abusing this in development very soon.

These were my favorite talks, but like I said, every talk I went to was fantastic. I did miss a few talks I wanted to see due to schedule conflicts, but I’ll be checking the YAPC website for slides and video/audio. The conference organizers were not able to record anything, but a few attendees brought recording equipment with them. If nothing else, I’ll hopefully see those missed talks next year or at the Pittsburgh Perl Workshop in 2010!

I’m recommitting to the Perl Iron Man. I was an idiot and jackass for bailing after 1 post! :)

I entered myself today.  The goal is blog about Perl atleast once a week.  As I’m splitting my development time between a Catalyst Project and a number of POE projects, I expect my posts to be along those lines.  I’ll eventually share my DBIx::Class scripts as well.  There should be something for everyone, especially @strcpy!  (He loves my Perl blogging).

Look for code related stuff early next week!

It all started with the concept of “Inside Out Objects” as a safe, functional object development methodology. From there a number of modules sprouted attempting to do Inside-Out better. Around this time, the Perl 6 Apocalypses were being published and translated in Conway’s Exegeses.  Conway  published “Perl Best Practices” and very soon after, Perl::Critic showed up on the CPAN to enforce the rules laid out in the book.  Perl::Critic became a critical authority on the most maintainable way to write Perl code.  TIMTOWTDI will never die, but clean, maintainable code does outweigh some stranger interpreter abuses.

The modern looking object system for Perl 6 made it debut, and instantly the Army of CPAN began figuring out clever ways to implement fancy object notation in Perl 5. his eventually led to the development of Class::MOP, from which the “post Modern Object System for Perl 5,” Moose, blossomed.

Concurrently, Ruby on Rails had layed waste to the entire scope of PHP Scaffolding systems in existence, building off the Model-View-Controller (MVC) Ideology implemented earlier in Perl 5 through Maypole. As RoR gained traction, Python’s Django framework, through it’s association with the MVC philosophy, began to see serious deployment. This made sense as a lot of large Open Source and Commercial companies were using Python for much of their behind the scenes development. The result left PHP staggering and dizzy in the corner.

Unfortunately, there was a horrible association of PHP to Perl in most people’s heads, which sounded the Death Knell for Perl as well. This wasn’t the case, as Perl, inside it’s mostly impenetrable Echo Chamber had not stagnated at all. Perl 5.8.x was a huge performance and syntactical modernization of Perl 5. This improvement was eclipsed with the release of 5.10, drawing from the Perl 6 Design Documents, and the push of the Echo Chamber for a more Modern Language.

The Army of CPAN was still hard at work in the background throughout all of this. ORM’s drawing on the Success of the MVC philosophy took shape and evolved. Rose::DB, Class::DBI, and the current forerunner DBIx::Class simplified database development through the use of abstraction through modules like SQL::Abstract. Maypole, an simplified, earlier implementation of MVC sparked other MVC efforts in Perl 5, the most popular of which are Catalyst, Jifty, and CGI::Application. Each have their strengths and weaknesses.

All of these modules are beginning to converge to create a beautiful, post modern web application development platform in pure Perl.  Additionally, projects like Strawberry Perl, and Padre are aiming to expand Perl’s reach into realms it’s shied away from: Windows & IDEs.  The future is bright for Perl thanks to efforts of countless volunteers and programmers.

Perl is dead.  Long live Perl.

After several colleagues recommending Puppet, I hesitantly began the slow, brain fscking process of:

1. Understanding exactly what I had accomplished with cfEngine.
2. Understanding Ruby (ugh, I’m so thankful for Perl)
3. Understanding how to express my cfengine feelings in a way Puppet will understand without hurting it’s feelings
4. …
5. Profit.

cfEngine makes some things incredibly easy to manage.  Nearly every command allows you to “define” new classes based on various conditions.  This allows to modify a configuration file, and then tell the daemon associated with that config file to restart.  However, when I needed to do something highly specialized, I had to create a shell script, copy the shell script to the server and then run the shell script.  Passing data back to do something was possible, though it seemed a bit hacky.  It separated the customized actions being performed from the dependent actions in the cfEngine configs.  If I had to go back later and make changes, I had to look at both the .cf file and the custom shell script in a completely different directory.

With Puppet, these things can be done relatively simply inside the same class file.  Also, Puppet can be extended simply through the use of defines (think macros) or complexly through the use of modules.  Additionally, Puppet supports templating, classes, inheritance, and explicit order.  Where with cfengine I’d have to do something like this:

copy:
  s_snmpd.dc_has_snmp::
     $(distribute)/snmpd.conf	dest=/etc/snmp/snmpd.conf mode=644

				server=$(policyhost)
				type=sum
				define=dc_restart_snmpd

shellcommands:
   s_snmpd.dc_restart_snmpd::
	"/sbin/service snmpd restart"

class ssh {
    package {
        [ "openssh-clients", "openssh-server" ]:
        ensure => latest
    }
    file { "/etc/ssh/sshd_config":
        mode  => 0600,
        owner => root,
        group => root,
        mode => 644,
        require => Package["openssh-server"],
        content => template("sshd_config.erb")
    }
    service { sshd:
        subscribe => File["/etc/ssh/sshd_config"],
        ensure    => running,
        enable    => true
    }
}

 

With this syntax it’s easy to read that the file /etc/ssh/sshd_config is dependent on the openssh-server package and that the sshd service is dependent on that file.  Puppet also feels more “cross-platform” as the “service” directive allows me to abstractly describe the service without having to hard code a call to /sbin/service.

Puppet is not without it’s drawbacks.  The first of which is that it is Ruby.  If you’re not using Ruby on your systems, this means more package installations on those servers.  If you’ve been programming in another language, like Perl or Python, it’s another language you have to fight with.  The memory usage is much higher than I expected.  On some virtual servers, this may be a huge drawback. Consider:

Memory usage for puppetmasterd

Not too bad, but this is shocking:

Memory Usage at ~250 MB prior to restart

Compare this to cfegine:

Memory Usage for cfservd, Yes, Memory Leak.

and:

Memory Usage for cfexecd

Hell, even a long running Perl program using POE and Net::Pcap to decode all packets on our uplink at work (which bursts to ~75mb/sec) isn’t using that much memory:

Memory Usage for PoCo::Pcap based Traffic Inspector

Ultimately, RAM is cheap and my time is expensive.  After kludging together configuration management in cfengine for the past three years, I’ve decided to ditch it in favor of a more sane and extensible configuration with Puppet.  I’ve got a lot to learn about Puppet still, so as I learn new and more exciting things and Puppet grows, I’ll be sure to share how it’s helping.

My talk was titled Network Introspection with Open Source Tools and was an overhaul of the presentation that I did at LinuxWorld earlier this year. I took the feedback of the audience and tuned the talk to a Perl centric audience. I wasn’t heckled badly on IRC, which is the ultimate gauge of success.

I’d like to thank the organizers, CMU, sponsors, and The Perl Foundation for another successful year of the Work Shop. Next year, Pittsburgh is hosting YAPC::NA, and will not be hosting the Pittsburgh Perl Workshop. I look forward to being able to drive to YAPC!

If you saw the talk and want to rant about it, feel free to do so here.