Blog

Photos2Folders Tutorial: Auto-Sort Images by Date and Folder

What Photos2Folders does

Photos2Folders is a small utility that automatically sorts image files into folders based on metadata (typically the photo’s creation or EXIF date) or filename patterns, letting you organize large batches without manual folder creation.

When to use it

• You have a large, unsorted photo dump from multiple cameras or phones.
• You need folders by date (year/month/day) or by camera/device.
• You want a quick one-time organization step before importing into a photo manager.

Quick setup (assumes Windows executable)

1. Download and extract Photos2Folders to a folder.
2. Place the images you want to sort into a single source folder (or point the app at a source directory).
3. Configure options:
   • Date source: EXIF Date Taken (preferred) or file creation/modification date.
   • Folder structure: choose patterns like YYYY\MM or YYYY\MM-DD.
   • Filename rules: keep original names or rename with date-time prefix.
   • Duplicates: move duplicates to a separate folder or skip.
4. Run a dry run (if available) to preview changes.
5. Execute the sort.

Recommended folder patterns

• Year/Month: YYYY\MM — good for long-term archives.
• Year/Month-Day: YYYY\MM-DD — finer granularity for frequent shoots.
• Camera-based: CameraName\YYYY — useful when combining multiple devices.

Handling common issues

• Missing EXIF dates: fallback to file creation date or use filename patterns.
• Incorrect camera timestamps: adjust timestamps first (use tools like ExifTool to shift date/time).
• Duplicates: enable checksum-based duplicate detection if available, or use a dedicated duplicate finder afterward.

Safety tips

• Always back up the source folder before running bulk operations.
• Run a preview/dry run to confirm folder mappings.
• Test with a small subset first.

Alternatives

• ExifTool (powerful command-line metadata tool).
• Dedicated photo managers (digiKam, Adobe Lightroom) for long-term workflows.

If you want, I can provide an ExifTool command to sort files into YYYY/MM folders or a sample Photos2Folders configuration for your preferred pattern.

Systematic Troubleshooting for PLC-Driven Motor Controls

Overview

A structured approach reduces downtime and prevents repeated faults. This guide provides a step-by-step workflow, specific checks, common fault signatures, diagnostic tools, and a post-repair verification checklist for PLC-driven motor control systems in industrial environments.

Safety first

• Lockout/tagout (LOTO): Isolate power and confirm zero energy before touching equipment.
• Verify control voltages: Use meter to confirm absence/presence at safe test points.
• PPE: Gloves, eye protection, and arc-rated clothing as required.

Tools & equipment

• Multimeter (true RMS)
• Clamp ammeter/insulation tester/megohmmeter
• Portable oscilloscope or handheld scope probe
• PLC programming software and laptop with comms cable
• Motor rotor lock tool and mechanical tools
• Spare fuses, contactor, overload relay, and control power supply
• Thermal camera (optional)

Step-by-step troubleshooting workflow

1. Gather quick context

   • Symptoms: Motor won’t start, trips, runs intermittently, or runs slowly.
   • When it occurs: Startup, under load, after runtime, or random.
   • Recent changes: Maintenance, firmware/ladder updates, wiring work.

2. Verify basic electrical supply

   • Check incoming mains voltage at VFD/contactor input. Confirm phase sequence and voltage within spec.
   • Inspect for blown fuses or tripped breakers on power and control circuits.

3. Confirm control power & PLC health

   • Measure PLC 24V (or system control voltage) and any auxiliary supplies.
   • Check PLC RUN/FAULT/ERROR indicators and battery/back-up supply.
   • Connect programming software; read CPU status and rack/module diagnostics.

4. Check wiring and interlocks

   • Inspect external safety interlocks (E-stops, safety relays, door switches) for proper state.
   • Verify field wiring to motor starter/contactor, overloads, and VFD control terminals for loose or damaged conductors.
   • Use continuity checks for control circuits (with power off).

5. Examine motor starter / VFD

   • For contactor-driven systems: Verify coil voltage when start command issued, inspect contact wear, and test auxiliary contacts and overload relay settings.
   • For VFD-driven systems: Check drive fault codes, DC bus voltage, cooling fan operation, and control input wiring (analog/digital).
   • Test output phases to motor for correct voltage/frequency or PWM signals.

6. Diagnose PLC-to-drive communications

   • Confirm I/O bits: monitor PLC ladder/status bits for start/stop, fault bits, and feedback signals.
   • For fieldbus/industrial Ethernet: verify link LEDs, cable integrity, IP/address settings, and device status via network diagnostics.
   • Use force/monitor in programming software only when safe and permitted.

7. Assess motor & mechanical load

   • Inspect motor for unusual noise, vibration, hot bearings, or odor.
   • Measure winding resistance and insulation (megger) to detect ground faults or shorted turns.
   • Check load coupling, gearbox, and driven equipment for jams or excessive torque.

