File Coverage

blib/lib/MongoDB/ReadPreference.pm

Criterion	Covered	Total	%
statement	48	49	97.9
branch	11	14	78.5
condition	7	9	77.7
subroutine	13	13	100.0
pod	0	3	0.0
total	79	88	89.7

#  Copyright 2014 - present MongoDB, Inc.
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#  http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

use strict;
use warnings;
package MongoDB::ReadPreference;

# ABSTRACT: Encapsulate and validate read preferences

use version;
our $VERSION = 'v2.2.2';

use Moo;
use MongoDB::Error;
use MongoDB::_Types qw(
    ArrayOfHashRef
    MaxStalenessNum
    NonNegNum
    ReadPrefMode
);
use namespace::clean -except => 'meta';

use overload (
    q[""]    => sub { $_[0]->mode },
    fallback => 1,
);

#pod =attr mode
#pod
#pod The read preference mode determines which server types are candidates
#pod for a read operation.  Valid values are:
#pod
#pod =for :list
#pod * primary
#pod * primaryPreferred
#pod * secondary
#pod * secondaryPreferred
#pod * nearest
#pod
#pod =cut

has mode => (
    is      => 'ro',
    isa     => ReadPrefMode,
    default => 'primary',
    coerce  => ReadPrefMode->coercion,
);

#pod =attr tag_sets
#pod
#pod The C parameter is an ordered list of tag sets used to restrict the
#pod eligibility of servers, such as for data center awareness.
#pod
#pod The application of C varies depending on the C parameter.  If
#pod the C is 'primary', then C must not be supplied.
#pod
#pod =cut

has tag_sets => (
    is      => 'ro',
    isa     => ArrayOfHashRef,
    default => sub { [ {} ] },
    coerce  => ArrayOfHashRef->coercion,
);

#pod =attr max_staleness_seconds
#pod
#pod The C parameter represents the maximum replication lag in
#pod seconds (wall clock time) that a secondary can suffer and still be
#pod eligible for reads. The default is -1, which disables staleness checks.
#pod
#pod If the C is 'primary', then C must not be supplied.
#pod
#pod =cut

has max_staleness_seconds => (
    is => 'ro',
    isa => MaxStalenessNum,
    default => -1,
);

sub BUILD {
    my ($self) = @_;

    if ( $self->mode eq 'primary' && !$self->has_empty_tag_sets ) {
        MongoDB::UsageError->throw("A tag set list is not allowed with read preference mode 'primary'");
    }

    if ( $self->mode eq 'primary' && $self->max_staleness_seconds > 0 ) {
        MongoDB::UsageError->throw("A positive max_staleness_seconds is not allowed with read preference mode 'primary'");
    }

    return;
}

# Returns true if the C array is empty or if it consists only of a
# single, empty hash reference.

sub has_empty_tag_sets {
    my ($self) = @_;
    my $tag_sets = $self->tag_sets;
    return @$tag_sets == 0 || ( @$tag_sets == 1 && !keys %{ $tag_sets->[0] } );
}

# Reformat to the document needed by mongos in $readPreference

sub _as_hashref {
    my ($self) = @_;
    return {
        mode => $self->mode,
        ( $self->has_empty_tag_sets ? () : ( tags => $self->tag_sets ) ),
        ( $self->max_staleness_seconds > 0 ? ( maxStalenessSeconds => int($self->max_staleness_seconds )) : () ),
    };
}

# Format as a string for error messages

sub as_string {
    my ($self) = @_;
    my $string = $self->mode;
    unless ( $self->has_empty_tag_sets ) {
        my @ts;
        for my $set ( @{ $self->tag_sets } ) {
            push @ts, keys(%$set) ? join( ",", map { "$_\:$set->{$_}" } sort keys %$set ) : "";
        }
        $string .= " (" . join( ",", map { "{$_}" } @ts ) . ")";
    }
    if ( $self->max_staleness_seconds > 0) {
        $string .= " ( maxStalenessSeconds: " . $self->max_staleness_seconds . " )";
    }
    return $string;
}


1;

__END__