X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBI%2FReplicated%2FBalancer.pm;h=316653a0f61fe54fcb86f453938753b15cf1a0a6;hb=7e38d85069fbeeff050dc736b756b60c01f85fc6;hp=bf47c07cb544bbc4c042cc4db7a4e66c1ca52be5;hpb=cb6ec758e3c4607ec8e30dd943a500a1d70d8940;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Storage/DBI/Replicated/Balancer.pm b/lib/DBIx/Class/Storage/DBI/Replicated/Balancer.pm index bf47c07..316653a 100644 --- a/lib/DBIx/Class/Storage/DBI/Replicated/Balancer.pm +++ b/lib/DBIx/Class/Storage/DBI/Replicated/Balancer.pm @@ -1,6 +1,7 @@ package DBIx::Class::Storage::DBI::Replicated::Balancer; -use Moose; +use Moose::Role; +requires 'next_storage'; =head1 NAME @@ -8,8 +9,7 @@ DBIx::Class::Storage::DBI::Replicated::Balancer; A Software Load Balancer =head1 SYNOPSIS -This class is used internally by L. You -shouldn't need to create instances of this class. +This role is used internally by L. =head1 DESCRIPTION @@ -21,6 +21,34 @@ method by which query load can be spread out across each replicant in the pool. This class defines the following attributes. +=head2 auto_validate_every ($seconds) + +If auto_validate has some sort of value, run the L every +$seconds. Be careful with this, because if you set it to 0 you will end up +validating every query. + +=cut + +has 'auto_validate_every' => ( + is=>'rw', + isa=>'Int', + predicate=>'has_auto_validate_every', +); + +=head2 master + +The L object that is the master database all the +replicants are trying to follow. The balancer needs to know it since it's the +ultimate fallback. + +=cut + +has 'master' => ( + is=>'ro', + isa=>'DBIx::Class::Storage::DBI', + required=>1, +); + =head2 pool The L object that we are trying to @@ -29,9 +57,9 @@ balance. =cut has 'pool' => ( - is=>'ro', - isa=>'DBIx::Class::Storage::DBI::Replicated::Pool', - required=>1, + is=>'ro', + isa=>'DBIx::Class::Storage::DBI::Replicated::Pool', + required=>1, ); =head2 current_replicant @@ -48,14 +76,14 @@ via it's balancer object. =cut has 'current_replicant' => ( - is=> 'rw', - isa=>'DBIx::Class::Storage::DBI', - lazy_build=>1, - handles=>[qw/ - select - select_single - columns_info_for - /], + is=> 'rw', + isa=>'DBIx::Class::Storage::DBI', + lazy_build=>1, + handles=>[qw/ + select + select_single + columns_info_for + /], ); =head1 METHODS @@ -69,26 +97,62 @@ Lazy builder for the L attribute. =cut sub _build_current_replicant { - my $self = shift @_; - $self->next_storage($self->pool); + my $self = shift @_; + $self->next_storage; } =head2 next_storage +This method should be defined in the class which consumes this role. + Given a pool object, return the next replicant that will serve queries. The default behavior is to grap the first replicant it finds but you can write your own subclasses of L to support other balance systems. +This returns from the pool of active replicants. If there are no active +replicants, then you should have it return the master as an ultimate fallback. + +=head2 around: next_storage + +Advice on next storage to add the autovalidation. We have this broken out so +that it's easier to break out the auto validation into a role. + +This also returns the master in the case that none of the replicants are active +or just just forgot to create them :) + =cut -sub next_storage { - my $self = shift @_; - return ($self->pool->active_replicants)[0] - if $self->pool->active_replicants; +around 'next_storage' => sub { + my ($next_storage, $self, @args) = @_; + my $now = time; + + ## Do we need to validate the replicants? + if( + $self->has_auto_validate_every && + ($self->auto_validate_every + $self->pool->last_validated) <= $now + ) { + $self->pool->validate_replicants; + } + + ## Get a replicant, or the master if none + my $next = $self->$next_storage(@args); + return $next ? $next:$self->master; +}; + +=head2 increment_storage + +Rolls the Storage to whatever is next in the queue, as defined by the Balancer. + +=cut + +sub increment_storage { + my $self = shift @_; + my $next_replicant = $self->next_storage; + $self->current_replicant($next_replicant); } -=head2 after: select +=head2 around: select Advice on the select attribute. Each time we use a replicant we need to change it via the storage pool algorithm. That way we are spreading @@ -96,13 +160,19 @@ the load evenly (hopefully) across existing capacity. =cut -after 'select' => sub { - my $self = shift @_; - my $next_replicant = $self->next_storage; - $self->current_replicant($next_replicant); +around 'select' => sub { + my ($select, $self, @args) = @_; + + if (my $forced_pool = $args[-1]->{force_pool}) { + delete $args[-1]->{force_pool}; + return $self->_get_forced_pool($forced_pool)->select(@args); + } else { + $self->increment_storage; + return $self->$select(@args); + } }; -=head2 after: select_single +=head2 around: select_single Advice on the select_single attribute. Each time we use a replicant we need to change it via the storage pool algorithm. That way we are spreading @@ -110,13 +180,19 @@ the load evenly (hopefully) across existing capacity. =cut -after 'select_single' => sub { - my $self = shift @_; - my $next_replicant = $self->next_storage; - $self->current_replicant($next_replicant); +around 'select_single' => sub { + my ($select_single, $self, @args) = @_; + + if (my $forced_pool = $args[-1]->{force_pool}) { + delete $args[-1]->{force_pool}; + return $self->_get_forced_pool($forced_pool)->select_single(@args); + } else { + $self->increment_storage; + return $self->$select_single(@args); + } }; -=head2 after: columns_info_for +=head2 before: columns_info_for Advice on the current_replicant_storage attribute. Each time we use a replicant we need to change it via the storage pool algorithm. That way we are spreading @@ -124,12 +200,30 @@ the load evenly (hopefully) across existing capacity. =cut -after 'columns_info_for' => sub { - my $self = shift @_; - my $next_replicant = $self->next_storage; - $self->current_replicant($next_replicant); +before 'columns_info_for' => sub { + my $self = shift @_; + $self->increment_storage; }; +=head2 _get_forced_pool ($name) + +Given an identifier, find the most correct storage object to handle the query. + +=cut + +sub _get_forced_pool { + my ($self, $forced_pool) = @_; + if(blessed $forced_pool) { + return $forced_pool; + } elsif($forced_pool eq 'master') { + return $self->master; + } elsif(my $replicant = $self->pool->replicants($forced_pool)) { + return $replicant; + } else { + $self->master->throw_exception("$forced_pool is not a named replicant."); + } +} + =head1 AUTHOR John Napiorkowski