storage type, add some replicated (readonly) databases, and perform reporting
tasks.
- ## Change storage_type in your schema class
- $schema->storage_type( ['::DBI::Replicated', {balancer=>'::Random'}] );
-
- ## Add some slaves. Basically this is an array of arrayrefs, where each
- ## arrayref is database connect information
-
- $schema->storage->connect_replicants(
- [$dsn1, $user, $pass, \%opts],
- [$dsn2, $user, $pass, \%opts],
- [$dsn3, $user, $pass, \%opts],
- );
-
+ ## Change storage_type in your schema class
+ $schema->storage_type( ['::DBI::Replicated', {balancer=>'::Random'}] );
+
+ ## Add some slaves. Basically this is an array of arrayrefs, where each
+ ## arrayref is database connect information
+
+ $schema->storage->connect_replicants(
+ [$dsn1, $user, $pass, \%opts],
+ [$dsn2, $user, $pass, \%opts],
+ [$dsn3, $user, $pass, \%opts],
+ );
+
=head1 DESCRIPTION
Warning: This class is marked ALPHA. We are using this in development and have
=cut
has 'pool_type' => (
- is=>'ro',
- isa=>'ClassName',
- lazy_build=>1,
- handles=>{
- 'create_pool' => 'new',
- },
+ is=>'ro',
+ isa=>'ClassName',
+ lazy_build=>1,
+ handles=>{
+ 'create_pool' => 'new',
+ },
);
=head2 pool_args
=cut
has 'pool_args' => (
- is=>'ro',
- isa=>'HashRef',
- lazy=>1,
- required=>1,
- default=>sub { {} },
+ is=>'ro',
+ isa=>'HashRef',
+ lazy=>1,
+ required=>1,
+ default=>sub { {} },
);
=cut
has 'balancer_type' => (
- is=>'ro',
- isa=>'ClassName',
- lazy_build=>1,
- handles=>{
- 'create_balancer' => 'new',
- },
+ is=>'ro',
+ isa=>'ClassName',
+ lazy_build=>1,
+ handles=>{
+ 'create_balancer' => 'new',
+ },
);
=head2 balancer_args
=cut
has 'balancer_args' => (
- is=>'ro',
- isa=>'HashRef',
- lazy=>1,
- required=>1,
- default=>sub { {} },
+ is=>'ro',
+ isa=>'HashRef',
+ lazy=>1,
+ required=>1,
+ default=>sub { {} },
);
=head2 pool
=cut
has 'pool' => (
- is=>'ro',
- isa=>'DBIx::Class::Storage::DBI::Replicated::Pool',
- lazy_build=>1,
- handles=>[qw/
- connect_replicants
- replicants
- has_replicants
- /],
+ is=>'ro',
+ isa=>'DBIx::Class::Storage::DBI::Replicated::Pool',
+ lazy_build=>1,
+ handles=>[qw/
+ connect_replicants
+ replicants
+ has_replicants
+ /],
);
=head2 balancer
=cut
has 'balancer' => (
- is=>'ro',
- isa=>'DBIx::Class::Storage::DBI::Replicated::Balancer',
- lazy_build=>1,
- handles=>[qw/auto_validate_every/],
+ is=>'ro',
+ isa=>'DBIx::Class::Storage::DBI::Replicated::Balancer',
+ lazy_build=>1,
+ handles=>[qw/auto_validate_every/],
);
=head2 master
=cut
has 'master' => (
- is=> 'ro',
- isa=>'DBIx::Class::Storage::DBI',
- lazy_build=>1,
+ is=> 'ro',
+ isa=>'DBIx::Class::Storage::DBI',
+ lazy_build=>1,
);
=head1 ATTRIBUTES IMPLEMENTING THE DBIx::Storage::DBI INTERFACE
=cut
has 'read_handler' => (
- is=>'rw',
- isa=>'Object',
- lazy_build=>1,
- handles=>[qw/
- select
- select_single
- columns_info_for
- /],
+ is=>'rw',
+ isa=>'Object',
+ lazy_build=>1,
+ handles=>[qw/
+ select
+ select_single
+ columns_info_for
+ /],
);
=head2 write_handler
=cut
has 'write_handler' => (
- is=>'ro',
- isa=>'Object',
- lazy_build=>1,
- lazy_build=>1,
- handles=>[qw/
- on_connect_do
- on_disconnect_do
- connect_info
- throw_exception
- sql_maker
- sqlt_type
- create_ddl_dir
- deployment_statements
- datetime_parser
- datetime_parser_type
- last_insert_id
- insert
- insert_bulk
- update
- delete
- dbh
- txn_do
- txn_commit
- txn_rollback
- sth
- deploy
- schema
- reload_row
- /],
+ is=>'ro',
+ isa=>'Object',
+ lazy_build=>1,
+ lazy_build=>1,
+ handles=>[qw/
+ on_connect_do
+ on_disconnect_do
+ connect_info
+ throw_exception
+ sql_maker
+ sqlt_type
+ create_ddl_dir
+ deployment_statements
+ datetime_parser
+ datetime_parser_type
+ last_insert_id
+ insert
+ insert_bulk
+ update
+ delete
+ dbh
+ txn_do
+ txn_commit
+ txn_rollback
+ sth
+ deploy
+ schema
+ reload_row
+ /],
);
=head1 METHODS
=cut
sub new {
- my $class = shift @_;
- my $schema = shift @_;
- my $storage_type_args = shift @_;
- my $obj = $class->SUPER::new($schema, $storage_type_args, @_);
-
- ## Hate to do it this way, but can't seem to get advice on the attribute working right
- ## maybe we can do a type and coercion for it.
- if( $storage_type_args->{balancer_type} && $storage_type_args->{balancer_type}=~m/^::/) {
- $storage_type_args->{balancer_type} = 'DBIx::Class::Storage::DBI::Replicated::Balancer'.$storage_type_args->{balancer_type};
- eval "require $storage_type_args->{balancer_type}";
- }
-
- return $class->meta->new_object(
- __INSTANCE__ => $obj,
- %$storage_type_args,
- @_,
- );
+ my $class = shift @_;
+ my $schema = shift @_;
+ my $storage_type_args = shift @_;
+ my $obj = $class->SUPER::new($schema, $storage_type_args, @_);
+
+ ## Hate to do it this way, but can't seem to get advice on the attribute working right
+ ## maybe we can do a type and coercion for it.
+ if( $storage_type_args->{balancer_type} && $storage_type_args->{balancer_type}=~m/^::/) {
+ $storage_type_args->{balancer_type} = 'DBIx::Class::Storage::DBI::Replicated::Balancer'.$storage_type_args->{balancer_type};
+ eval "require $storage_type_args->{balancer_type}";
+ }
+
+ return $class->meta->new_object(
+ __INSTANCE__ => $obj,
+ %$storage_type_args,
+ @_,
+ );
}
=head2 _build_master
=cut
sub _build_master {
- DBIx::Class::Storage::DBI->new;
+ DBIx::Class::Storage::DBI->new;
}
=head2 _build_pool_type
=cut
sub _build_pool_type {
- return 'DBIx::Class::Storage::DBI::Replicated::Pool';
+ return 'DBIx::Class::Storage::DBI::Replicated::Pool';
}
=head2 _build_pool
=cut
sub _build_pool {
- my $self = shift @_;
- $self->create_pool(%{$self->pool_args});
+ my $self = shift @_;
+ $self->create_pool(%{$self->pool_args});
}
=head2 _build_balancer_type
=cut
sub _build_balancer_type {
- return 'DBIx::Class::Storage::DBI::Replicated::Balancer::First';
+ return 'DBIx::Class::Storage::DBI::Replicated::Balancer::First';
}
=head2 _build_balancer
=cut
sub _build_balancer {
- my $self = shift @_;
- $self->create_balancer(
- pool=>$self->pool,
- master=>$self->master,
- %{$self->balancer_args},
- );
+ my $self = shift @_;
+ $self->create_balancer(
+ pool=>$self->pool,
+ master=>$self->master,
+ %{$self->balancer_args},
+ );
}
=head2 _build_write_handler
=cut
sub _build_write_handler {
- return shift->master;
+ return shift->master;
}
=head2 _build_read_handler
=cut
sub _build_read_handler {
- return shift->balancer;
+ return shift->balancer;
}
=head2 around: connect_replicants
=cut
around 'connect_replicants' => sub {
- my ($method, $self, @args) = @_;
- $self->$method($self->schema, @args);
+ my ($method, $self, @args) = @_;
+ $self->$method($self->schema, @args);
};
=head2 all_storages
=cut
sub all_storages {
- my $self = shift @_;
-
- return grep {defined $_ && blessed $_} (
- $self->master,
- $self->replicants,
- );
+ my $self = shift @_;
+ return grep {defined $_ && blessed $_} (
+ $self->master,
+ $self->replicants,
+ );
}
=head2 execute_reliably ($coderef, ?@args)
Example:
- my $reliably = sub {
- my $name = shift @_;
- $schema->resultset('User')->create({name=>$name});
- my $user_rs = $schema->resultset('User')->find({name=>$name});
- return $user_rs;
- };
+ my $reliably = sub {
+ my $name = shift @_;
+ $schema->resultset('User')->create({name=>$name});
+ my $user_rs = $schema->resultset('User')->find({name=>$name});
+ return $user_rs;
+ };
- my $user_rs = $schema->storage->execute_reliably($reliably, 'John');
+ my $user_rs = $schema->storage->execute_reliably($reliably, 'John');
Use this when you must be certain of your database state, such as when you just
inserted something and need to get a resultset including it, etc.
=cut
sub execute_reliably {
- my ($self, $coderef, @args) = @_;
-
- unless( ref $coderef eq 'CODE') {
- $self->throw_exception('Second argument must be a coderef');
- }
-
- ##Get copy of master storage
- my $master = $self->master;
-
- ##Get whatever the current read hander is
- my $current = $self->read_handler;
-
- ##Set the read handler to master
- $self->read_handler($master);
-
- ## do whatever the caller needs
- my @result;
- my $want_array = wantarray;
-
- eval {
- if($want_array) {
- @result = $coderef->(@args);
- }
- elsif(defined $want_array) {
- ($result[0]) = ($coderef->(@args));
- } else {
- $coderef->(@args);
- }
- };
-
- ##Reset to the original state
- $self->read_handler($current);
-
- ##Exception testing has to come last, otherwise you might leave the
- ##read_handler set to master.
-
- if($@) {
- $self->throw_exception("coderef returned an error: $@");
+ my ($self, $coderef, @args) = @_;
+
+ unless( ref $coderef eq 'CODE') {
+ $self->throw_exception('Second argument must be a coderef');
+ }
+
+ ##Get copy of master storage
+ my $master = $self->master;
+
+ ##Get whatever the current read hander is
+ my $current = $self->read_handler;
+
+ ##Set the read handler to master
+ $self->read_handler($master);
+
+ ## do whatever the caller needs
+ my @result;
+ my $want_array = wantarray;
+
+ eval {
+ if($want_array) {
+ @result = $coderef->(@args);
+ } elsif(defined $want_array) {
+ ($result[0]) = ($coderef->(@args));
} else {
- return $want_array ? @result : $result[0];
- }
+ $coderef->(@args);
+ }
+ };
+
+ ##Reset to the original state
+ $self->read_handler($current);
+
+ ##Exception testing has to come last, otherwise you might leave the
+ ##read_handler set to master.
+
+ if($@) {
+ $self->throw_exception("coderef returned an error: $@");
+ } else {
+ return $want_array ? @result : $result[0];
+ }
}
=head2 set_reliable_storage
Sets the current $schema to be 'reliable', that is all queries, both read and
write are sent to the master
-
+
=cut
sub set_reliable_storage {
- my $self = shift @_;
- my $schema = $self->schema;
- my $write_handler = $self->schema->storage->write_handler;
-
- $schema->storage->read_handler($write_handler);
+ my $self = shift @_;
+ my $schema = $self->schema;
+ my $write_handler = $self->schema->storage->write_handler;
+
+ $schema->storage->read_handler($write_handler);
}
=head2 set_balanced_storage
Sets the current $schema to be use the </balancer> for all reads, while all
writea are sent to the master only
-
+
=cut
sub set_balanced_storage {
- my $self = shift @_;
- my $schema = $self->schema;
- my $write_handler = $self->schema->storage->balancer;
-
- $schema->storage->read_handler($write_handler);
+ my $self = shift @_;
+ my $schema = $self->schema;
+ my $write_handler = $self->schema->storage->balancer;
+
+ $schema->storage->read_handler($write_handler);
}
=head2 around: txn_do ($coderef)
=cut
around 'txn_do' => sub {
- my($txn_do, $self, $coderef, @args) = @_;
- $self->execute_reliably(sub {$self->$txn_do($coderef, @args)});
+ my($txn_do, $self, $coderef, @args) = @_;
+ $self->execute_reliably(sub {$self->$txn_do($coderef, @args)});
};
=head2 reload_row ($row)
=cut
around 'reload_row' => sub {
- my ($reload_row, $self, $row) = @_;
- return $self->execute_reliably(sub {
- return $self->$reload_row(shift);
- }, $row);
+ my ($reload_row, $self, $row) = @_;
+ return $self->execute_reliably(sub {
+ return $self->$reload_row(shift);
+ }, $row);
};
=head2 connected
=cut
sub connected {
- my $self = shift @_;
-
- return
- $self->master->connected &&
- $self->pool->connected_replicants;
+ my $self = shift @_;
+ return
+ $self->master->connected &&
+ $self->pool->connected_replicants;
}
=head2 ensure_connected
=cut
sub ensure_connected {
- my $self = shift @_;
- foreach my $source ($self->all_storages) {
- $source->ensure_connected(@_);
- }
+ my $self = shift @_;
+ foreach my $source ($self->all_storages) {
+ $source->ensure_connected(@_);
+ }
}
=head2 limit_dialect
=cut
sub limit_dialect {
- my $self = shift @_;
- foreach my $source ($self->all_storages) {
- $source->limit_dialect(@_);
- }
+ my $self = shift @_;
+ foreach my $source ($self->all_storages) {
+ $source->limit_dialect(@_);
+ }
}
=head2 quote_char
=cut
sub quote_char {
- my $self = shift @_;
- foreach my $source ($self->all_storages) {
- $source->quote_char(@_);
- }
+ my $self = shift @_;
+ foreach my $source ($self->all_storages) {
+ $source->quote_char(@_);
+ }
}
=head2 name_sep
=cut
sub name_sep {
- my $self = shift @_;
- foreach my $source ($self->all_storages) {
- $source->name_sep(@_);
- }
+ my $self = shift @_;
+ foreach my $source ($self->all_storages) {
+ $source->name_sep(@_);
+ }
}
=head2 set_schema
=cut
sub set_schema {
- my $self = shift @_;
- foreach my $source ($self->all_storages) {
- $source->set_schema(@_);
- }
+ my $self = shift @_;
+ foreach my $source ($self->all_storages) {
+ $source->set_schema(@_);
+ }
}
=head2 debug
=cut
sub debug {
- my $self = shift @_;
- foreach my $source ($self->all_storages) {
- $source->debug(@_);
- }
+ my $self = shift @_;
+ foreach my $source ($self->all_storages) {
+ $source->debug(@_);
+ }
}
=head2 debugobj
=cut
sub debugobj {
- my $self = shift @_;
- foreach my $source ($self->all_storages) {
- $source->debugobj(@_);
- }
+ my $self = shift @_;
+ foreach my $source ($self->all_storages) {
+ $source->debugobj(@_);
+ }
}
=head2 debugfh
=cut
sub debugfh {
- my $self = shift @_;
- foreach my $source ($self->all_storages) {
- $source->debugfh(@_);
- }
+ my $self = shift @_;
+ foreach my $source ($self->all_storages) {
+ $source->debugfh(@_);
+ }
}
=head2 debugcb
=cut
sub debugcb {
- my $self = shift @_;
- foreach my $source ($self->all_storages) {
- $source->debugcb(@_);
- }
+ my $self = shift @_;
+ foreach my $source ($self->all_storages) {
+ $source->debugcb(@_);
+ }
}
=head2 disconnect
=cut
sub disconnect {
- my $self = shift @_;
- foreach my $source ($self->all_storages) {
- $source->disconnect(@_);
- }
+ my $self = shift @_;
+ foreach my $source ($self->all_storages) {
+ $source->disconnect(@_);
+ }
}
=head1 AUTHOR
- John Napiorkowski <john.napiorkowski@takkle.com>
+ John Napiorkowski <john.napiorkowski@takkle.com>
Based on code originated by:
- Norbert Csongrádi <bert@cpan.org>
- Peter Siklósi <einon@einon.hu>
+ Norbert Csongrádi <bert@cpan.org>
+ Peter Siklósi <einon@einon.hu>
=head1 LICENSE
=cut
has 'auto_validate_every' => (
- is=>'rw',
- isa=>'Int',
- predicate=>'has_auto_validate_every',
+ is=>'rw',
+ isa=>'Int',
+ predicate=>'has_auto_validate_every',
);
=head2 master
=cut
has 'master' => (
- is=>'ro',
- isa=>'DBIx::Class::Storage::DBI',
- required=>1,
+ is=>'ro',
+ isa=>'DBIx::Class::Storage::DBI',
+ required=>1,
);
=head2 pool
=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
=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
=cut
sub _build_current_replicant {
- my $self = shift @_;
- $self->next_storage;
+ my $self = shift @_;
+ $self->next_storage;
}
=head2 next_storage
=cut
around 'next_storage' => sub {
- my ($next_storage, $self, @args) = @_;
- my $now = time;
+ 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;
- }
+ ## 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;
+ ## Get a replicant, or the master if none
+ my $next = $self->$next_storage(@args);
+ return $next ? $next:$self->master;
};
=head2 before: select
=cut
before 'select' => sub {
- my $self = shift @_;
- my $next_replicant = $self->next_storage;
- $self->current_replicant($next_replicant);
+ my $self = shift @_;
+ my $next_replicant = $self->next_storage;
+ $self->current_replicant($next_replicant);
};
=head2 before: select_single
=cut
before 'select_single' => sub {
- my $self = shift @_;
- my $next_replicant = $self->next_storage;
- $self->current_replicant($next_replicant);
+ my $self = shift @_;
+ my $next_replicant = $self->next_storage;
+ $self->current_replicant($next_replicant);
};
=head2 before: columns_info_for
=cut
before 'columns_info_for' => sub {
- my $self = shift @_;
- my $next_replicant = $self->next_storage;
- $self->current_replicant($next_replicant);
+ my $self = shift @_;
+ my $next_replicant = $self->next_storage;
+ $self->current_replicant($next_replicant);
};
=head1 AUTHOR
This class is used internally by L<DBIx::Class::Storage::DBI::Replicated>. You
shouldn't need to create instances of this class.
-
+
=head1 DESCRIPTION
In a replicated storage type, there is at least one replicant to handle the
=cut
has 'maximum_lag' => (
- is=>'rw',
- isa=>'Num',
- required=>1,
- lazy=>1,
- default=>0,
+ is=>'rw',
+ isa=>'Num',
+ required=>1,
+ lazy=>1,
+ default=>0,
);
=head2 last_validated
=cut
has 'last_validated' => (
- is=>'rw',
- isa=>'Int',
- reader=>'last_validated',
- writer=>'_last_validated',
- lazy=>1,
- default=>sub {
- 0;
- },
+ is=>'rw',
+ isa=>'Int',
+ reader=>'last_validated',
+ writer=>'_last_validated',
+ lazy=>1,
+ default=>0,
);
=head2 replicant_type ($classname)
=cut
has 'replicant_type' => (
- is=>'ro',
- isa=>'ClassName',
- required=>1,
- default=>'DBIx::Class::Storage::DBI',
- handles=>{
- 'create_replicant' => 'new',
- },
+ is=>'ro',
+ isa=>'ClassName',
+ required=>1,
+ default=>'DBIx::Class::Storage::DBI',
+ handles=>{
+ 'create_replicant' => 'new',
+ },
);
=head2 replicants
A hashref of replicant, with the key being the dsn and the value returning the
actual replicant storage. For example if the $dsn element is something like:
- "dbi:SQLite:dbname=dbfile"
-
+ "dbi:SQLite:dbname=dbfile"
+
You could access the specific replicant via:
- $schema->storage->replicants->{'dbname=dbfile'}
-
-This attributes also supports the following helper methods
+ $schema->storage->replicants->{'dbname=dbfile'}
+
+This attributes also supports the following helper methods:
=over 4
=cut
has 'replicants' => (
- is=>'rw',
- metaclass => 'Collection::Hash',
- isa=>'HashRef[DBIx::Class::Storage::DBI]',
- default=>sub {{}},
- provides => {
- 'set' => 'set_replicant',
- 'get' => 'get_replicant',
- 'empty' => 'has_replicants',
- 'count' => 'num_replicants',
- 'delete' => 'delete_replicant',
- },
+ is=>'rw',
+ metaclass => 'Collection::Hash',
+ isa=>'HashRef[DBIx::Class::Storage::DBI]',
+ default=>sub {{}},
+ provides => {
+ 'set' => 'set_replicant',
+ 'get' => 'get_replicant',
+ 'empty' => 'has_replicants',
+ 'count' => 'num_replicants',
+ 'delete' => 'delete_replicant',
+ },
);
=head1 METHODS
=cut
sub connect_replicants {
- my $self = shift @_;
- my $schema = shift @_;
-
- my @newly_created = ();
- foreach my $connect_info (@_) {
-
- my $replicant = $self->create_replicant($schema);
- $replicant->connect_info($connect_info);
- $replicant->ensure_connected;
- DBIx::Class::Storage::DBI::Replicated::Replicant->meta->apply($replicant);
-
- my ($key) = ($connect_info->[0]=~m/^dbi\:.+\:(.+)$/);
- $self->set_replicant( $key => $replicant);
- push @newly_created, $replicant;
- }
-
- return @newly_created;
+ my $self = shift @_;
+ my $schema = shift @_;
+
+ my @newly_created = ();
+ foreach my $connect_info (@_) {
+ my $replicant = $self->create_replicant($schema);
+ $replicant->connect_info($connect_info);
+ $replicant->ensure_connected;
+ DBIx::Class::Storage::DBI::Replicated::Replicant->meta->apply($replicant);
+ my ($key) = ($connect_info->[0]=~m/^dbi\:.+\:(.+)$/);
+ $self->set_replicant( $key => $replicant);
+ push @newly_created, $replicant;
+ }
+
+ return @newly_created;
}
=head2 connected_replicants
Returns true if there are connected replicants. Actually is overloaded to
return the number of replicants. So you can do stuff like:
- if( my $num_connected = $storage->has_connected_replicants ) {
- print "I have $num_connected connected replicants";
- } else {
- print "Sorry, no replicants.";
- }
+ if( my $num_connected = $storage->has_connected_replicants ) {
+ print "I have $num_connected connected replicants";
+ } else {
+ print "Sorry, no replicants.";
+ }
This method will actually test that each replicant in the L</replicants> hashref
is actually connected, try not to hit this 10 times a second.
=cut
sub connected_replicants {
- my $self = shift @_;
- return sum( map {
- $_->connected ? 1:0
- } $self->all_replicants );
+ my $self = shift @_;
+ return sum( map {
+ $_->connected ? 1:0
+ } $self->all_replicants );
}
=head2 active_replicants
=cut
sub active_replicants {
- my $self = shift @_;
- return ( grep {$_} map {
- $_->active ? $_:0
- } $self->all_replicants );
+ my $self = shift @_;
+ return ( grep {$_} map {
+ $_->active ? $_:0
+ } $self->all_replicants );
}
=head2 all_replicants
=cut
sub all_replicants {
- my $self = shift @_;
- return values %{$self->replicants};
+ my $self = shift @_;
+ return values %{$self->replicants};
}
=head2 validate_replicants
=cut
sub validate_replicants {
- my $self = shift @_;
- foreach my $replicant($self->all_replicants) {
- if(
- $replicant->is_replicating &&
- $replicant->lag_behind_master <= $self->maximum_lag &&
- $replicant->ensure_connected
- ) {
- ## TODO:: Hook debug for this
- $replicant->active(1)
- } else {
- ## TODO:: Hook debug for this
- $replicant->active(0);
- }
+ my $self = shift @_;
+ foreach my $replicant($self->all_replicants) {
+ if(
+ $replicant->is_replicating &&
+ $replicant->lag_behind_master <= $self->maximum_lag &&
+ $replicant->ensure_connected
+ ) {
+ ## TODO:: Hook debug for this
+ $replicant->active(1)
+ } else {
+ ## TODO:: Hook debug for this
+ $replicant->active(0);
}
-
- ## Mark that we completed this validation.
- $self->_last_validated(time);
+ }
+ ## Mark that we completed this validation.
+ $self->_last_validated(time);
}
=head1 AUTHOR
projects / dbsrgits/DBIx-Class.git / commitdiff