Het beheren van een moderne bedrijfsomgeving kan zelfs de moeilijkste IT-strijders zweten – vooral als je een vloot van koppige eindpunten moet opnieuw opstarten. , een door Python aangedreven massale reboot-tool, ontworpen voor beheerders die geen tijd hebben voor click-by-click-monotonie. Net als een echte Barberion, snijdt het je lijst met machines door met snelheid, kracht en nul geduld voor obstakels. BarbaricBoot Wat is BarbaricBoot? is een command-line Python-script dat een lijst van computernamen leest en parallelle opstart op hen loslaat, waarbij elke overwinning en nederlaag langs de weg wordt gerapporteerd. Elke mislukte reboot wordt geregistreerd – elke succesvolle reboot is een andere gewonnen strijd. BarbaricBoot shutdown Waarom BarbaricBoot? 
 
 
 
 
 Efficiëntie: Honderden machines opnieuw opstarten in minuten, niet uren. Eenvoud: één bestand, één opdracht, minimale installatie. Aansprakelijkheid: realtime feedback over successen en mislukkingen. No-Nonsense Barbarian Spirit: Gewoon opnieuw opstarten 'em all - geen excuses, geen medelijden. Hoe het werkt 
 
 
 
 Invoer: Drop uw machinenamen (één per rij) in pcs.log. Uitvoering: BarbaricBoot aanvallen met behulp van concurrent.futures van Python om tot 20 parallelle opnieuw opstarten tegelijk te starten. Feedback: U krijgt real-time getallen van succes en falen, plus gedetailleerde logs van machines die uw opdracht weigeren. Hoe te installeren en gebruiken BarbaricBoot vereisten 
 
 
 
 Python 3.6 of hoger Windows-beheerdersrechten (voor rechten op afstand sluiten) Een pcs.log-bestand met een lijst van je doelmachines (één per lijn) instellen 
 
 
 
 **Save the Script
\  Copy the complete   code (provided below) to your admin machine. BarbaricBoot.py **Prepare Your Targets
\  Create a plain text file called   in the same directory as your script, listing each machine to be rebooted. pcs.log **Run BarbaricBoot
\  Open a terminal and execute: “Python BarbericBoot.py“ De volledige code #Another        /\_[]_/\
#    fine      |] _||_ [|
#       ___     \/ || \/
#      /___\       ||
#     (|0 0|)      ||
#   __/{\U/}\_ ___/vvv
#  / \  {~}   / _|_P|
#  | /\  ~   /_/   []
#  |_| (____)        
#  \_]/______\  Barberion  
#     _\_||_/_     Production      
#    (_,_||_,_)
#
import concurrent.futures
import subprocess
import logging
from threading import Lock

# Set up logging for failed reboots
logging.basicConfig(filename='failed_reboots.log', level=logging.INFO)

# Lock for thread-safe printing and updating counters
print_lock = Lock()

def reboot_machine(machine_name, success_counter, failure_counter):
    try:
        subprocess.run(['shutdown', '/r', '/t', '0', '/m', f'\\\\{machine_name}', '/f'], 
                       check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        with print_lock:
            success_counter[0] += 1
            print(f"\rTotal successful reboots: {success_counter[0]}, Total failed reboots: {failure_counter[0]}", end='')
    except subprocess.CalledProcessError as e:
        with print_lock:
            failure_counter[0] += 1
            print(f"\rTotal successful reboots: {success_counter[0]}, Total failed reboots: {failure_counter[0]}", end='')
        logging.error(f"Failed to reboot {machine_name}: {e}")

def main():
    with open('pcs.log') as file:
        machines = file.readlines()

    total_hosts = len(machines)
    print(f"Total hosts in file: {total_hosts}")

    # Shared counters for successful and failed reboots
    successful_reboots = [0]
    failed_reboots = [0]

    # Use ThreadPoolExecutor for parallel execution
    with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
        futures = [executor.submit(reboot_machine, machine.strip(), successful_reboots, failed_reboots) for machine in machines]

        # Wait for all tasks to complete, i suppose you can  comment out for rapid fire.
        concurrent.futures.wait(futures)

    # Final print to ensure the last count is displayed correctly
    print(f"\nFinal count - Total successful reboots: {successful_reboots[0]}, Total failed reboots: {failed_reboots[0]}")

if __name__ == "__main__":
    main()
 Customisatie Tips 
 
 
 
 Verhoog of Verminder Parallelisme: Tweak max_workers=20 voor meer of minder parallelle aanvallen, afhankelijk van de tolerantie van uw omgeving. Loggen: Alle mislukte pogingen worden opgeslagen in failed_reboots.log voor latere beoordeling. Rapid Fire Option: Commentaar op de concurrent.futures.wait(futures) lijn als u het script wilt laten ontsteken en verplaatsen Laatste gedachten BarbaricBoot is niet voor de verlegenen. Gebruik het verantwoordelijk, gebruik het verstandig, en onthoud: met grote kracht komt grote verantwoordelijkheid. Moge uw herstart snel zijn, uw logs schoon, en uw eindpunten altijd-conform!

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

Read My Stories

Deze audio wordt geproduceerd in de originele taal van het verhaal!

BarbaricBoot is het massale reboot-tool dat je IT-afdeling niet wist dat het nodig was

About Author

OPMERKINGEN

LABELS

DIT ARTIKEL WERD GEPRESENTEERD IN

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps