File Coverage

blib/lib/MongoDB/WriteConcern.pm

Criterion	Covered	Total	%
statement	47	49	95.9
branch	22	22	100.0
condition	6	9	66.6
subroutine	14	15	93.3
pod	0	1	0.0
total	89	96	92.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::WriteConcern;

# ABSTRACT: Encapsulate and validate a write concern

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

use Moo;
use MongoDB::Error;
use MongoDB::_Types qw(
    Boolish
);
use Types::Standard qw(
    ArrayRef
    Int
    Str
    Maybe
);
use Scalar::Util qw/looks_like_number/;
use boolean;
use namespace::clean -except => 'meta';

#pod =attr w
#pod
#pod Specifies the desired acknowledgement level. If not set, the
#pod server default will be used, which is usually "1".
#pod
#pod =cut

has w => (
    is        => 'ro',
    isa       => Maybe[Str],
);

#pod =attr wtimeout
#pod
#pod Specifies how long to wait for the write concern to be satisfied (in
#pod milliseconds).  Defaults to 1000. If you set this to undef, it could block
#pod indefinitely (or until socket timeout is reached).
#pod
#pod =cut

has wtimeout => (
    is      => 'ro',
    isa     => Maybe[Int],
    default => 1000,
);

#pod =attr j
#pod
#pod The j option confirms that the mongod instance has written the data to the
#pod on-disk journal.  Defaults to false.
#pod
#pod B: specifying a write concern that set j to a true value may result in an
#pod error with a mongod or mongos running with --nojournal option now errors.
#pod
#pod =cut

has j => (
    is        => 'ro',
    isa       => Boolish,
);

has _is_acknowledged => (
    is      => 'lazy',
    isa     => Boolish,
    reader  => 'is_acknowledged',
    builder => '_build_is_acknowledged',
);

has _as_args => (
    is      => 'lazy',
    isa     => ArrayRef,
    reader  => 'as_args',
    builder => '_build_as_args',
);

sub _build_is_acknowledged {
    my ($self) = @_;
    return !!( $self->j || $self->_w_is_acknowledged );
}

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

    my $wc = {
        ( defined( $self->w )        ? ( w        => $self->w )            : () ),
        ( defined( $self->wtimeout ) ? ( wtimeout => 0+ $self->wtimeout )  : () ),
        ( defined( $self->j )        ? ( j        => boolean( $self->j ) ) : () ),
    };

    return ( keys %$wc ? [writeConcern => $wc] : [] );
}

sub BUILD {
    my ($self) = @_;
    if ( ! $self->_w_is_valid ) {
        MongoDB::UsageError->throw("can't use write concern w=" . $self->w );
    }

    if ( ! $self->_w_is_acknowledged && $self->j ) {
        MongoDB::UsageError->throw("can't use write concern w=0 with j=" . $self->j );
    }

    # cant use nonnegnum earlier in type as errors explode with wrong class
    if ( defined($self->wtimeout) && $self->wtimeout < 0 ) {
        MongoDB::UsageError->throw("wtimeout must be non negative");
    }
    return;
}

sub _w_is_valid {
  my ($self) = @_;
  return 1 if !defined $self->w;
  return looks_like_number( $self->w ) ? $self->w >= 0 : length $self->w;
}

sub _w_is_acknowledged {
    my ($self) = @_;
    return 1 if !defined $self->w;
    return looks_like_number( $self->w ) ? $self->w > 0 : length $self->w;
}


1;

__END__