Origo OS

#!/usr/bin/perl

use JSON;

use URI::Escape::XS qw/uri_escape uri_unescape/;

use ConfigReader::Simple;

use Cwd;

use Data::Dumper;

# use Getopt::Std;

use Getopt::Long qw(GetOptions);

Getopt::Long::Configure qw(gnu_getopt); # Allow combining short options

our %options=();

# Getopt::Std::getopts("rapdfsu", \%options);

GetOptions(\%options, 'rebuild|r', 'activate|a', 'publish|p', 'debug|d', 'force|f', 'release|s', 'unrelease|u', 'freshen|h');

my $ofile = $ARGV[(scalar @ARGV)-1] if @ARGV;

my $rebuild = 1 if ($options{rebuild});

my $activate = 1 if ($options{activate});

my $publish = 1 if ($options{publish});

my $release = 1 if ($options{release});

my $debug = 1 if ($options{debug});

my $force = 1 if ($options{force});

my $freshen = 1 if ($options{freshen});

my $unrelease = 1 if ($options{unrelease});

$release = 1 if ($unrelease);

my $cwd = cwd();

my $gw = `route -n | awk '\$1 == "0.0.0.0" { print \$2 }'`;

chomp $gw;

unless ($ofile) {

    opendir(DIR, ".");

    my @files = grep(/\.stack$/,readdir(DIR));

    closedir(DIR);

    if (@files) {

        $ofile = $files[0];

        print "Using $ofile as stackfile\n";

    } else {

        print <<end

Usage: stackbuilder [-a] [-p] [-r] [-d] [-f] 'stackfile'

-a, --activate

-p, --publish

-r, --rebuild

-s, --release

-d, --debug

-f, --force

-u, --unrelease

-h, --freshen

end

;

        print "To force rebuild, activate and publish in one go use -frap\n";

        exit;

    }

}

unless (-e $ofile) {

    print "Stabile file not found: $ofile\n";

    print "Usage: stackbuilder [-a] [-p] [-r] [-d] [-f] 'stackfile'\n-a activate\n-p publish\n-r rebuild\n-s release\n-d debug\n-f force activate\n-u unrelease\n";

    print "To force rebuild, activate, publish and release in one go use -rapsf\n";

    exit;

}

my $config = ConfigReader::Simple->new($ofile);

chdir $1 if ($ofile =~ /(.*\/).+/);

# The version of the app we are building

my $version = $config->get("VERSION") || '1.0';

my $baseimage = $config->get("BASEIMAGE");

my $rebase = $config->get("REBASE");

my $basesuite = $config->get("BASESUITE") || 'xenial';

my $basename = $config->get("BASENAME") || 'ubuntu-16.04';

$basename = 'ubuntu-18.04' if ($basesuite eq 'bionic');

$basename = 'ubuntu-20.04' if ($basesuite eq 'focal');

$basename = 'ubuntu-22.04' if ($basesuite eq 'jammy');

my $name = $config->get("NAME");

die "You must supply a name [NAME]" unless ($name);

my $appname = $config->get("APPNAME");

my $dir = $config->get("DIR");

die "Directory '$dir' [DIR] does not exist" unless (!$dir || -d $dir);

my $dirtarget = $config->get("DIRTARGET") || '/tmp';

my $tar = $config->get("TAR");

my $tartarget = $config->get("TARTARGET") || '/tmp';

my $tarowner = $config->get("TAROWNER");

my $git = $config->get("GIT");

my $gittarget = $config->get("GITTARGET") || '/tmp';

my $gitowner = $config->get("GITOWNER");

my $downloadurl = $config->get("DOWNLOADURL");

my $debs = $config->get("DEBS");

my $preexec = $config->get("PREEXEC");

my $postexec = $config->get("POSTEXEC");

my $service = $config->get("SERVICE");

my $dname="$name.$version";

my $size=$config->get("SIZE") || 9216;

my $masterpath;

my $managementlink = $config->get("MANAGEMENTLINK") || '';

my $upgradelink = $config->get("UPGRADELINK") || '';

my $terminallink = $config->get("TERMINALLINK") || '';

my $vcpu = $config->get("VCPU") || '';

my $memory = $config->get("MEMORY") || '';

my $logo = $config->get("LOGO") || '';

my $price = $config->get("PRICE") || '';

my $thumbnail = $config->get("THUMBNAIL") || '';

my $ports = $config->get("PORTS") || '';

my $summary = $config->get("SUMMARY") || '';

