openshift-release-info

#!/usr/bin/perl

use strict;
use JSON;
use Getopt::Long;
Getopt::Long::Configure("bundling", "no_ignore_case", "pass_through");

my $base_repo="openshift-release";
my $base;
my $dot_url;
my $cincy_url;

my @channels;
my @release_channels;
my @release_labels;
my @release_urls;
my @release_payloads;
my @release_colors;
my %upgrades_from;
my %upgrades_to;
my %release_idx;

my $opt_channel;
my $opt_all_upgrades;
my $opt_print_color;
my $opt_print_only_validated;
my $opt_match_pattern;
my $verbose;
my $help;

sub read_releases() {
    open(DOT, "-|", "curl --silent -L $dot_url") || die "Can't read $dot_url: $!\n";
    my ($current_channel);
    while (<DOT>) {
	chomp;
	$_ =~ s/^[\s]*//;
	if (/^label="Stream +(.*)";$/) {
	    $current_channel=$1;
	    push @channels, $current_channel;
	} elsif (/^([0-9]+)->([0-9]+) *\[ *(.*) *];$/) {
	    my ($from) = $2;
	    my ($to) = $1;
	    my ($attrs) = $3;
	    if (! defined $upgrades_from{$from}) {
		$upgrades_from{$from} = {};
	    }
	    $upgrades_from{$from}{$to} = $attrs;
	    if (! defined $upgrades_to{$to}) {
		$upgrades_to{$to} = {};
	    }
	    $upgrades_to{$to}{$from} = $attrs;
	} elsif (/^([0-9]+) *\[ *(.*) *];$/) {
	    my ($idx) = $1;
	    my (%attrs) = parse_options($2);
	    if ($release_labels[$idx]) {
		warn "Attempt to redefine release $idx ($release_labels[$idx]) => $attrs{'label'}\n";
	    }
	    $release_labels[$idx] = $attrs{'label'};
	    $release_channels[$idx] = $current_channel;
	    $release_urls[$idx] = $attrs{'href'};
	    $release_colors[$idx] = $attrs{'color'};
	    $release_idx{$attrs{'label'}} = $idx;
	}
    }
    close(DOT);
}

sub read_graph() {
    open(GRAPH, "-|", "curl --silent -L $cincy_url") || die "Can't read $cincy_url: $!\n";
    my ($jsontxt);
    while (<GRAPH>) {
	$jsontxt .= $_;
    }
    close GRAPH;
    my $json = decode_json($jsontxt);
    my $nodes = $$json{'nodes'};
    if ($nodes) {
	foreach my $node (@$nodes) {
	    my $version = $$node{'version'};
	    my $payload = $$node{'payload'};
	    if ($version eq '') {
		warn "Can't find version!\n";
	    } elsif ($payload eq '') {
		warn "Can't find payload!\n";
	    } elsif ($release_idx{$version}) {
		$release_payloads[$release_idx{$version}] = $payload;
	    }
	}
    }
}

sub get_release_info($) {
    my ($release) = @_;
    my $response;
    open(INFO, "-|", "oc adm release info --image-for=machine-os-content $release") || warn "Can't run oc adm release info: $!\n";
    while (<INFO>) {
	chomp;
	$response .= $_;
    }
    close INFO;
    if (not $response) {
	warn "Can't read release info for $release\n";
    }
    return $response;
}

sub get_release_detail($) {
    my ($release) = @_;
    my ($response);
    open(INFO, "-|", "oc adm release info -o json $release") || warn "Can't run oc adm release info: $!\n";
    my ($jsontxt);
    while (<INFO>) {
	$jsontxt .= $_;
    }
    close INFO;
    my $json = decode_json($jsontxt);
    my (%reldetail);
    if (defined $$json{'references'}{'spec'}{'tags'}) {
	foreach my $tag (@{$$json{'references'}{'spec'}{'tags'}}) {
	    my ($name) = $$tag{'name'};
	    my ($repo) = $$tag{'annotations'}{'io.openshift.build.source-location'};
	    my ($commit) = $$tag{'annotations'}{'io.openshift.build.commit.id'};
	    my ($image) = $$tag{'from'}{'name'};
	    $reldetail{$name} = {};
	    $reldetail{$name}{'repo'} = $repo;
	    $reldetail{$name}{'commit'} = $commit;
	    $reldetail{$name}{'image'} = $image;
	}
    }
    return %reldetail;
}

