#!/usr/bin/env perl

use strict;
use warnings;

our $home;

BEGIN {
  use FindBin;
  FindBin::again();

  $home = ($ENV{NETDISCO_HOME} || $ENV{HOME});

  # try to find a localenv if one isn't already in place.
  if (!exists $ENV{PERL_LOCAL_LIB_ROOT}) {
      use File::Spec;
      my $localenv = File::Spec->catfile($FindBin::RealBin, 'localenv');
      exec($localenv, $0, @ARGV) if -f $localenv;
      $localenv = File::Spec->catfile($home, 'perl5', 'bin', 'localenv');
      exec($localenv, $0, @ARGV) if -f $localenv;

      die "Sorry, can't find libs required for App::Netdisco.\n"
        if !exists $ENV{PERLBREW_PERL};
  }
}

BEGIN {
  use Path::Class;

  # stuff useful locations into @INC and $PATH
  unshift @INC,
    dir($FindBin::RealBin)->parent->subdir('lib')->stringify,
    dir($FindBin::RealBin, 'lib')->stringify;
}

# for netdisco app config
use App::Netdisco;
use Dancer qw/:moose :script/;

use Try::Tiny;
use Pod::Usage;
use Scalar::Util 'blessed';
use File::Slurper qw/read_lines read_text/;
use NetAddr::IP qw/:rfc3021 :lower/;

use App::Netdisco::Backend::Job;
use App::Netdisco::JobQueue 'jq_insert';
use App::Netdisco::Util::Device 'get_device';

use Getopt::Long;
Getopt::Long::Configure ("bundling");

my ($port, $extra, $debug, $quiet, $queue_only, $force, $dryrun, $rollback);
my ($devices, $infotrace, $snmptrace, $sqltrace) = ([], 0, 0, 0);

my $result = GetOptions(
  'device|d=s@' => \$devices,
  'port|p=s'   => \$port,
  'extra|e=s'  => \$extra,
  'debug|D'    => \$debug,
  'enqueue'    => \$queue_only,
  'force'      => \$force,
  'dry-run'    => \$dryrun,
  'quiet'      => \$quiet,
  'rollback|R' => \$rollback,
  'infotrace|I+' => \$infotrace,
  'snmptrace|S+' => \$snmptrace,
  'sqltrace|Q+'  => \$sqltrace,
) or pod2usage(
  -msg => 'error: bad options',
  -verbose => 0,
  -exitval => 1,
);

if ($dryrun) {
  $ENV{ND2_WORKER_ROLL_CALL} = 1;
  $debug = 1;
}

my $CONFIG = config();
$CONFIG->{logger} = 'console';
$CONFIG->{log} = ($debug ? 'debug' : ($quiet ? 'error' : 'info'));

$ENV{INFO_TRACE} ||= $infotrace;
$ENV{SNMP_TRACE} ||= $snmptrace;
$ENV{DBIC_TRACE} ||= $sqltrace;
$ENV{ND2_DO_FORCE} ||= $force;
$ENV{ND2_DO_QUIET} ||= $quiet;
$ENV{ND2_DB_ROLLBACK} ||= $rollback;

# reconfigure logging to force console output
Dancer::Logger->init('console', $CONFIG);

info "App::Netdisco version $App::Netdisco::VERSION loaded.";

# get requested action
(my $action = shift @ARGV) =~ s/^set_//
  if scalar @ARGV;

unless ($action) {
    pod2usage(
      -msg => 'error: missing action!',
      -verbose => 2,
      -exitval => 2,
    );
}

# create worker (placeholder object for the action runner)
{
  package MyWorker;
  use Moo;
  with 'App::Netdisco::Worker::Runner';
}

# list of NetAddr::IP instances resolved from the -d params
my @hostlist = ();

sub _test_and_resolve_device {
  my $d = shift or return;
  $d =~ s/\s//g;
  return unless $d;

  my $net = NetAddr::IP->new($d);
  if (!$net or $net->num == 0 or $net->addr eq '0.0.0.0') {
      error sprintf 'unable to understand as host, IP, or prefix: %s', $d;
      exit 1;
  }

  push @hostlist, $net->hostenum;
  return;
}

foreach my $device (@$devices) {
    if (scalar grep {$action eq $_} @{ setting('job_targets_prefix') }) {
        push @hostlist, $device;
    }
    elsif ($device =~ m/^@(.+)/) {
        my $filename = $1;
        if (-f $filename) {
            debug sprintf 'opening file for reading hosts/IPs: %s', $device;
            my @dlist = read_lines $device;

            if (0 == scalar @dlist) {
                error sprintf 'unable to read devices from file: %s', $device;
                exit 2;
            }

            foreach my $entry (@dlist) {
                _test_and_resolve_device($entry);
            }
        }
        else {
            error sprintf 'unable to read devices from file: %s', $filename;
            exit 2;
        }
    }
    else {
        _test_and_resolve_device($device);
    }
}

my @job_specs = ();
my $exitstatus =  0;

