view release on metacpan or  search on metacpan

lib/Net/OpenNebula/RPC.pm  view on Meta::CPAN

    # reset $merge to integer value; undef implies merge = 0
    if ($merge) {
        $merge = 1;
    } else {
        $merge = 0;
    }

    $self->has_id("update") || return;

    return $self->_onerpc("update",
                          [ int => $self->id ],
                          [ string => $tpl ],
                          [ int => $merge ]
                          );
}

sub _lookup
{
    my ($self, $type, $id, $one) = @_;

    $id = -1 if ! defined($id);

    my $err;
    if ($id !~ m/^-?\d+$/) {
        my $msg = "Non-integer ${type}name $id";
        if ($one) {
            my $method = "get_${type}s";
            $self->debug(1, "$msg, looking up id using $method");
            my @found = $one->$method($id);
            if (@found) {
                if (scalar @found > 1) {
                    $self->warn("$msg and more than one $type found: ".join(", ", @found));
                }
                $id = $found[0]->id();
                $self->debug(1, "$msg resolved to id $id");
            } else {
                $err = "$msg and no matching ${type}s found.";
            }
        } else {
            $err = "$msg and no ONE instance provided";
        }
    }

    if ($err) {
        $self->error($err);
        return;
    } else {
        return $id;
    }
}


# Chown
# options
#    uid : uid to use
#    gid : gid to use
#    one : Net::OpenNebula instance to use for user/groupname lookup
#          (i.e. when uid/gid is not a integer)
#          It wil use $one->get_users and/or $one->get_groups methods.

sub chown
{
    my ($self, %opts) = @_;

    $self->has_id("chown") || return;

    my $uid = $self->_lookup('user', $opts{uid}, $opts{one});
    return if ! defined($uid);

    my $gid = $self->_lookup('group', $opts{gid}, $opts{one});
    return if ! defined($gid);

    return $self->_onerpc("chown",
                          [ int => $self->id ],
                          [ int => $uid ],
                          [ int => $gid ]
                          );
}


# Mode can be
#   an integer, typical in octal mode 0664, but can be decimal or whatever
sub chmod
{
    my ($self, $mode) = @_;

    $self->has_id("chmod") || return;

    my @bits;
    if ($mode =~ m/^\d+/) {
        my $bin = sprintf("%b", $mode & oct("777"));
        @bits = split('', $bin);
    } else {
        $self->error("chown cannot handle mode $mode");
        return;
    };

    if((scalar @bits) == 9) {
        my @allargs = qw(chmod);
        push(@allargs, [ int => $self->id ], map {[ int => $_ ]} @bits);
        return $self->_onerpc(@allargs);
    } else {
        $self->error("9 permissions bits required, got ".join(",", @bits));
        return;
    }
}


# When C<nameregex> is defined, only instances with name matching
# the regular expression are returned (if any).
# C<nameregex> is a compiled regular expression (e.g. qr{^somename$}).
sub _get_instances {
    my ($self, $nameregex, @args) = @_;

    my $class = ref $self;
    my $pool = $class->ONERPC . "pool";
    my $key = $class->ONEPOOLKEY || uc($class->ONERPC);

    my @ret = ();
    my $info = "info";

    # Change VM info by new infoextended if version >= 5.8.x
    if (($self->{rpc}->version() >= version->new('5.8.0')) and ($pool eq "vmpool")) {
        $info = 'infoextended';
        push(@args, [ string => "" ]);
    };

    my $reply = $self->{rpc}->_rpc("one.$pool.$info", @args);

    foreach my $data (@{ $reply->{$key} }) {
        # This is data from pool.info, so it is as complete as individual info
        # so we can set it as extended_data
        my $inst = $self->new(rpc => $self->{rpc}, data => $data, extended_data => $data);
        if (! defined($nameregex) || ($inst->name && $inst->name =~ $nameregex) ) {
            push(@ret, $inst);
        }
    }

    return @ret;
}

# Given state, wait until the state is reached.
# Between each check, sleep number of seconds;
# and there's a maximum number of iterations to try.
# Return 1 if the state is reached, 0 otherwise.
# state: the state (in text) to wait for
# opts:
#    sleep: sleep per interval
#    max_iter: maximum iterations (if 0, no sleep)
sub wait_for_state {
    my ($self, $state, %opts) = @_;

    my $sleep = 5; # in seconds
    my $max_iter = 200; # approx 15 minutes with default sleep