shell-scripts/update-gitea.pl

#!/usr/bin/perl

# Update gitea based on version provided
# Author: Tracey Clark
# Created: 2019-03-04
# You must have a mail transport agent installed to run this script

# Note: Daily backups are also being run from cron
# /home/gitea/gitea_backup.sh

# Re-write to use this dir according to gitea docs
# https://docs.gitea.io/en-us/install-from-binary/
# Get binary from system rather than hard code
# Stop gitea with systemctl before file copy
# Set right mod & perms?

use strict;
use warnings;
use LWP::UserAgent;
use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error);
use Data::Dumper;
use JSON;
use Sort::Versions;
use Getopt::Long qw(GetOptions);
use Term::ANSIColor qw(:constants);
use feature qw(say);

my ( $verbose, $info );

GetOptions(
    'info!'    => \$info,
    'verbose!' => \$verbose,
);

##########################################
### The user must set these variables ###
# SET email address
my $email    = 'tclark77@tlcnet.info';
my $filetype = '-linux-amd64';

# https://api.github.com/repos/go-gitea/gitea/releases/latest
# This URL will only have one version listed
my $gitea_bin_dir                = '/usr/local/bin/';
my $gitea_bin                    = $gitea_bin_dir . '/gitea';
my $gitea_current_version_string = `$gitea_bin --version`;
my $alphanum_ver                 = 0;

chomp $gitea_current_version_string;
unless ( defined $gitea_current_version_string ) {
    die
      "[DIE]: Unable to get the version of the gitea binary on the system: $!";
}