if (not $force and scalar @hostlist > 512) {
    info sprintf '%s: aborted - unwise to attempt %s jobs at once', $action, (scalar @hostlist);
    exit 1;
}

if ($action =~ m/^(?:cf_|macsuck|arpnip)/ and $extra) {
    if ($extra eq '@-' or ($quiet and $extra eq '-')) {
        $extra = do { local $/; <STDIN> };
    }
    elsif ($extra =~ m/^@(.+)/) {
        my $filename = $1;
        if (-f $filename) {
            $extra = read_text($filename);
        }
        else {
            error sprintf 'unable to read from file: %s', $filename;
            exit 2;
        }
    }
}

# some actions do not take a device parameter
@hostlist = (undef) if 0 == scalar @hostlist;

foreach my $host (@hostlist) {
  push @job_specs, {
    action => $action,
    device => ref $host ? $host->addr : $host,
    port   => $port,
    subaction => $extra,
    username => ($ENV{USER} || 'netdisco-do'),
  };
}

if ($queue_only) {
  jq_insert( \@job_specs );
  info sprintf '%s: queued %s jobs at %s',
    $action, (scalar @job_specs), scalar localtime;
}
else {
  foreach my $spec (@job_specs) {
    my $worker = MyWorker->new();
    my $job = App::Netdisco::Backend::Job->new({ job => 0, %$spec });
    $CONFIG->{$1."_min_age"} = 0 if $job->action =~ m/^(arpnip|macsuck|discover)$/;
    $CONFIG->{ignore_layers} = 'group:__ANY__' if $force;

    my $actiontext = (
      ($job->device ? ('['.$job->device.']') : '') .
      ($job->action eq 'show' ? ('/'. ($job->subaction || 'interfaces')) : '')
    );

    # do job
    try {
      info sprintf '%s: %s started at %s',
        $action, $actiontext, scalar localtime;
      $worker->run($job);
    }
    catch {
      $job->status('error');
      $job->log("error running job: $_");
    };

    if ($job->log eq 'failed to report from any worker!' and not $job->only_namespace) {
      pod2usage(
        -msg => (sprintf 'error: %s is not a valid action (no worker status recorded)', $action),
        -verbose => 2,
        -exitval => 3,
      );
    }

    info sprintf '%s: finished at %s', $action, scalar localtime;
    info sprintf '%s: status %s: %s', $action, $job->status, $job->log;
    $exitstatus = 1 if !$exitstatus and $job->status ne 'done';
  }
}

exit $exitstatus;

=encoding UTF-8

=head1 NAME

netdisco-do - Run any Netdisco job from the command-line.

=head1 SYNOPSIS

 ~/bin/netdisco-do <action> [-DISQR] [--enqueue] [--force] [--quiet] [-d <device> [-p <port>] [-e <extra>]]

=head1 DESCRIPTION

This program allows you to run any Netdisco poller job from the command-line.

=head1 BEHAVIOR

Note that some jobs (C<discoverall>, C<macwalk>, C<arpwalk>, C<nbtwalk>)
simply add entries to the Netdisco job queue for other jobs, so won't seem
to do much when you trigger them. Everything else happens in real-time.

However the "C<--enqueue>" option will force the queueing of the job,
regardless of type. This may be useful for cron-driven actions, or for actions
working across large IP spaces. Netdisco will refuse to queue more than 512
jobs at once unless you also add the "C<--force>" option.

For any action, if you wish to run one of its individual worker stages, then
pass C<action::stage> as the first argument to C<netdisco-do>, for example
C<discover::neighbors>.

Any action taking a C<device> parameter can be passed either a hostname or IP
address of any interface of a known or unknown device, or an IP prefix
(subnet) which will cause C<netdisco-do> to run the action on all addresses in
that range. If the C<device> parameter begins with "C<@>" it is interpreted as
a filename to open and read hostnames, IPs, or prefixes, one per line.

The C<device> parameter may be passed multiple times. In this case, all
addresses (after expanding IP Prefixes) will be handled one by one.

=head1 ACTIONS

For a complete list of actions and their accepted parameters, see the
Netdisco wiki: https://github.com/netdisco/netdisco/wiki/Actions

=head1 DEBUG OPTIONS

The flag "C<-R>" will cause any changes to the database to be rolled back
at the end of the action.

The flags "C<-DISQ>" can be specified, multiple times, and enable the
following items in order:

=over 4

=item C<-D>

Netdisco debug log level.

=item C<-I> or C<-II>

L<SNMP::Info> trace level (1 or 2).

=item C<-S> or C<-SS> or C<-SSS>

L<SNMP> (net-snmp) trace level (1, 2 or 3).

=item C<-Q>

L<DBIx::Class> trace enabled.

=back

In case of issues with the colored output, setting the environment variable
C<ANSI_COLORS_DISABLED> or C<NO_COLOR> can be used to suppress it.

The C<< --dry-run >> option can be provided to show the workers that will run
without actually executing their content. Setting the C<ND2_WORKER_ROLL_CALL>
environment variable does the same thing.

=cut