my $description = $config->get("DESCRIPTION") || '';

my $appid = $config->get("APPID") || '';

my $instances = $config->get("INSTANCES") || '';

my $dataimage = $config->get("DATAIMAGE") || '';

my $dataimagefs = $config->get("DATAIMAGEFS") || 'ext4';

my $storagepool = $config->get("STORAGEPOOL") || '';

my $storagepool2 = $config->get("STORAGEPOOL2") || '';

my $datamount = $config->get("DATAMOUNT") || '/mnt/data';

my $fuelpath = ''; # Is set below if we are in a VM

my $enginelinked = '';

my $imageuuid = '';

my $imageuser = '';

# Check if we are on an admin server or on a regular VM

unless (-e "/mnt/stabile/images" || -e "/stabile-images/images") {

    # Mount shared storage

    `curl --silent http://localhost:10000/stabile/index.cgi?action=mountpools`;

    $fuelpath = `cat /proc/mounts | grep '/mnt/fuel'`;

    die "Unable to mount shared storage" unless ($fuelpath =~ /(\/mnt\/fuel\/pool\d+)/);

    $fuelpath = $1;

    my $json = `curl --silent -k "https://$gw/stabile/users?action=listids"`;

    my $json_obj = from_json($json);

    $enginelinked = 1 if ($json_obj->{items}->[0]->{engine}->{enginelinked});

    $json = `curl --silent -k "https://$gw/stabile/images?image=$dname.master.qcow2"`;

    $json_obj = from_json($json);

    $imageuuid = $json_obj->{uuid} if ($json_obj->{uuid} && $json_obj->{uuid} ne '--');

    $imageuser = $json_obj->{user} if ($json_obj->{user} && $json_obj->{user} ne '--');

}

