blob: b8e380b154d38ecc2bf8a999944856ab0009e358 [file] [log] [blame]
#!/usr/bin/perl -w
###############################################################################
# $Id$
###############################################################################
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.
###############################################################################
=head1 NAME
VCL::Provisioning::docker - VCL module to support povisioning of docker
=head1 SYNOPSIS
Needs to be written
=head1 DESCRIPTION
This module provides...
=cut
##############################################################################
package VCL::Module::Provisioning::docker;
# Specify the lib path using FindBin
use FindBin;
use lib "$FindBin::Bin/../../..";
# Configure inheritance
use base qw(VCL::Module::Provisioning);
# Specify the version of this module
our $VERSION = '2.5.1';
# Specify the version of Perl to use
use 5.008000;
use strict;
use warnings;
use diagnostics;
use English qw(-no_match_vars);
use VCL::utils;
use LWP::UserAgent;
use JSON qw(from_json to_json encode_json decode_json);
##############################################################################
=head1 OBJECT METHODS
=cut
sub initialize {
my $self = shift;
notify($ERRORS{'DEBUG'}, 0, "Docker module initialized");
return 1;
} ## end sub initialize
#/////////////////////////////////////////////////////////////////////////////
=head2 load
Parameters :
Returns :
Description :
=cut
sub load {
my $self = shift;
if (ref($self) !~ /docker/i) {
notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
return;
}
my $image_name = $self->data->get_image_name() || return;
my $computer_id = $self->data->get_computer_id() || return;
my $computer_name = $self->data->get_computer_short_name() || return;
my $vmhost_public_ip_address = $self->vmhost_os->data->get_computer_public_ip_address(0) || return;
my $image_os_type = $self->data->get_image_os_type() || return;
# The docker daemon listens on unix:///var/run/docker.sock
# but you can Bind Docker to another host/port or a Unix socket
# set Docker daemon to listen on a specific IP and port
# set Docker host ip / port (/etc/init/docker.conf in Ubuntu 14.04 )
# (/usr/lib/systemd/system/docker.service in CentOS 7)
# e.g.,) docker -H tcp://0.0.0.0:4243 -H unix:///var/run/docker.sock -d &
my $docker_host_port = get_variable("docker_host_port"); # set docker host port in variable table, e.g., 4243
my $docker_host_url = "http://$vmhost_public_ip_address:$docker_host_port";
my $nathost_name = $self->data->get_nathost_hostname(0);
my $vmhost_name = $self->data->get_vmhost_short_name() || return;
my $using_nat_host = 0;
if (defined($nathost_name)) {
notify($ERRORS{'DEBUG'}, 0, "the VM hostname: $vmhost_name for computer: $computer_name is a nat host: $nathost_name");
notify($ERRORS{'DEBUG'}, 0, "computer: $computer_name will use random ports for nat");
$using_nat_host = 1;
}
# set ssh port of the vm_host (if not 22)
my $remote_connection_target = determine_remote_connection_target($vmhost_name);
# set the specific ssh port for vmhost in the variable table. e.g., 24
notify($ERRORS{'OK'}, 0, "remote_connection_target: $remote_connection_target");
my $target_ssh_port = get_variable("vmhost_ssh_port") || 22;
$ENV{ssh_port}{$remote_connection_target} = $target_ssh_port;
notify($ERRORS{'OK'}, 0, "vmhost_ssh_port: $target_ssh_port");
# create a useragent
my $ua = LWP::UserAgent->new();
# Using docker inspect to check whether there is any container with the same computer name or not
# if it exists, unload the previous one
my $resp = $ua->get(
$docker_host_url . "/containers/$computer_name/json",
content_type => 'application/json',
);
my $container_exist = 0;
eval {
from_json($resp->content);
$container_exist = 1;
} or do {
notify($ERRORS{'DEBUG'}, 0, "the container id for $computer_name does not exist: " . join("\n", $resp->content));
};
if ($container_exist) {
my $output = from_json($resp->content);
my $container_id = $output->{'Id'};
notify($ERRORS{'OK'}, 0, "container_id: [$container_id]");
if (defined($container_id)) {
notify($ERRORS{'WARNING'}, 0, "the container id for $computer_name already exists");
if(!$self->unload()) {
notify($ERRORS{'WARNING'}, 0, "failed to unload the container for $computer_name");
return 0;
}
}
}
# set the number of CPUs and memory size for the container
my $cpu_count = $self->data->get_image_minprocnumber() || 1;
notify($ERRORS{'OK'}, 0, "cpu_count: [$cpu_count]");
my $cpus = "0";
if ($cpu_count == 1) {
$cpus = "0";
}
else {
$cpu_count = $cpu_count - 1;
$cpus = "0-$cpu_count";
}
my $memory_mb = $self->data->get_image_minram();
my $memory_bytes = ($memory_mb * 1024 * 1024);
$memory_bytes = 0 + $memory_bytes;
my $eth0_mac_address = $self->data->get_computer_eth0_mac_address();
notify($ERRORS{'OK'}, 0, "eth0 mac: $eth0_mac_address, cpus: [$cpus], memory_bytes: [$memory_bytes]");
if (!defined($eth0_mac_address) || !defined($memory_bytes)) {
notify($ERRORS{'WARNINGS'}, 0, "eth0 mac address:[$eth0_mac_address] OR memory size: [$memory_bytes] is not defined for $computer_name");
return;
}
my $docker_default_ssh_port = get_variable("docker_default_ssh_port") || 22; # set docker container default ssh port in variable table, e.g., 22
my $docker_default_public_port = get_default_public_port($image_os_type);
if (!defined($docker_default_public_port)) {
notify($ERRORS{'WARNING'}, 0, "failed to get default public port for $computer_name");
return 0;
}
my $container_data;
# json docker create format of the container
if ($using_nat_host) {
# get a random ssh port for the container node for public access
my $random_ssh_port = $self->get_dockerhost_random_port($docker_default_ssh_port);
# get a random public port for public access of the applications (e.g., xrdp, lxde, rstudio)
my $random_public_port = $self->get_dockerhost_random_port($docker_default_public_port);
#my $random_vnc_port = $self->get_dockerhost_random_port($docker_default_vnc_port);
notify($ERRORS{'DEBUG'}, 0, "default_ssh_port: $docker_default_ssh_port, random_public_port: $docker_default_public_port");
notify($ERRORS{'DEBUG'}, 0, "random_ssh_port: $random_ssh_port, random_public_port: $random_public_port");
if (!defined($random_ssh_port) || !defined($random_public_port)) {
notify($ERRORS{'WARNING'}, 0, "failed to get ssh: $random_ssh_port, public: $random_public_port port for $computer_name");
return 0;
}
$container_data = {
Image => $image_name,
# MacAddress => $eth0_mac_address, # It could be used for future DHCP configuration.
HostConfig => {
Privileged => JSON::true, # 0/1 and true/false cause GO Marshall converting error
#Memory => 0 + $memory_bytes, # add 0 to avoid JSON format error (GO Marshall converting error)
# CpusetCpus => "$cpus", # This fixed and biased distribution would reduce the CPU utilization. Need more fair distribution methods.
# Docker uses all the available CPUs equally(Only set if you have better solutions)
CapAdd => ["NET_ADMIN"], #// allow to use iptables inside a container
#PublishAllPorts => JSON::true,
#NetworkMode => 'none' # default NetworkMode is bridge
PortBindings => {
"$docker_default_ssh_port\/tcp" => [{HostPort => $random_ssh_port }],
"$docker_default_public_port\/tcp" => [{HostPort => $random_public_port }],
# Examples
#"8080/tcp" => [{ HostPort => "" }],
#"8088/tcp" => [{ HostPort => "" }],
#"8443/tcp" => [{ HostPort => "" }],
#"18080/tcp" => [{ HostPort => "" }],
#"$docker_default_vnc_port\/tcp" => [{HostPort => $random_vnc_port }]
#"$docker_default_ssh_port\/tcp" => [{ HostIp => $vmhost_public_ip_address, HostPort => $random_ssh_port }],
#"$docker_default_public_port\/tcp" => [{ HostIp => $vmhost_public_ip_address, HostPort => $random_public_port }]
},
},
};
}
else {
$container_data = {
Image => $image_name,
# MacAddress => $eth0_mac_address, # It could be used for future DHCP configuration.
HostConfig => {
# Privileged => JSON::true, # 0/1 and true/false cause GO Marshall converting error
##Memory => 0 + $memory_bytes, # add 0 to avoid JSON format error (GO Marshall converting error)
# CpusetCpus => "$cpus", # This fixed and biased distribution would reduce the CPU utilization. Need more fair distribution methods.
# Docker uses all the available CPUs equally(Only set if you have better solutions)
CapAdd => ["NET_ADMIN"], #// allow to use iptables inside a container
NetworkMode => 'none' # default NetworkMode is bridge
},
};
}
# create the container
$resp = $ua->post(
$docker_host_url . "/containers/create?name=$computer_name",
content_type => 'application/json',
content => to_json($container_data),
);
if (!$resp->is_success) {
notify($ERRORS{'WARNING'}, 0, "failed to create a container for $computer_name: " . join("\n", $resp->content));
return;
}
notify($ERRORS{'DEBUG'}, 0, "successfully create a container: ". join("\n", $resp->content));
# start the container
$resp = $ua->post(
$docker_host_url . "/containers/$computer_name/start",
content_type => 'application/json',
);
if (!$resp->is_success) {
notify($ERRORS{'WARNING'}, 0, "failed to start the container for $computer_name: " . join("\n", $resp->content));
return;
}
notify($ERRORS{'DEBUG'}, 0, "successfully start the container: ". join("\n", $resp->content));
$resp = $ua->get(
$docker_host_url . "/containers/$computer_name/json",
content_type => 'application/json',
);
eval {
from_json($resp->content);
1;
} or do {
notify($ERRORS{'DEBUG'}, 0, "the container id for $computer_name does not exist: " . join("\n", $resp->content));
return;
};
my $output = from_json($resp->content);
my $container_pid = $output->{State}{Pid};
if (!defined($container_pid)) {
notify($ERRORS{'WARNING'}, 0, "failed to get Pid of the container on $computer_name");
return;
}
# if docker uses dhcp server to assign IPs to computer
if ($using_nat_host) {
my $ua_output = from_json($resp->content);
my $private_ip = $ua_output->{NetworkSettings}{IPAddress};
if (!defined($private_ip)) {
notify($ERRORS{'WARNINGS'}, 0, "private IP address is not defined for $computer_name");
return;
}
# YOUNG update /etc/hosts
`sed -i "/.*\\b$computer_name\$/d" /etc/hosts`;
`echo "$private_ip\t$computer_name" >> /etc/hosts`;
# update the private ip address of the computer
my $result = update_computer_private_ip_address($computer_id, $private_ip);
if (!defined($result)) {
notify($ERRORS{'WARNING'}, 0, "failed to update $private_ip on $computer_name");
return 0;
}
notify($ERRORS{'DEBUG'}, 0, "private IP address is $private_ip for $computer_name");
} else {
# add eth0 to the container
#my $private_nic = get_variable("docker_container_private_nic");
#my $private_bridge = get_variable("docker_host_privae_bridge");
my $container_private_nic = "eth0";
my $private_bridge = 'br0';
#my $private_bridge = $self->data->get_vmhost_profile_virtualswitch0(0) || 'br0';
if(!$self->create_eth_inside_container($container_pid, $container_private_nic, $private_bridge)) {
notify($ERRORS{'WARNING'}, 0, "failed to create eth0 inside the container on $computer_name");
return;
}
# add eth1 to the container
#my $public_nic = get_variable("docker_container_public_nic");
#my $public_bridge = get_variable("docker_host_public_bridge");
my $container_public_nic = "eth1";
my $public_bridge = 'br1';
#my $public_bridge = $self->data->get_vmhost_profile_virtualswitch1(0) || 'br1';
if(!$self->create_eth_inside_container($container_pid, $container_public_nic, $public_bridge)) {
notify($ERRORS{'WARNING'}, 0, "failed to create eth1 inside the container on $computer_name");
return;
}
# sleep to get dhcp
sleep(20);
}
# Call post_load
if ($self->os->can("post_load")) {
notify($ERRORS{'DEBUG'}, 0, "calling " . ref($self->os) . "->post_load()");
if ($self->os->post_load()) {
notify($ERRORS{'DEBUG'}, 0, "successfully ran OS post_load subroutine");
}
else {
notify($ERRORS{'WARNING'}, 0, "failed to run OS post_load subroutine");
return;
}
}
else {
notify($ERRORS{'WARNING'}, 0, ref($self->os) . "::post_load() has not been implemented");
return;
}
return 1;
} ## end sub load
#/////////////////////////////////////////////////////////////////////////////
=head2 create_eth_inside_container
Parameters : container process id
Returns : 1(success) or 0(failure)
Description :
=cut
sub create_eth_inside_container {
my $self = shift;
my $container_pid = shift;
my $eth_name = shift;
my $bridge_name = shift;
notify($ERRORS{'DEBUG'}, 0, "container_pid: $container_pid");
notify($ERRORS{'DEBUG'}, 0, "ethernet_name: $eth_name");
if (ref($self) !~ /docker/i) {
notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
return 0;
}
my $computer_name = $self->data->get_computer_short_name() || return;
my $veth_eth_name = $eth_name . $container_pid;
my $veth_name = "v" . $eth_name . $container_pid;
# PreStep 1
my $netns_path = "/var/run/netns";
my $command = "mkdir -p /var/run/netns";
my ($exit_status, $output);
if (!$self->vmhost_os->file_exists($netns_path)) {
#($exit_status, $output) = $self->vmhost_os->execute($command,1,10,3,24);
($exit_status, $output) = $self->vmhost_os->execute($command);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "failed to create netns on $container_pid\ncommand: $command\nexit status: $exit_status\noutput:\n" . join("\n", @$output));
#return 0;
}
}
# PreStep 2
my $netns_veth_path = "/var/run/netns/$container_pid";
if (!$self->vmhost_os->file_exists($netns_veth_path)) {
$command = "ln -s /proc/$container_pid/ns/net /var/run/netns/$container_pid";
#($exit_status, $output) = $self->vmhost_os->execute($command,1,10,3,24);
($exit_status, $output) = $self->vmhost_os->execute($command);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "failed to create netns on $container_pid\ncommand: $command\nexit status: $exit_status\noutput:\n" . join("\n", @$output));
#return 0;
}
}
# Step 1
$command = "ip link add $veth_name type veth peer name $veth_eth_name";
#($exit_status, $output) = $self->vmhost_os->execute($command,1,10,3,24);
($exit_status, $output) = $self->vmhost_os->execute($command);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "failed to create veth pair on $container_pid\ncommand: $command\nexit status: $exit_status\noutput:\n" . join("\n", @$output));
#return 0;
}
# Step 2
$command = "brctl addif $bridge_name $veth_name";
#($exit_status, $output) = $self->vmhost_os->execute($command,1,10,3,24);
($exit_status, $output) = $self->vmhost_os->execute($command);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "failed to add interface to the veth on $container_pid\ncommand: $command\nexit status: $exit_status\noutput:\n" . join("\n", @$output));
#return 0;
}
my $mac_address;
if ($eth_name eq 'eth0') {
$mac_address = $self->data->get_computer_eth0_mac_address();
notify($ERRORS{'OK'}, 0, "mac address of the eth0: $mac_address");
}
elsif ($eth_name eq 'eth1') {
$mac_address = $self->data->get_computer_eth1_mac_address();
notify($ERRORS{'OK'}, 0, "mac address of the eth1: $mac_address");
}
if (!defined($mac_address)) {
notify($ERRORS{'WARNING'}, 0, "failed to get mac address: $mac_address");
#return 0;
}
# Step 3
$command = "ip link set $veth_name up";
($exit_status, $output) = $self->vmhost_os->execute($command);
#($exit_status, $output) = $self->vmhost_os->execute($command,1,10,3,24);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "failed to set the interface up on $container_pid\ncommand: $command\nexit status: $exit_status\noutput:\n" . join("\n", @$output));
#return 0;
}
# Step 4
$command = "ip link set $veth_eth_name netns $container_pid";
#($exit_status, $output) = $self->vmhost_os->execute($command,1,10,3,24);
($exit_status, $output) = $self->vmhost_os->execute($command);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "failed to set the interface up on $container_pid\ncommand: $command\nexit status: $exit_status\noutput:\n" . join("\n", @$output));
#return 0;
}
# Step 5
$command = "ip netns exec $container_pid ip link set dev $veth_eth_name name $eth_name";
#($exit_status, $output) = $self->vmhost_os->execute($command,1,10,3,24);
($exit_status, $output) = $self->vmhost_os->execute($command);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "failed to set the interface up on $container_pid\ncommand: $command\nexit status: $exit_status\noutput:\n" . join("\n", @$output));
#return 0;
}
# Step 6
$command = "ip netns exec $container_pid ip link set $eth_name address $mac_address";
#($exit_status, $output) = $self->vmhost_os->execute($command,1,10,3,24);
($exit_status, $output) = $self->vmhost_os->execute($command);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "failed to set the interface up on $container_pid\ncommand: $command\nexit status: $exit_status\noutput:\n" . join("\n", @$output));
#return 0;
}
$command = "ip netns exec $container_pid ip link set $eth_name up";
#($exit_status, $output) = $self->vmhost_os->execute($command,1,10,3,24);
($exit_status, $output) = $self->vmhost_os->execute($command);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "failed to set the interface up on $container_pid\ncommand: $command\nexit status: $exit_status\noutput:\n" . join("\n", @$output));
#return 0;
}
if ($eth_name eq 'eth1') {
$command = "docker exec $computer_name dhclient";
#$command = "docker exec $computer_name dhclient eth0 eth1";
#($exit_status, $output) = $self->vmhost_os->execute($command,1,10,3,24);
($exit_status, $output) = $self->vmhost_os->execute($command);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "failed to set the interface up on $container_pid\ncommand: $command\nexit status: $exit_status\noutput:\n" . join("\n", @$output));
#return 0;
}
}
return 1;
}
#/////////////////////////////////////////////////////////////////////////////
=head2 unload
Parameters : hash
Returns : 1(success) or 0(failure)
Description : loads virtual machine with requested image
=cut
sub unload {
my $self = shift;
if (ref($self) !~ /docker/i) {
notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
return;
}
my $image_name = $self->data->get_image_name() || return;
my $computer_name = $self->data->get_computer_short_name() || return;
my $vmhost_name = $self->data->get_vmhost_short_name() || return;
my $vmhost_public_ip_address = $self->vmhost_os->data->get_computer_public_ip_address(0) || return;
my $vmhost_internal_ip_address = $self->vmhost_os->data->get_computer_private_ip_address(0) || return;
my $docker_host_port = get_variable("docker_host_port"); # set docker host port in variable table, e.g., 4243
my $docker_host_url = "http://$vmhost_public_ip_address:$docker_host_port";
# set ssh port of the vm_host (if not 22)
my $remote_connection_target = determine_remote_connection_target($vmhost_name);
# set the specific ssh port for vmhost in the variable table. e.g., 24
my $target_ssh_port = get_variable("vmhost_ssh_port") || 22;
$ENV{ssh_port}{$remote_connection_target} = $target_ssh_port;
# create a useragent
my $ua = LWP::UserAgent->new();
# stop the container
my $resp = $ua->post(
$docker_host_url . "/containers/$computer_name/stop",
content_type => 'application/json',
);
if (!$resp->is_success) {
notify($ERRORS{'WARNING'}, 0, "failed to stop the container for $computer_name: " . join("\n", $resp->content));
return;
}
sleep(1);
$resp = $ua->delete(
$docker_host_url . "/containers/$computer_name",
content_type => 'application/json',
);
if (!$resp->is_success) {
notify($ERRORS{'WARNING'}, 0, "failed to delete the container for $computer_name: " . join("\n", $resp->content));
return;
}
# delete dangled network namespace ids
my $nathost_name = $self->data->get_nathost_hostname(0);
if (!defined($nathost_name)) {
notify($ERRORS{'DEBUG'}, 0, "docker container $computer_name is not running in a NATHOST");
my $command = "find -L /var/run/netns -type l -delete";
#my ($exit_status, $output) = $self->vmhost_os->execute($command,1,10,3,24);
my ($exit_status, $output) = $self->vmhost_os->execute($command);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "delete dangled veth on $computer_name\ncommand: $command\nexit status: $exit_status\noutput:\n" . join("\n", @$output));
}
}
notify($ERRORS{'DEBUG'}, 0, "docker container $computer_name is completely removed");
sleep(10);
return 1;
} ## end sub unload
#/////////////////////////////////////////////////////////////////////////////
=head2 capture
Parameters : None
Returns : 1 if sucessful, 0 if failed
Description : capturing a new OpenStack image.
=cut
sub capture {
my $self = shift;
if (ref($self) !~ /docker/i) {
notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
return;
}
notify($ERRORS{'OK'}, 0, "Docker Capturing....");
my $old_image_name = $self->data->get_image_name();
my $new_image_name = $self->get_new_image_name();
$self->data->set_image_name($new_image_name);
my $image_id = $self->data->get_image_id();
my $imagerevision_id = $self->data->get_imagerevision_id();
my $imagerevision_comments = $self->data->get_imagerevision_comments(0);
my $computer_name = $self->data->get_computer_short_name();
my $vmhost_public_ip_address = $self->vmhost_os->data->get_computer_public_ip_address(0);
my $docker_host_port = get_variable("docker_host_port"); # set docker host port in variable table, e.g., 4243
my $docker_host_url = "http://$vmhost_public_ip_address:$docker_host_port";
if ($self->os->can("pre_capture")) {
notify($ERRORS{'OK'}, 0, "calling OS module's pre_capture() subroutine");
# do not turn the container off to run "docker commit"
if (!$self->os->pre_capture({end_state => 'on'})) {
notify($ERRORS{'WARNING'}, 0, "OS module pre_capture() failed");
return 0;
}
}
my $ua = LWP::UserAgent->new();
my $resp = $ua->get(
$docker_host_url . "/containers/$computer_name/json",
content_type => 'application/json',
);
eval {
from_json($resp->content);
1;
} or do {
notify($ERRORS{'DEBUG'}, 0, "the container id for $computer_name does not exist: " . join("\n", $resp->content));
return 0;
};
my $output = from_json($resp->content);
my $container_id = $output->{'Id'};
notify($ERRORS{'OK'}, 0, "container_id: [$container_id]");
if (!defined($container_id)) {
notify($ERRORS{'WARNING'}, 0, "failed to get the container id for $computer_name");
return 0;
}
$resp = $ua->post(
$docker_host_url . "/commit?container=$container_id&comment=$imagerevision_comments&repo=$new_image_name",
content_type => 'application/json',
);
if (!$resp->is_success) {
notify($ERRORS{'WARNING'}, 0, "failed to commit the container for $computer_name: " . join("\n", $resp->content));
return;
}
# Update the image name in the database
if ($old_image_name ne $new_image_name && !update_image_name($image_id, $imagerevision_id, $new_image_name)) {
notify($ERRORS{'WARNING'}, 0, "failed to update image name in the database: $old_image_name --> $new_image_name");
return;
}
sleep(10);
notify($ERRORS{'DEBUG'}, 0, "successfully captured the container for $computer_name");
if(!$self->unload()) {
notify($ERRORS{'WARNING'}, 0, "failed to unload the container for $computer_name");
return 0;
}
return 1;
} ## end sub capture
#/////////////////////////////////////////////////////////////////////////////
=head2 get_image_size
Parameters : imagename
Returns : 0 failure or size of image
Description : in size of Megabytes
=cut
sub get_image_size {
my $self = shift;
if (ref($self) !~ /docker/i) {
notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
return 0;
}
my $image_name = $self->data->get_image_name() || return;
my $vmhost_public_ip_address = $self->vmhost_os->data->get_computer_public_ip_address(0);
my $docker_host_port = get_variable("docker_host_port"); # set docker host port in variable table, e.g., 4243
my $docker_host_url = "http://$vmhost_public_ip_address:$docker_host_port";
# create a useragent
my $ua = LWP::UserAgent->new();
my $resp = $ua->get(
$docker_host_url . "/images/json?filter=$image_name",
content_type => 'application/json',
);
if (!$resp->is_success) {
notify($ERRORS{'WARNING'}, 0, "failed to get image info: " . join("\n", $resp->content));
return 0;
}
my $output = from_json($resp->content);
if (!defined($output)) {
notify($ERRORS{'WARNING'}, 0, "failed to parse json output");
return 0;
}
my $image_size = $output->[0]{'VirtualSize'};
if (!defined($image_size)) {
notify($ERRORS{'WARNING'}, 0, "The docker image size for $image_name does not be defined");
return 0;
}
else
{
notify($ERRORS{'OK'}, 0, "The docker image size for $image_name is $image_size");
return round($image_size); # Mbytes
}
} ## end sub get_image_size
#/////////////////////////////////////////////////////////////////////////////
=head2 power_reset
Parameters : $computer_node_name (optional)
Returns : boolean
Description : Powers off and then powers on the computer.
=cut
sub power_reset() {
my $self = shift;
unless (ref($self) && $self->isa('VCL::Module')) {
notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
return;
}
## To DO (YOUNG)
# restart the docker container remove the veth
notify($ERRORS{'OK'}, 0, "Power_reset does NOT support for Docker");
return 1;
my $computer_name = $self->data->get_computer_short_name() || return;
notify($ERRORS{'OK'}, 0, "computer_name: $computer_name");
my $vmhost_public_ip_address = $self->vmhost_os->data->get_computer_public_ip_address(0);
my $docker_host_port = get_variable("docker_host_port"); # set docker host port in variable table, e.g., 4243
my $docker_host_url = "http://$vmhost_public_ip_address:$docker_host_port";
# create a useragent
my $ua = LWP::UserAgent->new();
my $resp = $ua->post(
$docker_host_url . "/containers/$computer_name/restart",
content_type => 'application/json',
);
if (!$resp->is_success) {
notify($ERRORS{'WARNING'}, 0, "failed to restart the container for $computer_name: " . join("\n", $resp->content));
return;
}
notify($ERRORS{'OK'}, 0, "The docker container is successfully restarted");
return 1;
} ## end sub power_reset
#/////////////////////////////////////////////////////////////////////////////
=head2 node_status
Parameters : [0]: computer node name (optional)
[1]: log file path (optional)
Returns : Depends on the context which node_status was called:
default: string containing "READY" or "FAIL"
boolean: true if ping, SSH, and VCL client checks are successful
false if any checks fail
list: array, values are 1 for SUCCESS, 0 for FAIL
[0]: Node status ("READY" or "FAIL")
[1]: Ping status (0 or 1)
[2]: SSH status (0 or 1)
[3]: VCL client daemon status (0 ir 1)
arrayref: reference to array described above
hashref: reference to hash with keys/values:
{status} => <"READY","FAIL">
{ping} => <0,1>
{ssh} => <0,1>
{vcl_client} => <0,1>
Description : Checks the status of a lab machine. Checks if the machine is
pingable, can be accessed via SSH, and the VCL client is running.
=cut
sub node_status{
my $self;
# Get the argument
my $argument = shift;
# Check if this subroutine was called an an object method or an argument was passed
if (ref($argument) =~ /VCL::Module/i) {
$self = $argument;
}
elsif (!ref($argument) || ref($argument) eq 'HASH') {
# An argument was passed, check its type and determine the computer ID
my $computer_id;
if (ref($argument)) {
# Hash reference was passed
$computer_id = $argument->{id};
}
elsif ($argument =~ /^\d+$/) {
# Computer ID was passed
$computer_id = $argument;
}
else {
# Computer name was passed
($computer_id) = get_computer_ids($argument);
}
if ($computer_id) {
notify($ERRORS{'DEBUG'}, 0, "computer ID: $computer_id");
}
else {
notify($ERRORS{'WARNING'}, 0, "unable to determine computer ID from argument:\n" . format_data($argument));
return;
}
# Create a DataStructure object containing data for the computer specified as the argument
my $data;
eval {
$data= new VCL::DataStructure({computer_identifier => $computer_id});
};
if ($EVAL_ERROR) {
notify($ERRORS{'WARNING'}, 0, "failed to create DataStructure object for computer ID: $computer_id, error: $EVAL_ERROR");
return;
}
elsif (!$data) {
notify($ERRORS{'WARNING'}, 0, "failed to create DataStructure object for computer ID: $computer_id, DataStructure object is not defined");
return;
}
else {
notify($ERRORS{'DEBUG'}, 0, "created DataStructure object for computer ID: $computer_id");
}
# Create a VMware object
my $object_type = 'VCL::Module::Provisioning::docker';
if ($self = ($object_type)->new({data_structure => $data})) {
notify($ERRORS{'DEBUG'}, 0, "created $object_type object to check the status of computer ID: $computer_id");
}
else {
notify($ERRORS{'WARNING'}, 0, "failed to create $object_type object to check the status of computer ID: $computer_id");
return;
}
# Create an OS object for the VMware object to access
if (!$self->create_os_object()) {
notify($ERRORS{'WARNING'}, 0, "failed to create OS object");
return;
}
}
# Create a hash reference and populate it with the default values
my $status;
$status->{currentimage} = '';
$status->{ssh} = 0;
$status->{image_match} = 0;
$status->{status} = 'RELOAD';
return $status;
} ## end sub node_status
#/////////////////////////////////////////////////////////////////////////
=head2 does_image_exist
Parameters :
Returns : 1 or 0
Description : Checks the existence of an image.
=cut
sub does_image_exist {
my $self = shift;
if (ref($self) !~ /docker/i) {
notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
return 0;
}
my $image_name = $self->data->get_image_name();
my $vmhost_public_ip_address = $self->vmhost_os->data->get_computer_public_ip_address(0);
my $docker_host_port = get_variable("docker_host_port"); # set docker host port in variable table, e.g., 4243
my $docker_host_url = "http://$vmhost_public_ip_address:$docker_host_port";
notify($ERRORS{'DEBUG'}, 0, "find image name: $image_name in docker host: $docker_host_url");
my $ua = LWP::UserAgent->new();
my $resp = $ua->get(
$docker_host_url . "/images/$image_name/json",
content_type => 'application/json',
);
eval {
from_json($resp->content);
1;
} or do {
notify($ERRORS{'DEBUG'}, 0, "the image id for $image_name does not exist: " . join("\n", $resp->content));
return 0;
};
my $output = from_json($resp->content);
my $image_id = $output->{'Id'};
notify($ERRORS{'OK'}, 0, "image_id: [$image_id]");
if (!defined($image_id)) {
notify($ERRORS{'WARNING'}, 0, "The docker image for $image_name does not exist");
return 0;
}
else
{
notify($ERRORS{'OK'}, 0, "The docker image for $image_name exists");
return 1;
}
} ## end sub does_image_exist
#/////////////////////////////////////////////////////////////////////////////
=head2 get_default_public_port
Parameters :
Returns : string
Description : Find the default public port for the image based on the connect method
=cut
sub get_default_public_port {
my $image_os_type = shift;
if (!defined($image_os_type)) {
notify($ERRORS{'WARNING'}, 0, "failed to get image os type");
return;
}
my $sql_statement = <<EOF;
SELECT
port
FROM
connectmethodport
WHERE
connectmethodid = (
SELECT id
FROM
connectmethod
WHERE
name = '$image_os_type')
EOF
notify($ERRORS{'DEBUG'}, 0, "$sql_statement");
my @selected_rows = database_select($sql_statement);
if (scalar @selected_rows == 0 || scalar @selected_rows > 1) {
notify($ERRORS{'WARNING'}, 0, "" . scalar @selected_rows . " rows were returned from database select");
return;
}
my $default_public_port = $selected_rows[0]{port};
if (!defined($default_public_port)) {
notify($ERRORS{'WARNING'}, 0, "failed to get default public port");
return;
}
notify($ERRORS{'DEBUG'}, 0, "default public port for $image_os_type is $default_public_port");
return $default_public_port;
}
#/////////////////////////////////////////////////////////////////////////////
=head2 get_new_image_name
Parameters :
Returns : string
Description : Constructs a new image name for images being captured. This is
used instead of the name in the database in case an image is
converted. The new image name shouldn't contain vmware.
=cut
sub get_new_image_name {
my $self = shift;
if (ref($self) !~ /docker/i) {
notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
return;
}
my $image_id = $self->data->get_image_id();
my $image_os_name = $self->data->get_image_os_name();
my $image_prettyname = $self->data->get_image_prettyname();
my $imagerevision_revision = $self->data->get_imagerevision_revision();
# Clean up the OS name
$image_os_name = "docker";
# Remove non-word characters and underscores from the image prettyname
$image_prettyname =~ s/[\W\_]+//ig;
my $new_image_name = "$image_os_name\-$image_prettyname"."$image_id\-v$imagerevision_revision";
notify($ERRORS{'DEBUG'}, 0, "new_image_name: [$new_image_name]");
return $new_image_name;
} ## end sub get_new_image_name
#/////////////////////////////////////////////////////////////////////////////
=head2 get_dockerhost_random_port
Parameters : $remote_ip (optional), $overwrite
Returns : ssh_port or public_port
Description : Processes the random port for the connect methods configured for the image revision.
=cut
sub get_dockerhost_random_port{
my $self = shift;
my $default_port = shift;
notify($ERRORS{'DEBUG'}, 0, "default_port: $default_port");
if (ref($self) !~ /docker/i) {
notify($ERRORS{'CRITICAL'}, 0, "subroutine was called as a function, it must be called as a class method");
return;
}
my $image_name = $self->data->get_image_name();
my $computer_node_name = $self->data->get_computer_node_name();
my $nathost_hostname = $self->data->get_nathost_hostname(0);
my $nathost_public_ip_address = $self->data->get_nathost_public_ip_address(0);
# Retrieve the connect method info hash
my $connect_method_info = $self->data->get_connect_methods();
if (!$connect_method_info) {
notify($ERRORS{'WARNING'}, 0, "failed to retrieve connect method info");
return;
}
CONNECT_METHOD: for my $connect_method_id (sort keys %{$connect_method_info} ) {
my $connect_method = $connect_method_info->{$connect_method_id};
for my $connect_method_port_id (keys %{$connect_method->{connectmethodport}}) {
my $protocol = $connect_method->{connectmethodport}{$connect_method_port_id}{protocol};
my $port = $connect_method->{connectmethodport}{$connect_method_port_id}{port};
if ($port == $default_port) {
my $random_port = $connect_method->{connectmethodport}{$connect_method_port_id}{natport}{publicport};
if (!defined($random_port)) {
notify($ERRORS{'WARNING'}, 0, "$computer_node_name is assigned to NAT host $nathost_hostname but connect method info does not contain NAT port information:\n" . format_data($connect_method));
return;
}
else {
return $random_port;
}
}
# notify($ERRORS{'WARNING'}, 0, "$computer_node_name is assigned to NAT host $nathost_hostname but connect method info does not contain NAT port information:\n" . format_data($connect_method));
}
}
return;
} ## end sub get_dockerhost_random_port
#/////////////////////////////////////////////////////////////////////////////
1;
__END__
=head1 SEE ALSO
L<http://cwiki.apache.org/VCL/>
=cut