DEV Community: Jefster Farlei Fernandes Caixeta Junior

Automating Remote Branch Cleanup in Azure DevOps Using Git and Bash

Jefster Farlei Fernandes Caixeta Junior — Fri, 07 Mar 2025 14:08:15 +0000

Managing remote branches is crucial in keeping a Git repository clean and efficient. Over time, stale branches accumulate, making navigation harder and slowing down repository operations. In Azure DevOps, branches that haven't been used in months can clutter your repository, potentially causing confusion and unnecessary storage costs.

This article presents a Bash script to automate the deletion of remote branches that haven't been modified in over three months. By the end of this guide, you'll have a simple but powerful tool to maintain a clean repository in Azure Repos.

Why Delete Old Remote Branches?

Reduce Clutter – Old feature branches make the repository hard to navigate.
Improve Performance – Fewer branches mean faster Git operations.
Enforce Best Practices – Encourages developers to clean up after merging.
Save Storage Space – Reducing unnecessary data stored in Azure DevOps.

The Problem: Stale Branches in Azure DevOps

If you're working on an Azure DevOps repository, you may notice an increasing number of old branches that are no longer relevant. Manually identifying and deleting these branches is tedious, especially in large teams.

The Solution: Automate Cleanup with Bash + Git

1. We can automate this process by writing a Bash script that:
2. Fetches all remote branches.
3. Check the last commit date for each branch.
4. Deletes branches that haven't been modified in 3+ months.
Asks for confirmation before deleting.

The Bash Script

Below is a fully automated script to clean up remote branches in Azure DevOps repositories:

#!/bin/bash

# Remote repository (default to origin)
REMOTE=${1:-origin}

# Time threshold (3 months ago)
THRESHOLD_DATE=$(date -d "3 months ago" +%s)

# Fetch latest remote branches
git fetch --prune $REMOTE

echo "Checking remote branches older than 3 months..."

# Get remote branches and last commit date
OLD_BRANCHES=()
while read -r branch last_commit_date; do
    # Convert last commit date to Unix timestamp
    LAST_COMMIT_TIMESTAMP=$(date -d "$last_commit_date" +%s)

    # Compare with threshold
    if [[ "$LAST_COMMIT_TIMESTAMP" -lt "$THRESHOLD_DATE" ]]; then
        OLD_BRANCHES+=("$branch")
    fi
done < <(git for-each-ref --format '%(refname:short) %(committerdate:iso8601)' refs/remotes/$REMOTE | sed "s#refs/remotes/$REMOTE/##")

# If no old branches, exit
if [[ ${#OLD_BRANCHES[@]} -eq 0 ]]; then
    echo "No branches older than 3 months found."
    exit 0
fi

# Show branches to be deleted
echo "The following branches are older than 3 months and will be deleted:"
printf '%s\n' "${OLD_BRANCHES[@]}"

# Confirm deletion
read -p "Are you sure you want to delete these branches from Azure DevOps? (y/N): " CONFIRM
if [[ "$CONFIRM" != "y" ]]; then
    echo "Operation aborted."
    exit 0
fi

# Delete branches from Azure DevOps
for branch in "${OLD_BRANCHES[@]}"; do
    echo "Deleting $REMOTE/$branch from Azure DevOps..."
    git push $REMOTE --delete "$branch"
done

echo "Old branches successfully deleted from Azure DevOps."

Key Features

Automatically Detects Old Branches

The script checks when each branch was last modified.

Uses git for-each-ref to get the last commit timestamp.

Compares timestamps to filter branches older than 3 months.

Prevents Accidental Deletion

List branches before deleting them.

Ask for confirmation before proceeding.

Azure DevOps Compatible

Works with Azure Repos (Git) in Azure DevOps.

Uses git push origin --delete to remove branches remotely.

Customizable

Change the time threshold by modifying 3 months ago.

Change REMOTE=${1:-origin} to work with different Git remotes.

🛠 How to Use the Script

Save the Script

Create a new file called delete_old_devops_branches.sh and paste the script inside.

Make it Executable

Run the following command:
chmod +x delete_old_devops_branches.sh

Run the Script

Execute the script in your repository:
./delete_old_devops_branches.sh
Or specify a different remote (if not origin):
./delete_old_devops_branches.sh upstream

Enhancing the Script (Optional)

Want to add more features? Here are some ideas:

Exclude Protected Branches (Main, Develop, etc.)

Modify the script to skip the deletion of main, develop, or other critical branches:

EXCLUDED_BRANCHES=("main" "develop" "release")
if [[ " ${EXCLUDED_BRANCHES[@]} " =~ " $branch " ]]; then
    continue
fi

Run in Dry-Run Mode

Instead of deleting, list the branches:
git push --dry-run $REMOTE --delete "$branch"

Schedule Automatic Cleanup

Use cron jobs to run the script monthly:
crontab -e
Add this line:
0 2 1 * * /path/to/delete_old_devops_branches.sh
This will run the script on the 1st of every month at 2 AM.

Final Thoughts

Cleaning up remote branches in Azure DevOps is essential for maintaining a healthy Git repository. By automating this task with a simple Bash script, you save time, improve repository organization, and enforce best practices across your team.

This script is a starting point—you can extend it further with exclusions, dry-run mode, or automatic scheduling.

💡 Have any ideas to improve it? Share your thoughts in the comments!

Wrappers in Java and Spring Boot: What They Are, When to Use, and When to Create Custom Ones

Jefster Farlei Fernandes Caixeta Junior — Mon, 17 Feb 2025 21:15:15 +0000

Introduction

In Java development, especially in Spring Boot applications, wrappers play a crucial role in enhancing functionality, improving security, ensuring thread safety, and simplifying complex operations. While Java provides a robust collection framework and utility classes, there are cases where custom wrappers become essential.

This article explores what wrappers are, when to use them, and how to create custom ones tailored for real-world applications.

What Are Wrappers?

A wrapper is a design pattern that encapsulates an existing object or collection, adding additional functionality without modifying the original implementation. Wrappers are commonly used for:

Read-only access (e.g., Collections.unmodifiableList)
Thread safety (e.g., Collections.synchronizedList)
Logging and debugging
Caching and performance optimization
Event-driven behavior (e.g., observable collections)

When to Use Wrappers

Wrappers are beneficial when:
Enhancing an existing collection or object without modifying its source code.
Implementing additional behaviors like logging, validation, or event notifications.
Ensuring security by restricting modifications to sensitive data.
Improving thread safety in concurrent applications.
Providing default values or error handling mechanisms.

Common Use Cases in Spring Boot Applications

Spring Boot applications often require custom wrappers to handle specific concerns. Some common scenarios include:

1. Thread-Safe Wrappers

Spring Boot applications often work in multi-threaded environments. Wrapping collections with synchronization mechanisms ensures safe concurrent access.

Example: A thread-safe Map using ReadWriteLock:

import java.util.*;
import java.util.concurrent.locks.*;

public class SynchronizedReadWriteMap<K, V> {
    private final Map<K, V> map = new HashMap<>();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public void put(K key, V value) {
        lock.writeLock().lock();
        try {
            map.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public V get(K key) {
        lock.readLock().lock();
        try {
            return map.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }
}

2. Logging and Auditing Wrappers

Logging wrappers help track modifications to collections, useful for debugging or auditing.

Example: A logging wrapper for List:

import java.util.*;

public class LoggingList<T> extends ArrayList<T> {
    @Override
    public boolean add(T t) {
        System.out.println("Adding element: " + t);
        return super.add(t);
    }

    @Override
    public boolean remove(Object o) {
        System.out.println("Removing element: " + o);
        return super.remove(o);
    }
}

3. Read-Only Wrappers

To prevent modifications to a collection, an unmodifiable wrapper ensures data integrity.

Example:

import java.util.*;

public class UnmodifiableWrapper<T> extends ArrayList<T> {
    @Override
    public boolean add(T t) {
        throw new UnsupportedOperationException("Modification is not allowed");
    }
}

4. Observable Wrappers

Observable wrappers notify listeners when data changes, useful for reactive applications.

Example:

import java.util.*;

public class ObservableMap<K, V> extends HashMap<K, V> {
    private final List<Runnable> listeners = new ArrayList<>();

    public void addListener(Runnable listener) {
        listeners.add(listener);
    }

    private void notifyListeners() {
        for (Runnable listener : listeners) {
            listener.run();
        }
    }

    @Override
    public V put(K key, V value) {
        V result = super.put(key, value);
        notifyListeners();
        return result;
    }
}

5. Auto-Expiring Cache Wrappers

For caching, a wrapper can remove entries after a certain time.

Example:

import java.util.*;
import java.util.concurrent.*;

public class ExpiringCache<K, V> {
    private final Map<K, V> cache = new ConcurrentHashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    public void put(K key, V value, long expirationTime, TimeUnit unit) {
        cache.put(key, value);
        scheduler.schedule(() -> cache.remove(key), expirationTime, unit);
    }

    public V get(K key) {
        return cache.get(key);
    }
}

When to Create Custom Wrappers

While Java provides built-in wrappers likeCollections.synchronizedList and Collections.unmodifiableMap, creating custom wrappers is useful when:

You need business-specific behavior (e.g., access control on collections).

You require event-driven changes (e.g., auto-updating UI components in Spring Boot with WebSockets).

You must optimize performance (e.g., batching writes to a database).

You want to implement retry mechanisms (e.g., handling network failures in REST clients).

Conclusion

Wrappers are a powerful tool in Java and Spring Boot applications, enabling better modularity, security, and performance. Whether making collections thread-safe, adding observability, or implementing caching, custom wrappers can significantly improve your application's maintainability.

By understanding when and how to use them, you can enhance your software design and build more resilient applications. 🚀