if (!$rebuild && -e "$cwd/$dname.master.qcow2") { # Master image already exists, try to activate and publish

    print "Found $cwd/$dname.master.qcow2, not building (specify -r to force rebuild)\n";

} elsif (!$rebuild && $imageuuid) {

    print "$dname.master.qcow2 is already activated on engine by user $imageuser, not building (specify -r to force rebuild)\n";

} elsif (!$freshen) {

    # Load nbd

    print `killall qemu-nbd`;

    print `rmmod nbd`;

    print `modprobe nbd max_part=63`;

    unless (-e "$cwd/$dname.master.qcow2") {

        # If app is based on another image, get a link to it, and mount it

        if ($baseimage) {

            my $basepath = "$cwd/$baseimage";

            if ($fuelpath) {

                print ">> Asking engine to link or copy $baseimage\n";

                print qq|>> curl --silent -k "https://$gw/stabile/images/?action=linkmaster&image=$baseimage"|;

                my $json = `curl --silent -k "https://$gw/stabile/images/?action=linkmaster&image=$baseimage"`;

                print $json;

                my $jobj = from_json($json);

                my $linkpath = $jobj->{linkpath};

                $basepath = $jobj->{path};

                $masterpath = $jobj->{masterpath};

                unless ($basepath) {

                    print ">> No base path received. Perhaps master image is not on fuel storage?\n";

                    print $json, "\n";

                    exit 0;

                }

                while (!(-e $basepath)) {

                    print ">> Waiting for $basepath...\n";

                    sleep 1

                }

            } elsif (!(-e "$cwd/$baseimage")) {

                print ">> You are trying to build an image which depends on a baseimage, $baseimage, which is not available\n";

                exit;

            }

            # Clone base image

            if (-e "$cwd/$dname.master.qcow2") {

                print ">> Destination image already exists: $cwd/$dname.master.qcow2\n";

            } else {

                print `qemu-img create -f qcow2 -b "$basepath" "$cwd/$dname.master.qcow2"`;

            }

    # No baseimage, let's build image from scratch or download

        } else {

            if ($downloadurl) {

                my $dlname = "$cwd/$dname.master.qcow2";

                $dlname = "$cwd/$dname.master.qcow2.tar" if ($downloadurl =~ /\.box$/);

                $cmd = qq|wget -O "$dlname" "$downloadurl"|;

                print `$cmd`;

                if ($dlname =~ /\.tar$/) {

                    print ">> untarring...\n";

                    print `tar -xvf "$dlname" box.img`;

                    print `mv box.img "$cwd/$dname.master.qcow2"`;

                    print `rm "$dlname"`;

                }

            } else {

                #            die "You need to install python-vm-builder in order to build a base image\n" unless (`which vmbuilder`);

                die "You need to install virt-builder (provided by libguestfs-tools) in order to build a base image\n" unless (`which virt-builder`);

                # We unfortunately have to patch vmbuilder

                ## See: http://askubuntu.com/questions/819844/kvm-vmbuilder-fails

                #            my $vmbuilder_dapper = "/usr/lib/python2.7/dist-packages/VMBuilder/plugins/ubuntu/dapper.py";

                #            if (-e $vmbuilder_dapper) {

                #                unless (`grep 'force-confnew' $vmbuilder_dapper`) {

                #                    print ">> Patching vmbuilder\n";

                #                    system(qq|perl -pi -e "s/(\'dist-upgrade\')/\'--option=Dpkg::Options::=--force-confnew\', \'dist-upgrade\'/" $vmbuilder_dapper|);

                #                    unlink($vmbuilder_dapper.'c');

                #                }

                #                unless (`grep 'force-confnew' $vmbuilder_dapper`) {

                #                    print ">> Patching vmbuilder\n";

                #                    system(qq|perl -pi -e "s/(self.install_from_template.*sudoers.*)/# \\\$1/" $vmbuilder_dapper|);

                #                    unlink($vmbuilder_dapper . 'c');

                #                }

                #            }

                #my $cmd = qq|vmbuilder kvm ubuntu -o -v --debug --suite $basesuite --arch amd64 --components main,universe,multiverse --rootsize $size --user stabile --pass stabile --hostname $name --tmpfs 2048 --addpkg linux-image-generic --addpkg wget --addpkg curl --domain stabile.io --ip 10.1.1.2|;

                # print "$cmd\n";

                $cmd = qq|virt-builder $basename -o "$cwd/$dname.master.qcow2" --arch x86_64 --size $size --hostname $name --format qcow2|;

                print "$cmd\n";

                print `$cmd`;

                # The downloaded image is in sparse format - get rid of unused/sparse space

                print "Getting rid of sparse space...\n";

                print `qemu-img convert -O qcow2 "$cwd/$dname.master.qcow2" "$cwd/$dname.master.qcow2.new"`;

                print `mv "$cwd/$dname.master.qcow2.new" "$cwd/$dname.master.qcow2"`;

                # Clean up

                # `mv ubuntu-kvm/*.qcow2 "$cwd/$dname.master.qcow2"`;

                # `rm -r ubuntu-kvm`;

            }

        }

    }

    # Now load nbd and mount the image

    if (-e "$cwd/$dname.master.qcow2") {

        # Wait for nbd0 to be created

        if (!(-e "/dev/nbd0p1")) {

            print `qemu-nbd -c /dev/nbd0 "$cwd/$dname.master.qcow2"`;

            while (!(-e "/dev/nbd0p1")) {

                print ">> Waiting for nbd0p1...\n";

                sleep 1

            }

        }

        # Mount image

        print `mkdir "/tmp/$dname"` unless (-d "/tmp/$dname");

        my $part; # We assume max 4 partitions and assume the main partition is the last

        for (my $i=4; $i>=0; $i--) {

            if (-e "/dev/nbd0p$i") {

                my $partinfo = `blkid /dev/nbd0p$i`;

                chomp $partinfo;

                if ($partinfo =~ /TYPE="(xfs|ext|.+_member)/) {

                    $part = "p$i";

                    last;

                }

            }

        }

        print `mount /dev/nbd0$part "/tmp/$dname"` unless (-e "/tmp/$dname/boot");

        # Mount /proc  and /dev/pts

        print `mount --bind /proc "/tmp/$dname/proc"`;

        print `mount --bind /dev/pts "/tmp/$dname/dev/pts"`;

#        print `mount --bind /dev/pts "/tmp/$dname/dev/pts"`;

        # Make /dev/null available

        # print `mknod -m 666 "/tmp/$dname/dev/null" c 1 3`

        # Create data image if specified

        if ($dataimage && !(-e "$cwd/$dname-data.master.qcow2") && (-e "$cwd/$dname.master.qcow2")) {

            print ">> Creating data image $dataimage in $cwd/$dname-data.master.qcow2...\n";

            print `qemu-img create -f qcow2 "$cwd/$dname-data.master.qcow2" $dataimage`;

        #    print `modprobe nbd max_part=63`;

            print `qemu-nbd -c /dev/nbd1 "$cwd/$dname-data.master.qcow2"`;

            print `sfdisk /dev/nbd1 << EOF\n;\nEOF`;

        #    print `mkfs.ext4 /dev/nbd1p1`;

            print `mkfs.$dataimagefs /dev/nbd1p1`;

            print ">> Mounting data image $dataimage on /tmp/$dname$datamount...\n";

            print `mkdir -p "/tmp/$dname$datamount"`;

            print `mount /dev/nbd1p1 "/tmp/$dname$datamount"`;

        #    print `qemu-nbd -d /dev/nbd1`;

        }

    } else {

        die "Unable to mount image $cwd/$dname.master.qcow2";

    }

    # Copy files

    if ($dir) {

        die "'$dir' not found [DIR]" unless (-d $dir);

        print ">> Copying files from $dir to /tmp/$dname$dirtarget...\n";

        print `tar rf "/tmp/$dname.tar" "$dir"`;

        print `tar xf "/tmp/$dname.tar" -C "/tmp/$dname$dirtarget"`;

        print `rm "/tmp/$dname.tar"`;

    }

    print `rm /tmp/$dname/etc/resolv.conf`;

    print `echo "nameserver 1.1.1.1" > /tmp/$dname/etc/resolv.conf`;

    # Add user stabile

    print `chroot "/tmp/$dname" useradd stabile -b /home -s /bin/bash 2>/dev/null`;

    print `chroot "/tmp/$dname" mkdir /home/stabile 2>/dev/null`;

    print `chroot "/tmp/$dname" chown stabile:stabile /home/stabile`;

	# Run pre exec script

    # Stop local webmin from blocking port 10000

    print `systemctl stop webmin`;

    if ($preexec) {

        print "Running pre exec in /tmp/$dname\n";

        foreach my $line (split(/\\n/, $preexec)) { # $preexec may contain a multi-line script

            $line =~ s/^\s+//; # remove leading spaces

            $line =~ s/\s+$//; # remove trailing spaces

            $line =~ s/#.+$//; # remove comments

            $line =~ s/\|/\|chroot "\/tmp\/$dname" /; # redirect pipes

            $line =~ s/\> +/\> \/tmp\/$dname/; # redirect pipes

            $line =~ s/\< +/\> \/tmp\/$dname/; # redirect pipes

            $line =~ s/\$\((.+)\)/\$(chroot "\/tmp\/$dname" $1) /; # handle environment variables

            if ($line) {

                my $cmd = qq|chroot "/tmp/$dname" $line|; # execute command in chroot

                print ">> $cmd\n";

                print `$cmd`;

            }

        }

    }

    # Install debs

    if ($debs) {

        print ">> Installing packages\n";

        system(qq|perl -pi -e "s/(deb http.+ bionic-updates universe)/# \\\$1/" /etc/apt/sources.list|);

        system(qq|perl -pi -e "s/(deb http.+ bionic-updates multiverse)/# \\\$1/" /etc/apt/sources.list|);

        # Necessary for now to avoid corrupted apt caches

#        print `rm -r /var/lib/apt/lists/*`; # Start from a clean slate

#        print `chroot "/tmp/$dname" dpkg --clear-avail`;

#        print `chroot "/tmp/$dname" sync-available` if (-e "/tmp/$dname/usr/sbin/sync-available");

        print `chroot "/tmp/$dname" apt-get update`;

        print `chroot "/tmp/$dname" /bin/bash -c 'DEBIAN_FRONTEND=noninteractive apt-get -q -y --show-progress install $debs'`;

    }

    # Unpack tar

    if ($tar) {

        print ">> Unpacking files...\n";

        if ($tar =~ /^http(s?):\/\//) {

            print "Downloading $tar to /tmp/$dname/tmp\n";

            my $cmd = qq|wget "$tar" --directory-prefix "/tmp/$dname/tmp" 2>&1|;

            print "$cmd\n";

            my $dl = `$cmd`;

            $tar = $1 if ($dl =~ /Saving to: (.+)/);

            $tar = $1 if ($tar =~ /...(\S+).../); # tar now surrounds path with multi-byte chars...

            print "Received: $tar\n";

        }

        if ($tar =~ /\.zip$/) {

            print `unzip $tar -d "/tmp/$dname$tartarget" > /dev/null`;

        } elsif ($tar =~ /\.tgz$/ || $tar =~ /\.tar\.gz$/) {

            print `tar zxf "$tar" -C "/tmp/$dname$tartarget"`;

        } else {

            print `tar xf "$tar" -C "/tmp/$dname$tartarget"`;

        }

        `chown -R $tarowner "/tmp/$dname$tartarget"` if ($tarowner);

    }

    # Git clone

    if ($git) {

        print ">> Cloning from Git repo...\n";

        print `git clone $git "/tmp/$dname$gittarget"`;

        `chown -R $gitowner "/tmp/$dname/$gittarget"` if ($gitowner);

    }

    # Run post exec script

    if ($postexec) {

        print "Running post exec in /tmp/$dname\n";

        foreach my $line (split(/\\n/, $postexec)) {

            $line =~ s/^\s+//;

            $line =~ s/\s+$//;

            $line =~ s/#.+$//;

            $line =~ s/\|/\|chroot "\/tmp\/$dname" /;

            $line =~ s/\> +/\> \/tmp\/$dname/;

            $line =~ s/\< +/\> \/tmp\/$dname/;

            $line =~ s/\$\((.+)\)/\$(chroot "\/tmp\/$dname" $1) /;

            if ($line) {

                my $cmd = qq|chroot "/tmp/$dname" $line|;

                print ">> $cmd\n";

                print `$cmd`;

            }

        }

    }

    # Install boot exec script

    if ($service) {

        my $unit =  <<END

[Unit]

DefaultDependencies=no

Description=Stabile $dname

After=network-online.target stabile-ubuntu.service webmin.service

Wants=network-online.target stabile-ubuntu.service webmin.service

[Service]

Type=oneshot

ExecStart=$service

TimeoutSec=600

RemainAfterExit=yes

[Install]

WantedBy=multi-user.target

END

        ;

        `echo "$unit" > "/tmp/$dname/etc/systemd/system/stabile-$dname.service"`;

        `chmod 664 "/tmp/$dname/etc/systemd/system/stabile-$dname.service"`;

        `chmod 755 "/tmp/$dname$service"`;

        `chroot /tmp/$dname ln -s /etc/systemd/system/stabile-$dname.service /etc/systemd/system/multi-user.target.wants/stabile-$dname.service`;

#        `systemctl enable stabile-$dname.service`;

    }

    if ($debug) {

        print ">> Leaving image mounted on: /tmp/$dname\n";

        print ">> Remember to unmount /tmp/$dname/proc and /tmp/$dname manually and 'killall qemu-nbd' when you are done debugging.\n";

        exit;

    }

# Start webmin again

	print `killall -9 miniserv.pl`;

    print `systemctl start webmin`;

	sleep 2;

    # Unmount data image

    if ($dataimage) {

        print `umount "/tmp/$dname$datamount"`;

        print `qemu-nbd -d /dev/nbd1`;

    }

# Unmount base image and clean things up

    print `umount "/tmp/$dname/proc"`;

    print `umount "/tmp/$dname/dev/pts"`;

    print `umount "/tmp/$dname"`;

    print `killall qemu-nbd`;

    print `rm -d "/tmp/$dname"`;

    # convert to qcow2

    # print "Converting $cwd/$dname.master.qcow2\n";

    # print `qemu-img amend -f qcow2 -o compat=0.10 $cwd/$dname.master.qcow2`;

    # Rebase image

    if ($rebase) { # Flatten image

        sleep 5;

        print ">> Rebasing and flattening image...\n";

        print `qemu-img rebase --force-share -f qcow2 -b "" "$cwd/$dname.master.qcow2"`;

    } elsif ($masterpath) { # Update backing file path

        sleep 5;

        print ">> Rebasing to new backing file path $masterpath...\n";

        my $res = `qemu-img rebase --force-share -f qcow2 -u -b "$masterpath" "$cwd/$dname.master.qcow2" 2>\&1`;

        if ($res =~ /Failed/) {

            print ">> Trying agin to rebasing to new backing file path $masterpath...\n";

            $res = `qemu-img rebase --force-share -f qcow2 -u -b "$masterpath" "$cwd/$dname.master.qcow2" 2>\&1`;

            print qq|>> Rebasing failed - please rebase manually before activating:\nqemu-img rebase --force-share -f qcow2 -u -b "$masterpath" "$cwd/$dname.master.qcow2"\n| if ($res =~ /failed/i);

        }

    } else {

        print ">> No master, so not rebasing image...\n";

    }

}