sub get_os_build($) {
    my ($release) = @_;
    my ($relinfo) = get_release_info($release);
    if (not $relinfo) {
	return '';
    }
    open(RELINFO, "-|", "oc image info -o json $relinfo") || warn "Can't run oc image info $relinfo: $!\n";
    my ($jsontxt);
    while (<RELINFO>) {
	$jsontxt .= $_;
    }
    close RELINFO;
    my $json = decode_json($jsontxt);
    if (defined $$json{'config'}{'config'}{'Labels'}{'version'}) {
	return $$json{'config'}{'config'}{'Labels'}{'version'};
    }
    warn "Unable to parse configuration for $release\n";
    return '';
}

sub get_releases($\@) {
    my ($channel, $releases) = @_;
    my (%requested_releases);
    my ($explicit_release_count) = 0;
    my ($invalid_release_count) = 0;
    read_releases();
    read_graph();
    foreach (@$releases) {
	if (! defined $release_idx{$_}) {
	    print STDERR "Invalid release $_\n";
	    $invalid_release_count++;
	} else {
	    $requested_releases{$_} = $explicit_release_count++;
	}
    }
    if ($explicit_release_count == 0 && $invalid_release_count > 0) {
	print STDERR "No valid releases specified\n";
	exit 1;
    }
    my (@answer);
    foreach my $release (sort keys %release_idx) {
	if (($channel eq '' || $release_channels[$release_idx{$release}] eq $channel) &&
	    $release_payloads[$release_idx{$release}] ne '' &&
	    ($explicit_release_count == 0 || defined $requested_releases{$release})) {
	    push @answer, $release;
	}
    }
    if (! @answer) {
	print STDERR "No valid releases found\n";
    }
    return @answer;
}

sub print_channels(;$) {
    my ($pattern) = @_;
    read_releases();
    print join("\n", grep {$_ =~ /$pattern/} @channels ), "\n";
}

sub print_releases($;$) {
    my ($channel, $pattern) = @_;
    read_releases();
    read_graph();
    foreach my $idx (0..$#release_labels) {
	if ($channel eq '' || $release_channels[$idx] eq $channel) {
	    next if (! ($release_labels[$idx] =~ /$pattern/));
	    next if ($opt_print_only_validated && $release_colors[$idx]);
	    if ($opt_print_color && $release_colors[$idx]) {
		print "$release_labels[$idx] $release_colors[$idx]\n";
	    } else {
		print "$release_labels[$idx]\n";
	    }
	}
    }
}

sub parse_options($) {
    my ($string) = @_;
    $string =~ s/\s*$//;
    my (@attrs) = split(/, */, $string);
    my (%attrs);
    map { $_ =~ /^(.*)=(.*)$/;
	  my $key = $1;
	  my $val = $2;
	  $val =~ s/^"(.*)"$/$1/;
	  $attrs{$key} = $val;
    } @attrs;
    return %attrs;
}

my %generic_commands = (
    "os"         => 1,
    "payload"    => 1,
    "url"        => 1,
    "upgrades"   => 0,
    "components" => 0,
    );

sub do_command($$\@) {
    my ($command, $channel, $releases) = @_;
    my ($plural) = $generic_commands{$command};
    if (! $plural && length @$releases != 1) {
	die "Error: command '$command' takes only one release\n";
    }
    my (@releases) = get_releases($channel, @$releases);
    foreach my $release (@releases) {
	my ($always_print_release) = 0;
	my ($answer);
	my ($idx) = $release_idx{$release};
	if ($command eq "os") {
	    $answer = get_os_build($release_payloads[$idx]);
	} elsif ($command eq "payload") {
	    $answer = "$release_payloads[$idx]";
	} elsif ($command eq "url") {
	    $answer = "$base$release_urls[$idx]";
	} elsif ($command eq "upgrades") {
	    if (defined $upgrades_from{$idx}) {
		my (@answers);
		foreach my $upgrade (sort keys %{$upgrades_to{$idx}}) {
		    my (%attrs) = parse_options($upgrades_to{$idx}{$upgrade});
		    if ($attrs{'style'} ne 'invis' &&
			($opt_all_upgrades || $attrs{'color'} ne 'red')) {
			push @answers, "$release_labels[$upgrade]";
			$always_print_release = 1;
		    }
		}
		if (@answers) {
		    $answer = "\n  " . join("\n  ", @answers) . "\n";
		}
	    }
	} elsif ($command eq "components") {
	    my (%stuff) = get_release_detail($release_payloads[$idx]);
	    my ($maxnamelen) = 1;
	    my ($maxrepolen) = 1;
	    if ($verbose) {
		foreach my $name (keys %stuff) {
		    if (length $name > $maxnamelen) {
			$maxnamelen = length $name;
		    }
		    if (length $stuff{$name}{'repo'} > $maxrepolen) {
			$maxrepolen = length $stuff{$name}{'repo'};
		    }
		}
		my (@answers);
		my ($printfstr) = "%-${maxnamelen}s %-${maxrepolen}s %s";
		foreach my $name (sort keys %stuff) {
		    my ($a1) = sprintf($printfstr, $name, $stuff{$name}{'repo'}, $stuff{$name}{'commit'});
		    $a1 =~ s/ +$//;
		    push @answers, $a1;
		}
		$answer = join("\n", @answers);
	    } else {
		$answer = join("\n", sort keys %stuff);
	    }
	}
	if ($answer ne '') {
	    if ($#releases > 0 || $always_print_release) {
		print "$release ";
	    }
	    print "$answer\n";
	}
    }
}

sub print_help_and_exit() {
    print STDERR <<EOF;
  Usage: openshift-release-info [opts] command args...
    Commands:
      channels                List available channels.
      components <release>    List components associated with release.
                              With -v, print repo and commit hash.
      os [releases...]        Print OS version for specified release[s] or all
                              if none specified.
      payload [releases...]   Print payload for specified release[s].
      releases                List available releases.
      upgrades <release>      List available upgrades for the specified
                              release.
      url [releases...]       Print URL for specified release[s].
      help                    Print this help
    Options:
      -B base                 Use the specified base.  At present, this should
                              be openshift-release or origin-release.
      -c channel              Restrict releases to the specified channel.
      -m pattern              Only print releases or channels matching
                              regexp pattern.
      -C                      Print release status with each release in CSV.
      -G                      Print only validated releases.
      -v                      Print verbose information, as appropriate.
EOF
    exit 1;
}

GetOptions("B=s" => \$base_repo,
	   "m=s" => \$opt_match_pattern,
	   "c=s" => \$opt_channel,
	   "C!"  => \$opt_print_color,
	   "G!"  => \$opt_print_only_validated,
	   "h"   => \$help,
	   "v"   => \$verbose);

if ($help) {
    print_help_and_exit();
}

if (! @ARGV) {
    print STDERR "No command specified.\n";
    print_help_and_exit();
}

my $command = lc shift @ARGV;

$base="https://$base_repo.apps.ci.l2s4.p1.openshiftapps.com";
$dot_url="${base}/graph?format=dot";
$cincy_url="$base/graph";

if ($command eq "help") {
    print_help_and_exit();
} elsif ($command eq "channels") {
    print_channels($opt_match_pattern);
} elsif ($command eq "releases") {
    print_releases($opt_channel, $opt_match_pattern);
} elsif (defined $generic_commands{$command}) {
    do_command($command, $opt_channel, @ARGV);
} else {
    print STDERR "Unknown command '$command'.\n";
    print_help_and_exit();
}