my %binary_file           = get_current_version($gitea_current_version_string);
my $gitea_current_version = $binary_file{'version'};
my $baseURL               = q{https://github.com/go-gitea/gitea/};
my $latestURL = q{https://api.github.com/repos/go-gitea/gitea/releases/latest};

# https://hubpages.com/technology/Use-Perl-to-access-REST-API
# Spin up the browser object
my $ua = LWP::UserAgent->new(
    cookie_jar => {},  # keep cookies in RAM but not persistent between sessions
);

my $resp                = $ua->get($latestURL);
my $latest_release_hash = decode_json( $resp->content )
  or die "[DIE]: Unable to parse the version data! Output is:\n $resp";

my $orig_tag = $latest_release_hash->{tag_name};
my $tag      = $orig_tag;
substr( $tag, 0, 1, '' );
print("Latest upstream version is $tag\n");
my $release_id = $latest_release_hash->{id};    # Works
my $unz_filename = 'gitea-' . $tag . $filetype;
#ex: gitea-1.7.6-linux-amd64
my $download_dir = '/home/gitea/bin/';
my $download_filename = $unz_filename . '.xz';

if ( defined $verbose ) {
    printf( YELLOW
          "[INFO]\nRelease id: $release_id\nUncompressed filename: $unz_filename\nDownload file target: $download_filename\n"
    );
}


#ex: gitea-1.7.6-linux-amd64.xz

if ( versioncmp( $gitea_current_version, $tag ) == -1 ) {
    printf(
"Version tag is greater than the system version, proceeding with update\n"
    );
    backup_bin( \%binary_file );

    my $download_url = get_download_url( $download_filename, $release_id );
    print("Downloading the compressed binary\n");
    print("Download URL we got from the sub is $download_url\n");
    `wget -P $gitea_bin_dir $download_url`;
    my $xz_file = $gitea_bin_dir . $download_filename;

    if ( defined $info ) {
        print YELLOW "[INFO] xz file is $xz_file\n", RESET;
    }

    install_bin($download_filename);

}

my $status = check_gitea_status();
if ( $status =~ /active/ ) {
    print( GREEN "[INFO] Gitea service is active\n", RESET );
}
unless ( $status =~ /active/ ) {
    die RED "[DIE] Status of gitea service is no good! OMGURD\n", RESET;
}
$gitea_current_version_string = `$gitea_bin --version`;
chomp $gitea_current_version_string;
%binary_file           = get_current_version($gitea_current_version_string);
$gitea_current_version = $binary_file{'version'};

if ( versioncmp( $gitea_current_version, $tag ) == -1 ) {
    printf(
"Upstream version tag is STILL greater than the current system version, something went wrong\n"
    );
}
else {
    say "Cleanup and remove the old xz file and uncompressed file";
    say "Unzipped filename in cleanup is " . $download_dir . $unz_filename;
    system("rm -vf " . $download_dir . $unz_filename);
    system("rm -vf " . $download_dir . $download_filename);
    # Intentionally *not* removing the 'gitea' binary in case something goes wrong running the current binary.
}

#TODO Add check if running binary is the same version as what we downloaded

# #notification( $email );

# ##### Subroutines #####

# sub check_deps {
#     # Check to make sure dependencies installed on system - unit test??
#     # bzip2 perl mods
# }

sub get_current_version {
    my $current_version_string = shift;
    my $current_version;
    if ( $current_version_string =~ m/ion\ (\d+\.\d+\.\d*)\s+b/ ) {
        $current_version = $1;
        printf("Version number of the installed gitea binary: $1\n");
    }
    elsif ( $current_version_string =~ m/ion\ (\d+\d+\w*)\s/ ) {
        $current_version = $1;
        printf("Current version number the installed gitea binary: $1\n");
        $alphanum_ver = 1;
    }
    my %binary_file = (
        input   => $gitea_bin,
        version => $current_version,
    );
    unless ( defined $current_version ) {
        die RED
        "[DIE]: Unable to get the current gitea version! Value is $current_version",
          RESET;
    }
    return %binary_file;
}

sub backup_bin {

    # Ghetto to get it working for now

    my (%opts)  = %{ shift() };
    my $input   = $opts{input};
    my $version = $opts{version};
    print GREEN "Backing up the current binary\n", RESET;
    if ( defined $info ) {
        print YELLOW
      "[INFO] Input in backup_bin sub is:\n  Directory $input\n  Version $version\n",
          RESET;
    }
    my $gitea_bin_backup =
      '/home/gitea/bin/gitea.' . $gitea_current_version . '.bz2';
    print GREEN "Gitea bin backup will be $gitea_bin_backup\n", RESET;
    system("cp $input $input.bak");

  # TODO
  # # Do this with a system call to make a compressed copy of the current binary
  # # bzip2 -k file.txt
  # # my $status = system("vi", "fred.txt");
  # # if (($status >>=8) != 0) {
  # #     die "[DIE] Failed to run vi";
  # # }
  # my $bzip_status = system("bzip2 -k", "$input");
  # if (($status >>=8) != 0) {
  #     die "[DIE] Failed to run bzip2";
  # }

    return;
}

sub get_download_url {
    my ( $dl_filename, $rel_id ) = @_;
    my $dl_url;

    # Get the download_url from the array
    my $assetsURL =
        'https://api.github.com/repos/go-gitea/gitea/releases/'
      . $release_id
      . '/assets';
    if ( defined $info ) {
        print YELLOW "[INFO] Assets URL\n";
        print "$assetsURL\n", RESET;
    }

    my $asset_resp           = $ua->get($assetsURL);
    my $asset_resp_array_ref = decode_json( $asset_resp->content );

    if ( defined $verbose ) {
        printf( RED
              "[DEBUG] Array of hashes of the json response for the assets:\n"
        );
        printf Dumper $asset_resp_array_ref, RESET;
    }

    foreach my $asset_ref ( @{$asset_resp_array_ref} ) {
        if ( defined $verbose ) {
            print( RED
                  "[DEBUG] The asset ref in get_download_url is $asset_ref\n" );
            print(
            "The asset ref name in get_download_url is $asset_ref->{name}\n",
                RESET
            );
        }
        if ( $asset_ref->{name} eq $dl_filename ) {
            print("Yay we have a match for our desired file :D and it is \n");
            print $asset_ref->{name} . "\n";
            $dl_url = $asset_ref->{browser_download_url};
            if ( defined $info ) {
                print YELLOW
            "[INFO] The download url from the response array is $dl_url\n",
                  RESET;
            }
            return $dl_url;
        }
    }
    unless ( defined $dl_url ) {
        print( RED
   "ONOES we have no download URL from the github API! Trying to build one manually\n",
            RESET
        );
        my $dl_url = build_download_url( $orig_tag, $download_filename );
        return $dl_url;
    }
    return 0;
}

sub build_download_url {
    my ( $url_tag, $url_file ) = @_;
    print "Building the URL based on the version\n";

# If getting the download URL fails through the API, use this to build it manually
# URL is in the form of
# https://github.com/go-gitea/gitea/releases/download/v1.15.2/gitea-1.15.2-linux-amd64.xz
    my $built_url =
        'https://github.com/go-gitea/gitea/releases/download/'
      . $url_tag . '/'
      . $url_file;
    if ( defined $info ) {
        print YELLOW "The URL built for the download is $built_url\n", RESET;
    }
    return $built_url;
}

sub install_bin {
    my $filename = shift;

    #my $unz_binary =

    print("Unpacking the downloaded file, setting owner and permissions\n");

    # Copy the downloaded binary to gitea and chmod it 750
    # Doing this with a filthy system call because the perl library
    # for xz manipulation is a memory hog and buggy besides
    system("xz -d --keep $download_dir . $filename");
    system("systemctl stop gitea");
    system("cp $download_dir/$unz_filename $gitea_bin");
    system("chown gitea.gitea $gitea_bin");
    system("chmod 750 $gitea_bin");

    # Restart service
    print("Restarting the gitea service\n");
    system("systemctl restart gitea");
    return;
}

sub check_gitea_status {
    my $gitea_status = `systemctl is-active gitea`;
    return $gitea_status;
}

sub cleanup {

# remove downloaded binary and old backup set install_status=success ELSE remove "gitea" and restore from backup and set install_status=fail
    return;
}

sub notification {
    my $to = shift;

    return;
}