if ($fuelpath) {

    # Activate and publish image

    $appname = uri_escape($appname);

    $managementlink = uri_escape($managementlink);

    $upgradelink = uri_escape($upgradelink);

    $terminallink = uri_escape($terminallink);

    $logo = uri_escape($logo);

    $thumbnail = uri_escape($thumbnail);

    $ports = uri_escape($ports);

    $summary = uri_escape($summary);

    $description = uri_escape($description);

    $price = uri_escape($price);

    my $image2 = "$dname-data.master.qcow2" if ($dataimage);

    my $imgpath = "$cwd/$dname.master.qcow2";

    # Move image unless already on shared storage

    unless ($imgpath =~ /\/mnt\/fuel\/pool\d+/) {

        die "Unable to move image to shared storage - already exists" if (-e "$fuelpath/$dname.master.qcow2");

        print "Moving $dname.master.qcow2 to $fuelpath\n";

        print `mv -v "$cwd/$dname.master.qcow2" $fuelpath`;

        $imgpath = "$fuelpath/$dname.master.qcow2";

        if ($image2) {

            print "Moving $dname-data.master.qcow2 to $fuelpath\n";

            print `mv -v "$cwd/$dname-data.master.qcow2" $fuelpath`;

        }

    }

    if ($activate) {

        print "Trying to activate stack $dname\n";

        if ($imageuuid && !$force) {

            print "Not activating - this image has already been activated on this engine by user $imageuser. Specify -f if you want to force activation.\n";

        } elsif (!(-e $imgpath)) {

            print "Not activating - image not found. Specify -r if you want to force rebuild it.\n";

        } else {

            my $cmd = qq|curl --silent -k "https://$gw/stabile/images?action=activate&image=$imgpath&version=$version&name=$appname&managementlink=$managementlink&upgradelink=$upgradelink&terminallink=$terminallink&image2=$image2&force=$force"|;

            my $res = `$cmd`;

            print $res;

            $res =~ /(\S{8}-\S{4}-\S{4}-\S{4}-\S{12})$/;

            $imageuuid = $1;

            chomp $imageuuid;

        }

    } elsif ( -e $imgpath) {

        print "Your image has been built - now you should activate it (run stackbuilder again with '-a' option), in order to use it!\n";

    }

    if ($publish) {

        if ($enginelinked) {

            print "Trying to publish stack $dname\n";

            if ($imageuuid) {

                print "Uploading image with uuid $imageuuid to the registry\n";

                print "Hang on - this may take a while...\n";

                $res = `curl -k --silent "https://$gw/stabile/images?action=publish&uuid=$imageuuid&appid=$appid&vcpu=$vcpu&memory=$memory&logo=$logo&thumbnail=$thumbnail&price=$price&ports=$ports&summary=$summary&description=$description&image2=$image2&instances=$instances&storagepool=$storagepool&storagepool2=$storagepool2&force=$force"`;

                print "$res";

            } else {

                print "Something went wrong, did not get valid uuid $imageuuid - left it in your shared storage.\n";

            }

        } else {

            print "Not publishing - you are not in a VM, or the engine you are running on is not linked with the Registry.\n" if ($publish);

        }

    }

    if ($freshen) {

        if ($enginelinked) {

            print "Trying to freshen stack $dname\n";

            if ($imageuuid) {

                $res = `curl -k --silent "https://$gw/stabile/images?action=publish&uuid=$imageuuid&appid=$appid&vcpu=$vcpu&memory=$memory&logo=$logo&thumbnail=$thumbnail&price=$price&ports=$ports&summary=$summary&description=$description&image2=$image2&instances=$instances&storagepool=$storagepool&storagepool2=$storagepool2&force=$force&freshen=$freshen"`;

                print "$res";

            } else {

                print "Something went wrong, did not freshen the stack.\n";

            }

        } else {

            print "Not freshening - you are not in a VM, or the engine you are running on is not linked with the Registry.\n";

        }

    }

    if ($release) {

        if ($enginelinked) {

            my $action = ($unrelease)?"unrelease":"release";

            print "Trying to $action stack $dname\n";

            if ($imageuuid) {

                print "Moving image with uuid $imageuuid\n";

                $res = `curl -k --silent "https://$gw/stabile/images?action=release&uuid=$imageuuid&force=$force&unrelease=$unrelease"`;

                print "$res";

            }

            else {

                print "Something went wrong, did not get valid uuid $imageuuid.\n";

            }

        } else {

            print "Not releasing - you are not in a VM, or the engine you are running on is not linked with the Registry.\n" if ($publish);

        }

    }

} else {

    print "Looks like we are not running in a VM - leaving image in $cwd/$dname.master.qcow2\n";

}