8. Interpret common fault signatures

   • Immediate no-start with PLC start command present: contactor/coils, fuse, safety interlock, or PLC output failed.
   • Drive fault + overcurrent trips: mechanical jam, motor short, incorrect VFD parameters, or tuning needed.
   • Intermittent stops: loose wiring, overheating, intermittent sensor or encoder failure, or PLC program logic with watchdog/timeouts.

9. Repair, replace, or reconfigure

   • Replace failed hardware (contactor, overload, VFD module) using originals’ ratings.
   • Tighten/replace wiring and terminals; re-crimp connectors if corrosion evident.
   • Adjust overload settings and VFD parameters to match motor nameplate and application.

10. Test under load and verify

• Reapply power and run test cycles. Monitor currents, voltages, PLC bits, and drive parameters.
• Use thermal camera to check hotspots after short run.
• Run through start/stop cycles, reversals, and safety trips to confirm stable operation.

PLC ladder/program checks (practical steps)

• Monitor inputs/outputs in real time; locate mismatches between expected and actual states.
• Trace interlocks and safety logic paths; ensure resets are correctly handled.
• Check timers, counters, and retentive bits that may inhibit starts after faults.
• Review recent program changes and revert or compare with a known good backup if available.

Quick reference table: common faults vs. likely causes

Post-repair checklist

• Restore and verify all covers and guards.
• Confirm correct nameplate-rated settings on motor starter/VFD.
• Document fault, root cause, and corrective actions in maintenance log.
• Schedule follow-up inspection after 24–72 hours of operation.

Preventive measures

• Implement periodic thermography, vibration, and insulation testing.
• Keep spare critical components and an up-to-date PLC program backup.
• Use sensors for torque/current trending and alarm on anomalies.

If you want, I can convert this into a printable checklist, a PLC ladder troubleshooting flowchart, or a one-page quick reference — tell me which format.

Comparing JSONLIB vs. Alternatives: Which JSON Library Suits Your Project?

Choosing the right JSON library affects performance, maintainability, and developer productivity. This article compares JSONLIB (a representative JSON library) with common alternatives across key dimensions and gives concrete recommendations for different project needs.

Libraries compared

• JSONLIB — assumed feature-rich, extensible JSON parser/serializer.
• Jackson — widely used Java JSON library (high-performance, streaming + data binding).
• Gson — Google’s Java library (easy-to-use, good defaults).
• org.json (JSON-Java) — minimal, straightforward API.
• FastJSON / Jsoniter / Ultra-fast parsers — focused on raw parsing speed.

Comparison matrix (summary)

Detailed considerations

1. Performance and memory

• If raw throughput and low GC overhead are critical (high-concurrency servers, large payloads), prefer Jackson or specialized fast parsers (Jsoniter, FastJSON) configured for streaming. JSONLIB performs well for typical workloads but may lag behind top-tier parsers in microbenchmarks.

2. Streaming and large payloads

• Jackson’s streaming API (JsonParser/JsonGenerator) is mature and ideal for processing gigabytes without building full object graphs. Use streaming when you must avoid loading entire documents. JSONLIB’s streaming is suitable for moderate-sized streams; for maximum efficiency choose Jackson or Jsoniter.

3. Ease of use and developer experience

• For quick projects or prototypes, Gson or org.json provides minimal friction. JSONLIB offers a balance of usability and features; if your team prefers convention-over-configuration, Gson’s simpler model may be preferable.

4. Data binding and complex types

• For advanced mapping, polymorphic types, or extensive annotation support, Jackson has the richest toolkit (annotations, modules for Java 8 time types, Kotlin, Joda-Time, etc.). JSONLIB supports custom serializers/deserializers but lacks the same breadth of modules.

5. Customization and extensibility

• If you need custom serializers, property naming strategies, or fine-grained control over (de)serialization, prefer Jackson or JSONLIB. Gson can be extended but sometimes requires workarounds for complex scenarios.

6. Ecosystem and integrations

• Jackson integrates widely across frameworks (Spring Boot, Apache projects) and has many community modules. JSONLIB integrates sufficiently for most Java ecosystems but expect fewer third-party adapters.

7. Security and maintenance

• Choose a library with active maintenance and security responsiveness. Jackson and Gson have large user bases and frequent updates. For JSONLIB, verify the project activity and CVE history before adopting in security-sensitive contexts.

When to choose JSONLIB

• Your team wants a balanced library: reasonably fast, feature-complete, and easier to configure than lower-level streaming APIs.
• Typical payload sizes and throughput requirements are moderate.
• You need some customization but don’t require the widest module ecosystem.
• You prefer an API with clearer defaults than Jackson’s more granular configuration.

When to choose Jackson

• High throughput, low-latency services where performance and memory are critical.
• Need for robust streaming support or advanced data-binding (annotations, polymorphism).
• Integrations with major frameworks (Spring, Kafka, etc.) are important.

When to choose Gson or org.json

• Small projects, scripts, or prototypes where rapid development and simplicity matter.
• Minimal configuration and predictable behavior are more important than raw performance.

When to choose fast parsers (Jsoniter, FastJSON)

• Microservice environments processing very large volumes of JSON and willing to trade some API convenience for maximum speed.
• Benchmark and profile with real data before committing—raw speed gains depend on payload shape and use patterns.

Benchmarks and testing advice

• Always benchmark with representative payloads (structure, sizes, key counts).
• Measure both throughput and end-to-end latency under realistic GC settings and concurrency.
• Test memory pressure, streaming scenarios, and worst-case malformed input handling.
• Include security scanning and check project maintenance status.

Migration checklist (if switching libraries)

1. Inventory current JSON usage (parsing, serialization, custom serializers).
2. Run automated tests and add serialization regression tests.
3. Replace core read/write calls and validate behavior with sample payloads.
4. Address differences in default behaviors (null handling, date formats, property naming).
5. Performance-test under production-like load.
6. Monitor after rollout for unexpected errors or GC changes.

Recommendation (decisive)

• For most enterprise applications needing performance and features: choose Jackson.
• For small projects or simplicity: choose Gson or org.json.
• For extreme-performance needs: benchmark and choose a fast parser (Jsoniter/FastJSON).
• Choose JSONLIB when you want a balanced, easy-to-use library with reasonable performance and moderate customization needs—but validate project activity and run real-data benchmarks before committing.

If you want, I can produce a short benchmark plan and sample test harness (JMH) tailored to your JSON payloads.

BRYden: Pronunciation, Variations, and Popularity Trends

Pronunciation

• Primary pronunciation: BRY-den — two syllables with the first syllable rhyming with “ride” (/ˈbraɪdən/).
• Alternate pronunciations: BREE-den (/ˈbriːdən/) and BRIH-den (/ˈbrɪdən/) occur depending on regional accents and personal preference.

Variations

• Orthographic variations: Bryden, Brydon, Bridon, Brydan.
• Diminutives/nicknames: Bry, Bryd, Den, Deny.
• Related names: Brayden, Braden, Bryson — similar-sounding modern names that often get conflated with BRYden.
• Cultural/forms: Can appear as a surname or a given name; capitalizing the initial letters (BRYden) is a stylistic/brand choice.

Popularity Trends

• Contemporary usage: BRYden and similar spellings have gained visibility alongside names like Brayden/Braden since the early 2000s, driven by trends favoring “-den” endings.
• Geography: More common in English-speaking countries (U.S., U.K., Australia, Canada).
• Age cohort: Seen more among children and younger adults born in the last 20–25 years, aligning with the broader “Bray-/Bra-” name trend.
• Search/branding interest: The stylized form “BRYden” is increasingly used for branding or online handles to stand out from common spellings.

Quick guidance for use

• If naming a person: Expect pronunciation as BRY-den by default; clarify spelling to avoid confusion with Brayden/Braden.
• If using for a brand/handle: The all-caps or mixed-case “BRYden” reads as distinctive and modern; consider securing common alternate spellings to avoid misdirection.

If you want, I can provide: regional pronunciation audio guides, popularity charts over time, or sample uses for branding.

Prism of Possibilities: Creative Projects and Experiments

Overview

A hands-on collection of simple, creative activities that use prisms (glass or acrylic) and related materials to explore light, color, optics, and design. Suitable for beginners, educators, hobbyists, and makers.

What you’ll learn

• How prisms refract and disperse white light into a spectrum
• Ways to capture, manipulate, and photograph rainbows
• Basic concepts of wavelength, refraction, and internal reflection
• Creative applications in art, DIY decor, and small-scale experiments

Materials (common, low-cost)

• Glass or acrylic triangular prism (or a CD, water-filled glass, or clear triangular block)
• Flashlight or direct sunlight
• White screen or sheet of paper
• Colored filters/gels, mirrors, tape, mounting putty
• Smartphone or camera for documentation
• Protractor, ruler, and dark room or shaded area

8 Creative Projects (quick list)

1. Rainbow Projection — Cast a spectrum onto paper using direct sun + prism.
2. Mobile Light Sculpture — Suspend multiple prisms to create moving rainbow patterns.
3. Spectrum Photography — Capture high-contrast rainbow shots; experiment with exposure and angles.
4. DIY Kaleidoscope — Use small prisms and mirrors to build a simple kaleidoscope.
5. Color-Mixing Shadows — Combine prisms and colored gels to study additive color blending.
6. Water Prism — Use a triangular water-filled container to demonstrate dispersion without a manufactured prism.
7. Polarization Play — Combine prism dispersion with polarized filters to explore intensity changes.
8. Interactive Exhibit — Create a table station where viewers adjust prism angle to move the spectrum.

Step-by-step: Rainbow Projection (quick)

1. Set prism on a stable surface in sunlight or strong flashlight beam.
2. Place a white sheet 0.5–2 meters away to catch the spectrum.
3. Rotate prism slowly until a clear band of colors appears.
4. Move the sheet to adjust focus and spread.
5. Photograph with camera set to low ISO and faster shutter to capture vivid colors.

Safety tips

• Never point bright light into eyes.
• Handle glass prisms carefully to avoid chips/breaks.
• Supervise children during experiments.

Extensions (for learners & educators)

• Measure angles of incidence/refraction and calculate refractive index using Snell’s law.
• Build lesson plans pairing visual demos with short labs on wavelength and visible spectrum.
• Integrate art by creating prints from projected spectra or using prisms in mixed-media pieces.

If you’d like, I can expand any single project into a full activity sheet with materials list, photos, expected results, and assessment questions.

Tempered Glass Notepad with Pen Holder — Product Overview

What it is:
A tempered glass notepad is a slim, durable glass board sized like a notepad (often A5–A4). It functions as a reusable writing surface for notes, lists, sketches, and reminders. The integrated pen holder keeps a dry-erase or wet-erase marker accessible and prevents lost pens.

Key features:

• Tempered glass surface: Scratch-resistant, smooth writing, easy to erase.
• Pen holder: Built-in groove, magnetic strip, or attached loop to store a marker or stylus.
• Erasable: Works with dry-erase markers and some wet-erase markers; cleans without ghosting.
• Slim frame or frameless design: Modern, minimal look that sits flat on a desk or hangs on a wall.
• Non-porous & hygienic: Resists stains and bacteria, simple to sanitize.
• Magnetic compatibility (optional): Some models accept magnets for holding photos or notes.
• Rubber feet or bumpers: Prevent slipping and protect desk surfaces.

Benefits:

• Eco-friendly: Reusable surface reduces paper waste.
• Durable: Tempered glass resists chips and scratches better than regular glass or plastic.
• Aesthetic: Clean, modern look that elevates workspace design.
• Organized desk: Pen always at hand; notes visible without clutter.
• Versatile use: Daily planning, quick sketches, brainstorming, reminders, menus, or recipes.

Typical specs to compare when buying:

• Size (A5, A4, A3)
• Glass thickness (commonly 3–6 mm)
• Pen type included (dry-erase, wet-erase, liquid chalk)
• Pen holder style (groove, magnetic, loop)
• Mounting options (desktop, wall, easel)
• Weight and rubber feet presence
• Warranty and scratch/chip resistance rating

Care & maintenance:

• Wipe with a microfiber cloth and standard dry-erase cleaner or glass cleaner.
• For stubborn marks, use isopropyl alcohol or a non-abrasive cleaner.
• Avoid abrasive pads or harsh chemical strippers to prevent surface damage.
• Store marker horizontally and replace ink cartridges as needed.

Use-case examples:

• Home office — daily to-dos and meeting notes.
• Creative studio — quick sketches and color testing.
• Kitchen — weekly meal plans and grocery lists.
• Retail or café — menu specials written in erasable marker.
• Gift — stylish, practical present for students or professionals.

If you want, I can write a short product description, bullet-point specs for a listing, or a 50–70 word marketing blurb.

I couldn’t find reliable web sources for “CTClick.” I’ll proceed using a reasonable assumption: CTClick is a click-tracking/attribution tool. Here’s a concise 2026-style review covering features, pricing, and alternatives.

CTClick Review 2026: Features, Pricing, and Alternatives

Summary

• CTClick (assumed) is a click-tracking and campaign attribution platform focused on real-time tracking, link management, and conversion attribution for performance marketers and affiliates.

Key features

• Real-time click tracking: Millisecond-resolution click logs with IP, UA, referrer, timestamp.
• Advanced attribution: Last-click, multi-touch, and configurable lookback windows.
• Link management: Branded short links, UTM automation, and rotator links for A/B testing.
• Fraud detection: IP protection, bot filters, invalid click scoring, and automated blocking.
• Integrations: Webhooks, server-to-server postbacks, Google Analytics/GA4, major ad networks, Zapier.
• Audience & conversion tracking: Pixel/snippet and server-side conversion APIs.
• Reporting & analytics: Custom dashboards, cohort analysis, funnel visualization, exportable CSV/JSON.
• SLA & compliance: GDPR/CCPA support, data retention controls, and optional EU data region (assumed).

Pricing (estimated tiers)

• Free: Basic link tracking, limited clicks/month (e.g., 5k), basic reports.
• Pro (\(49–\)99/mo): Higher limits (50k–200k clicks), A/B rotators, fraud filters, integrations.
• Business (\(199–\)499/mo): Multi-domain, team seats, priority support, S2S postbacks.
• Enterprise (custom): Dedicated IPs, SLAs, custom integrations,

SynchronEX: The Future of Real-Time Data Integration

What it is

SynchronEX is a real-time data integration platform that synchronizes data across systems, services, and applications with low latency and strong consistency guarantees. It’s designed for modern, distributed architectures where up-to-date data across multiple endpoints is critical.

Key capabilities

• Real-time replication: Streams changes as they occur (CDC-style) to target systems with minimal delay.
• Schema-aware transformations: Applies schema mappings and lightweight transformations during the sync pipeline.
• Event ordering & consistency: Preserves causal ordering and offers configurable consistency levels (at-most-once, at-least-once, exactly-once where supported).
• Connectors: Prebuilt connectors for databases (SQL/NoSQL), message brokers, data lakes, SaaS APIs, and event platforms.
• Monitoring & observability: End-to-end metrics, latency histograms, and alerting for pipeline health.
• Security & compliance: Encryption in transit/rest, role-based access control, and audit logs for change provenance.

Typical architecture

1. Change capture: CDC agents or source connectors produce change events.
2. Ingestion: A streaming layer buffers and batches events (Kafka-like).
3. Processing: Transformation layer applies mappings, enrichment, and schema validation.
4. Delivery: Sink connectors write to target stores or publish to topics.
5. Control plane: UI/API for configuration, versioning, and monitoring.

Common use cases

• Multi-region data replication for low-latency reads.
• Synchronizing SaaS CRMs with internal databases.
• Feeding analytics data lakes with up-to-the-second events.
• Maintaining cache coherence across services.
• Migrating data with minimal downtime.

Benefits

• Reduced staleness — clients read near-instant data.
• Simplified integration — fewer bespoke ETL scripts.
• Lower downtime during migrations or failovers.
• Easier compliance tracking through auditable change logs.

Trade-offs / Considerations

• Operational complexity: requires monitoring and capacity planning.
• Cost: continuous streaming and connectors can increase infrastructure spend.
• Exactly-once semantics: may be limited by source/target capabilities.
• Schema evolution: needs careful handling to avoid downstream breakage.

Quick implementation checklist

1. Inventory sources and sinks; verify connector availability.
2. Define required consistency and latency SLAs.
3. Design schema mapping and transformation rules.
4. Pilot with a noncritical dataset; measure lag and error rates.
5. Add alerting, retention policies, and access controls.
6. Roll out incrementally and validate data fidelity.

If you want, I can draft an implementation plan for a specific stack (e.g., Postgres → Kafka → Redshift) or generate sample configuration snippets.

Automating Kill Proc: Scripts to Monitor and Restart Failed Services

Maintaining reliable services often means detecting failures and restarting processes automatically. This guide shows practical, safe ways to monitor processes, kill stuck or misbehaving ones, and restart services using short scripts and tools on Linux and macOS (Windows notes at the end). Examples use common shell utilities so you can adapt them to your environment.

Goals

• Detect unresponsive or resource-hogging processes.
• Gracefully stop or forcefully kill when necessary.
• Restart services and notify operators.
• Run checks periodically or as a lightweight watchdog.

Principles and safety

• Prefer graceful shutdowns (SIGTERM) before forceful kills (SIGKILL).
• Confirm process identity to avoid killing the wrong PID (match by owner, command, and start time).
• Add logging and rate limits to avoid restart loops.
• Test scripts in staging before production.

Simple monitor + restart (systemd-friendly)

Use systemd for services where possible—systemd already handles restarts robustly. For small custom daemons not managed by systemd, use this script to detect failure and restart.

Script: monitor-restart.sh

bash
Copy CodeCopied
#!/usr/bin/env bash
SERVICE_CMD=”/usr/local/bin/mydaemon”
SERVICE_NAME=“mydaemon”
LOGFILE=”/var/log/\({SERVICE_NAME}</span><span class="token" style="color: rgb(163, 21, 21);">-watch.log"</span><span> </span><span></span><span class="token assign-left" style="color: rgb(54, 172, 170);">MAX_RESTARTS</span><span class="token" style="color: rgb(57, 58, 52);">=</span><span class="token" style="color: rgb(54, 172, 170);">5</span><span> </span><span></span><span class="token assign-left" style="color: rgb(54, 172, 170);">RESTART_WINDOW</span><span class="token" style="color: rgb(57, 58, 52);">=</span><span class="token" style="color: rgb(54, 172, 170);">300</span><span></span><span class="token" style="color: rgb(0, 128, 0); font-style: italic;"># seconds</span><span> </span><span></span><span class="token assign-left" style="color: rgb(54, 172, 170);">PIDFILE</span><span class="token" style="color: rgb(57, 58, 52);">=</span><span class="token" style="color: rgb(163, 21, 21);">"/var/run/</span><span class="token" style="color: rgb(54, 172, 170);">\){SERVICE_NAME}.pid”

log(){ echo “\((</span><span class="token" style="color: rgb(57, 58, 52);">date</span><span class="token" style="color: rgb(54, 172, 170);"> --iso-8601</span><span class="token" style="color: rgb(57, 58, 52);">=</span><span class="token" style="color: rgb(54, 172, 170);">seconds</span><span class="token" style="color: rgb(54, 172, 170);">)</span><span class="token" style="color: rgb(163, 21, 21);"> </span><span class="token" style="color: rgb(54, 172, 170);">\)” >>“\(LOGFILE</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(57, 58, 52);">;</span><span> </span><span class="token" style="color: rgb(57, 58, 52);">}</span><span> </span> <span></span><span class="token" style="color: rgb(0, 128, 0); font-style: italic;"># Ensure only one watcher runs</span><span> </span><span></span><span class="token builtin" style="color: rgb(43, 145, 175);">exec</span><span> </span><span class="token file-descriptor" style="color: rgb(238, 153, 0); font-weight: bold;">9</span><span class="token" style="color: rgb(57, 58, 52);">></span><span>/var/lock/</span><span class="token" style="color: rgb(54, 172, 170);">\){SERVICE_NAME}.lock if ! flock -n 9; then
  log “Watcher already running, exiting.”
  exit 1
fi

# Track restarts (simple file-based)
touch /var/run/\({SERVICE_NAME}</span><span>.restarts </span><span></span><span class="token assign-left" style="color: rgb(54, 172, 170);">now</span><span class="token" style="color: rgb(57, 58, 52);">=</span><span class="token" style="color: rgb(54, 172, 170);">\)(date +%s)
# prune old entries
awk -v now=“\(now</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span> -v </span><span class="token assign-left" style="color: rgb(54, 172, 170);">w</span><span class="token" style="color: rgb(57, 58, 52);">=</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(54, 172, 170);">\)RESTART_WINDOW” ‘BEGIN{ORS=” “} { if (now - \(1 <= w) print \)0 }’ /var/run/\({SERVICE_NAME}</span><span>.restarts </span><span class="token" style="color: rgb(57, 58, 52);">></span><span> /var/run/</span><span class="token" style="color: rgb(54, 172, 170);">\){SERVICE_NAME}.restarts.tmp mv /var/run/\({SERVICE_NAME}</span><span>.restarts.tmp /var/run/</span><span class="token" style="color: rgb(54, 172, 170);">\){SERVICE_NAME}.restarts 
is_running(){
  if [ -f ”\(PIDFILE</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span> </span><span class="token" style="color: rgb(57, 58, 52);">]</span><span class="token" style="color: rgb(57, 58, 52);">;</span><span> </span><span class="token" style="color: rgb(0, 0, 255);">then</span><span> </span><span>    </span><span class="token assign-left" style="color: rgb(54, 172, 170);">pid</span><span class="token" style="color: rgb(57, 58, 52);">=</span><span class="token" style="color: rgb(54, 172, 170);">\)(cat “\(PIDFILE</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(54, 172, 170);">)</span><span> </span><span>    </span><span class="token" style="color: rgb(0, 0, 255);">if</span><span> </span><span class="token" style="color: rgb(57, 58, 52);">kill</span><span> -0 </span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(54, 172, 170);">\)pid” 2>/dev/null; then
      return 0
    fi
  fi
  return 1
}

start_service(){
  log “Starting \(SERVICE_NAME</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span> </span><span>  </span><span class="token" style="color: rgb(54, 172, 170);">\)SERVICE_CMD &> /var/log/\({SERVICE_NAME}</span><span>.out </span><span class="token" style="color: rgb(57, 58, 52);">&</span><span> </span><span>  </span><span class="token builtin" style="color: rgb(43, 145, 175);">echo</span><span> </span><span class="token" style="color: rgb(54, 172, 170);">\)! > ”\(PIDFILE</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span> </span><span>  </span><span class="token builtin" style="color: rgb(43, 145, 175);">echo</span><span> </span><span class="token" style="color: rgb(54, 172, 170);">\)(date +%s) >> /var/run/\({SERVICE_NAME}</span><span>.restarts </span><span></span><span class="token" style="color: rgb(57, 58, 52);">}</span><span> </span> <span></span><span class="token function-name" style="color: rgb(57, 58, 52);">stop_service</span><span class="token" style="color: rgb(57, 58, 52);">(</span><span class="token" style="color: rgb(57, 58, 52);">)</span><span class="token" style="color: rgb(57, 58, 52);">{</span><span> </span><span>  </span><span class="token" style="color: rgb(0, 0, 255);">if</span><span> </span><span class="token" style="color: rgb(57, 58, 52);">[</span><span> -f </span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(54, 172, 170);">\)PIDFILE“ ]; then
    pid=\((</span><span class="token" style="color: rgb(57, 58, 52);">cat</span><span class="token" style="color: rgb(54, 172, 170);"> </span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(163, 21, 21);">\)PIDFILE”)
    if kill -TERM “\(pid</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span> </span><span class="token file-descriptor" style="color: rgb(238, 153, 0); font-weight: bold;">2</span><span class="token" style="color: rgb(57, 58, 52);">></span><span>/dev/null</span><span class="token" style="color: rgb(57, 58, 52);">;</span><span> </span><span class="token" style="color: rgb(0, 0, 255);">then</span><span> </span><span>      log </span><span class="token" style="color: rgb(163, 21, 21);">"Sent SIGTERM to </span><span class="token" style="color: rgb(54, 172, 170);">\)pid”
      # wait up to 10s
      for i in {1..10}; do
        if ! kill -0 “\(pid</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span> </span><span class="token file-descriptor" style="color: rgb(238, 153, 0); font-weight: bold;">2</span><span class="token" style="color: rgb(57, 58, 52);">></span><span>/dev/null</span><span class="token" style="color: rgb(57, 58, 52);">;</span><span> </span><span class="token" style="color: rgb(0, 0, 255);">then</span><span> </span><span class="token builtin" style="color: rgb(43, 145, 175);">break</span><span class="token" style="color: rgb(57, 58, 52);">;</span><span> </span><span class="token" style="color: rgb(0, 0, 255);">fi</span><span> </span><span>        </span><span class="token" style="color: rgb(57, 58, 52);">sleep</span><span> </span><span class="token" style="color: rgb(54, 172, 170);">1</span><span> </span><span>      </span><span class="token" style="color: rgb(0, 0, 255);">done</span><span> </span><span>      </span><span class="token" style="color: rgb(0, 0, 255);">if</span><span> </span><span class="token" style="color: rgb(57, 58, 52);">kill</span><span> -0 </span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(54, 172, 170);">\)pid” 2>/dev/null; then
        kill -KILL “\(pid</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span> </span><span class="token file-descriptor" style="color: rgb(238, 153, 0); font-weight: bold;">2</span><span class="token" style="color: rgb(57, 58, 52);">></span><span>/dev/null </span><span class="token" style="color: rgb(57, 58, 52);">&&</span><span> log </span><span class="token" style="color: rgb(163, 21, 21);">"Sent SIGKILL to </span><span class="token" style="color: rgb(54, 172, 170);">\)pid”
      fi
    fi
    rm -f “\(PIDFILE</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span> </span><span>  </span><span class="token" style="color: rgb(0, 0, 255);">fi</span><span> </span><span></span><span class="token" style="color: rgb(57, 58, 52);">}</span><span> </span> <span></span><span class="token" style="color: rgb(0, 128, 0); font-style: italic;"># Main</span><span> </span><span></span><span class="token" style="color: rgb(0, 0, 255);">if</span><span> is_running</span><span class="token" style="color: rgb(57, 58, 52);">;</span><span> </span><span class="token" style="color: rgb(0, 0, 255);">then</span><span> </span><span>  log </span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(54, 172, 170);">\)SERVICE_NAME already running”
  exit 0
fi

# check restart rate
restarts=\((</span><span class="token" style="color: rgb(57, 58, 52);">wc</span><span class="token" style="color: rgb(54, 172, 170);"> -l </span><span class="token" style="color: rgb(57, 58, 52);"><</span><span class="token" style="color: rgb(54, 172, 170);"> /var/run/\){SERVICE_NAME}.restarts)
if [ “\(restarts</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span> -ge </span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(54, 172, 170);">\)MAX_RESTARTS” ]; then
  log “Too many restarts (\(restarts</span><span class="token" style="color: rgb(163, 21, 21);"> in last </span><span class="token" style="color: rgb(54, 172, 170);">\)RESTART_WINDOW s). Not restarting.”
  exit 2
fi

startservice 

bash
 ffON2NH02oMAcqyoh2UU MQCbz04ET5EljRmK3YpQ CPXAhl7VTkj2dHDyAYAf” data-copycode=“true” role=“button” aria-label=“Copy Code”>Copy CodeCopied
#!/usr/bin/env bash
TARGET_CMD=“mydaemon”
CPU_LIMIT=80.0   # percent
MEM_LIMIT=$((10241024))  # KiB, e.g., 1 GiB = 1048576 KiB

for pid in \((</span><span class="token" style="color: rgb(54, 172, 170);">pgrep -f </span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(163, 21, 21);">\)TARGET_CMD“); do
  read pid cmd <<< ”\((</span><span class="token" style="color: rgb(57, 58, 52);">ps</span><span class="token" style="color: rgb(54, 172, 170);"> -p \)pid -o pid= -o comm=)“
  cpu=\((</span><span class="token" style="color: rgb(57, 58, 52);">ps</span><span class="token" style="color: rgb(54, 172, 170);"> -p \)pid -o %cpu= | awk ’{print \(1}'</span><span class="token" style="color: rgb(54, 172, 170);">)</span><span> </span><span>  </span><span class="token assign-left" style="color: rgb(54, 172, 170);">rss</span><span class="token" style="color: rgb(57, 58, 52);">=</span><span class="token" style="color: rgb(54, 172, 170);">\)(awk ’/VmRSS/ {print \(2}'</span><span class="token" style="color: rgb(54, 172, 170);"> /proc/\)pid/status 2>/dev/null || echo 0)
  # compare CPU (float) or memory (int)
  cpu_exceeded=\((</span><span class="token" style="color: rgb(57, 58, 52);">awk</span><span class="token" style="color: rgb(54, 172, 170);"> -v </span><span class="token assign-left" style="color: rgb(54, 172, 170);">c</span><span class="token" style="color: rgb(57, 58, 52);">=</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(163, 21, 21);">\)cpu” -v lim=“\(CPU_LIMIT</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(54, 172, 170);"> </span><span class="token" style="color: rgb(163, 21, 21);">'BEGIN{print (c>lim)?1:0}'</span><span class="token" style="color: rgb(54, 172, 170);">)</span><span> </span><span>  </span><span class="token assign-left" style="color: rgb(54, 172, 170);">mem_exceeded</span><span class="token" style="color: rgb(57, 58, 52);">=</span><span class="token" style="color: rgb(54, 172, 170);">\)([ ”\(rss</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(54, 172, 170);"> -gt </span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(163, 21, 21);">\)MEM_LIMIT“ ] && echo 1 || echo 0)
  if [ ”\(cpu_exceeded</span><span class="token" style="color: rgb(163, 21, 21);">"</span><span> -eq </span><span class="token" style="color: rgb(54, 172, 170);">1</span><span> </span><span class="token" style="color: rgb(57, 58, 52);">]</span><span> </span><span class="token" style="color: rgb(57, 58, 52);">||</span><span> </span><span class="token" style="color: rgb(57, 58, 52);">[</span><span> </span><span class="token" style="color: rgb(163, 21, 21);">"</span><span class="token" style="color: rgb(54, 172, 170);">\)mem_exceeded“ -eq 1 ]; then
    echo ”\((</span><span class="token" style="color: rgb(57, 58, 52);">date</span><span class="token" style="color: rgb(54, 172, 170);">)</span><span class="token" style="color: rgb(163, 21, 21);"> Killing </span><span class="token" style="color: rgb(54, 172, 170);">\)pid (\(cmd</span><span class="token" style="color: rgb(163, 21, 21);">) cpu=</span><span class="token" style="color: rgb(54, 172, 170);">\)cpu rss=\({rss}</span><span class="token" style="color: rgb(163, 21, 21);">KiB"</span><span> </span><span>    </span><span class="token" style="color: rgb(57, 58, 52);">kill</span><span> -</span><span class="token environment" style="color: rgb(54, 172, 170);">TERM</span><span> </span><span class="token" style="color: rgb(54, 172, 170);">\)pid
    sleep 5
    if kill -0 \(pid</span><span> </span><span class="token file-descriptor" style="color: rgb(238, 153, 0); font-weight: bold;">2</span><span class="token" style="color: rgb(57, 58, 52);">></span><span>/dev/null</span><span class="token" style="color: rgb(57, 58, 52);">;</span><span> </span><span class="token" style="color: rgb(0, 0, 255);">then</span><span> </span><span>      </span><span class="token" style="color: rgb(57, 58, 52);">kill</span><span> -KILL </span><span class="token" style="color: rgb(54, 172, 170);">\)pid
    fi
    # optionally restart via systemd or custom command:
    # systemctl restart mydaemon.service
  fi
done

Code
 ffON2NH02oMAcqyoh2UU MQCbz04ET5EljRmK3YpQ CPXAhl7VTkj2dHDyAYAf” data-copycode=“true” role=“button” aria-label=“Copy Code”>Copy CodeCopied
[Service] ExecStart=/usr/local/bin/mydaemon Restart=on-failure RestartSec=5 StartLimitBurst=5 StartLimitIntervalSec=300 

bash
Copy CodeCopied
curl -X POST -H ‘Content-type: application/json’ -d ”{“text”:“mydaemon restarted on $(hostname)”}” https://hooks.slack.com/services/...