killport 2.0.0

A command-line tool to easily kill processes and containers running on a specified port.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! The `killport` command-line utility is designed to kill processes
//! listening on specified ports.
//!
//! The utility accepts a list of port numbers as input and attempts to
//! terminate any processes listening on those ports.

use clap::Parser;
use log::error;
use log::LevelFilter;
use std::io::Write;
use std::process::exit;

use killport::cli::{service_descriptors, KillPortArgs};
use killport::killport::Killport;

fn main() {
    // Reset SIGPIPE to default behavior so piping output (e.g., `killport 8080 | head`)
    // exits silently instead of panicking with a broken pipe error.
    #[cfg(unix)]
    unsafe {
        nix::libc::signal(nix::libc::SIGPIPE, nix::libc::SIG_DFL);
    }

    // Parse command-line arguments
    let args = KillPortArgs::parse();

    // Set up logging environment
    let log_level = args
        .verbose
        .log_level()
        .map(|level| level.to_level_filter())
        .unwrap_or(LevelFilter::Off);

    env_logger::builder()
        .format(move |buf, record| {
            if log_level <= LevelFilter::Info {
                writeln!(buf, "{}", record.args())
            } else {
                // Default format for lower levels
                writeln!(
                    buf,
                    "[{}] {}: {}",
                    record.target(),
                    record.level(),
                    record.args()
                )
            }
        })
        .format_module_path(log_level == log::LevelFilter::Trace)
        .format_target(log_level == log::LevelFilter::Trace)
        .format_timestamp(Option::None)
        .filter_level(log_level)
        .init();

    let (service_type_singular, _service_type_plural) = service_descriptors(args.mode);

    // Create an instance of Killport
    let killport = Killport::with_real_deps().unwrap_or_else(|e| {
        error!("Failed to initialize: {}", e);
        exit(1);
    });

    // Attempt to kill processes listening on specified ports
    let mut any_not_found = false;

    for port in args.ports {
        match killport.kill_service_by_port(port, args.signal.clone(), args.mode, args.dry_run) {
            Ok(killed_services) => {
                if killed_services.is_empty() {
                    println!("No {} found using port {}", service_type_singular, port);
                    any_not_found = true;
                } else {
                    for (killable_type, name) in killed_services {
                        let action = if args.dry_run {
                            "Would kill"
                        } else {
                            "Successfully killed"
                        };
                        println!(
                            "{} {} '{}' listening on port {}",
                            action, killable_type, name, port
                        );
                    }
                }
            }
            Err(err) => {
                error!("{}", err);
                exit(1);
            }
        }
    }

    if any_not_found && !args.no_fail {
        exit(2);
    }
}