X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBI%2FReplicated%2FBalancer.pm;h=a2d0fbc0a4f9ecaa882ef3a868d9c735069ed0b8;hb=071bbccba2ec162da1a78069dc6f8fa371788895;hp=f69ce8c64eebc5d8b453b9e4fb73aa38b0412a70;hpb=7edf5f1cd3b097de79d262ed02d65128336f5893;p=dbsrgits%2FDBIx-Class-Historic.git diff --git a/lib/DBIx/Class/Storage/DBI/Replicated/Balancer.pm b/lib/DBIx/Class/Storage/DBI/Replicated/Balancer.pm index f69ce8c..a2d0fbc 100644 --- a/lib/DBIx/Class/Storage/DBI/Replicated/Balancer.pm +++ b/lib/DBIx/Class/Storage/DBI/Replicated/Balancer.pm @@ -1,15 +1,18 @@ package DBIx::Class::Storage::DBI::Replicated::Balancer; -use Moose; +use Moose::Role; +requires 'next_storage'; +use MooseX::Types::Moose qw/Int/; + +use namespace::clean -except => 'meta'; =head1 NAME -DBIx::Class::Storage::DBI::Replicated::Balancer; A Software Load Balancer +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 @@ -30,28 +33,9 @@ validating every query. =cut has 'auto_validate_every' => ( - is=>'rw', - isa=>'Int', - predicate=>'had_auto_validate_every', -); - -=head2 last_validated - -This is an integer representing a time since the last time the replicants were -validated. It's nothing fancy, just an integer provided via the perl time -builtin. - -=cut - -has 'last_validated' => ( - is=>'rw', - isa=>'Int', - reader=>'last_validated', - writer=>'_last_validated', - lazy=>1, - default=>sub { - time; - }, + is=>'rw', + isa=>Int, + predicate=>'has_auto_validate_every', ); =head2 master @@ -63,9 +47,9 @@ ultimate fallback. =cut has 'master' => ( - is=>'ro', - isa=>'DBIx::Class::Storage::DBI', - required=>1, + is=>'ro', + isa=>'DBIx::Class::Storage::DBI', + required=>1, ); =head2 pool @@ -76,9 +60,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 @@ -95,14 +79,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 @@ -116,12 +100,14 @@ Lazy builder for the L attribute. =cut sub _build_current_replicant { - my $self = shift @_; - $self->next_storage; + 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 @@ -130,28 +116,50 @@ 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. -TODO this needs to wrap for the subclasses better. Maybe good use of INNER? +=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 + +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 + if(my $next = $self->$next_storage(@args)) { + return $next; + } else { + $self->master->debugobj->print("No Replicants validate, falling back to master reads. "); + return $self->master; + } +}; + +=head2 increment_storage + +Rolls the Storage to whatever is next in the queue, as defined by the Balancer. =cut -sub next_storage { - my $self = shift @_; - - ## Do we need to validate the replicants? - if( - $self->had_auto_validate_every && - ($self->auto_validate_every + $self->last_validated) > time - ) { - $self->pool->validate_replicants; - $self->_last_validated(time); - } - - ## Get a replicant, or the master if none - my $next = ($self->pool->active_replicants)[0]; - return $next ? $next:$self->master; +sub increment_storage { + my $self = shift @_; + my $next_replicant = $self->next_storage; + $self->current_replicant($next_replicant); } -=head2 before: 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 @@ -159,13 +167,21 @@ the load evenly (hopefully) across existing capacity. =cut -before '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); + } elsif($self->master->{transaction_depth}) { + return $self->master->select(@args); + } else { + $self->increment_storage; + return $self->$select(@args); + } }; -=head2 before: 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 @@ -173,10 +189,18 @@ the load evenly (hopefully) across existing capacity. =cut -before '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); + } elsif($self->master->{transaction_depth}) { + return $self->master->select_single(@args); + } else { + $self->increment_storage; + return $self->$select_single(@args); + } }; =head2 before: columns_info_for @@ -188,14 +212,32 @@ the load evenly (hopefully) across existing capacity. =cut before 'columns_info_for' => sub { - my $self = shift @_; - my $next_replicant = $self->next_storage; - $self->current_replicant($next_replicant); + 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 +John Napiorkowski =head1 LICENSE