view release on metacpan or  search on metacpan

bin/devmode  view on Meta::CPAN

            };
            $session{$1} = $session{$2}
        }
    }
    close $screen;

    return map { $_ => $session{$_} } grep { $_ ne $session{$_}{pid} } keys %session;

}

# runs a ssh-agent protecting screen session
sub protect {
    my ($task) = @_;
    my $protect_dir = "$ENV{HOME}/.devmode_prot";
    if ( !-d $protect_dir ) {
        mkdir $protect_dir;
    }

    my $protect_rc = file $protect_dir, $task;
    if ( !-f $protect_rc ) {
        create_task( $task, 'rcprot', $protect_dir );
    }

    for my $env ( keys %ENV ) {
        delete $ENV{$env} if $env =~ /ssh/i;
    }
    my $cmd = "$SCREEN -S PROT_$task -c $protect_rc";
    if ($option{test}) {
        warn $cmd;
        exit 0;
    }
    exec $cmd or error( COULD_NOT_LAUNCH_SCREEN_PROTECTION => $cmd, $OS_ERROR );
}

sub force_title {
    my ($task) = @_;

    require Term::Title;
    Term::Title::set_titlebar(
        ( $option{short} ? '' : "Devmode " )
        . ( $option{title_bar} || $task )
    );

    return;
}

sub create_task {
    my ( $task, $template, $out_dir ) = @_;

    require Template;
    require Template::Provider::FromDATA;

    # Create the provider
    my $provider = Template::Provider::FromDATA->new({
        CLASSES => __PACKAGE__,
    });

    # Add the provider to the config
    my $tt = Template->new({
        LOAD_TEMPLATES => [ $provider ],
        OUTPUT_PATH    => $out_dir,
    });

    my %data = (
        cwd     => file('.')->absolute->resolve,
        devmode => file($0)->absolute->resolve,
        task    => $task,
    );

    $tt->process( $template, \%data, lc $task ) or error( COULD_NOT_CREATE_CONFIG => $tt->error() );

    return "$out_dir/$task";
}

sub auto {
    my ($type) = @_;

    if ( $type eq 'ssh' ) {
        my @hosts
            = map {
                /(.*?)(?:#.*)?$/;
                my ($addr, @a) = split /\s+/, $1;
                @a;
            }
            grep {
                !/^\s*$/ && !/^\s*#/
            }
            map {
                /(.*)\n/;
                $1 || $_
            }
            file('/etc/hosts')->slurp;
        push @hosts,
            map {
                /(?:Host\s*)?(.*)/;
                $1;
            }
            grep {
                /^Host /
            }
            map {
                /(.*)\n/;
                $1 || $_
            }
            file("$ENV{HOME}/.ssh/config")->slurp;
        print join ' ', uniq sort @hosts;
        exit 0;
    }
    elsif ( $type eq 'full' ) {
        my @names;
        my @running;
        if ( $option{server} ) {
            @names = remote_cache($option{server});
        }
        else {
            @names
                = sort {
                    my $A = $a;
                    $A =~ s/(\d+)/sprintf "%05d", $1/egxms;
                    my $B = $b;
                    $B =~ s/(\d+)/sprintf "%05d", $1/egxms;