Backing up data is a critical task in server management, and cPanel provides robust backup solutions. However, sometimes you might encounter an issue where cPanel fails to prune older backups, leading to excessive disk usage and potential server problems. This blog post will guide you through identifying and fixing this issue using a custom bash script.

The Issue: Backup Pruning Failure

When cPanel backups are configured, it is expected that older backups are automatically deleted (pruned) to free up space. However, due to various errors during the backup process, this pruning may fail, leaving you with accumulating backups and shrinking disk space.

Common errors causing this failure include:

• Unable to get user id
• Unable to load cPanel user data
• pkgacct failed to copy daily backup
• Could not use daily backup
• Backup::PartialFailure
• The REMOTE_PASSWORD variable is missing

These errors can prevent cPanel from completing the backup process properly, resulting in older backups not being pruned.

Solution: Using a Bash Script to Identify the Problem

To resolve this issue, you first need to identify the root cause of the backup failure. The following bash script will help you scan through your cPanel backup logs to pinpoint the exact error that caused the backup to fail and, consequently, the pruning issue.

#!/bin/bash

# Directory containing the log files
LOG_DIR="/usr/local/cpanel/logs/cpbackup/"

# Error patterns to search for
ERROR_PATTERNS=(
    "Unable to get user id"
    "Unable to load cPanel user data"
    "You cannot copy the root user"
    "pkgacct failed to copy daily backup"
    "Could not use daily backup"
    "Bailing out"
    "The REMOTE_PASSWORD variable is missing"
    "Unable to find domain name"
    "Exiting with error code"
    "Could not remove directory"
    "Hook denied execution of pkgacct"
    "Could not open"
    "Could not chmod"
    "Could not rename"
    "failed to create the working dir"
    "Unable to fork"
    "Unable to waitpid"
    "Unable to open"
    "Failure dumping"
    "Unable to read"
    "does not appear to be valid XML"
    "Could not create directory"
    "mysqldump: Got error"
    "mysqldump: Error"
    "mysqldump: Couldn't"
    "mysqldump failed"
    "“Mysql” failed with an error"
    "Failed to generate backup metadata"
    "rsync: connection unexpectedly closed"
    "rsync:.*write error: Broken pipe"
    "received the KILL (9) signal"
    "backup_incomplete"
    "Backup::PartialFailure"
)

# Function to search for errors in a specific log file
find_errors_in_file() {
    local log_file="$1"
    local errors_found=false

    for pattern in "${ERROR_PATTERNS[@]}"; do
        local errors=$(grep -i -E "$pattern" "$log_file")
        if [ -n "$errors" ]; then
            if [ "$errors_found" = false ]; then
                echo "Errors found in $log_file:"
                errors_found=true
            fi
            echo "$errors"
        fi
    done

    if [ "$errors_found" = false ]; then
        echo "No known errors found in $log_file."
    fi
}

# Loop through each log file in the directory and check for errors
for log_file in "$LOG_DIR"*.log; do
    if [ -f "$log_file" ]; then
        find_errors_in_file "$log_file"
        echo ""
    else
        echo "No log files found in $LOG_DIR."
    fi
done

How the Script Works

This script is designed to scan all the log files in the /usr/local/cpanel/logs/cpbackup/ directory. It searches for a predefined set of error patterns that are commonly associated with backup failures. When any of these errors are found, the script will print them along with the log file where the error occurred.

Troubleshooting and Fixing the Issue

Once you run the script, it will output any errors found in your backup logs. Identifying the exact error can help you troubleshoot the underlying cause. Here are a few steps you can take to resolve common issues:

1. Permission Issues: Check if the backup process has the necessary permissions to access the required files and directories.
2. Database Errors: If you encounter errors related to mysqldump or other database operations, ensure that your databases are properly configured and accessible.
3. cPanel Configuration: Verify your cPanel backup configuration to ensure that all settings are correct and that no crucial variables (like REMOTE_PASSWORD) are missing.
4. Server Resources: Ensure that your server has adequate resources (CPU, RAM, Disk Space) to perform the backup operations without interruptions.

Conclusion

By using this script, you can quickly identify the root cause of backup pruning failures in cPanel. Regular monitoring and prompt troubleshooting of these issues can prevent potential server problems caused by excessive disk usage. Make sure to address the errors identified by the script to ensure that your backups complete successfully, allowing cPanel to prune older backups as intended.

The post cPanel Backup Not Pruning Older Backups: Troubleshooting and Fix appeared first on https://inertz.org.

The Issue
The root cause of this problem is an upstream bug, as documented in cPanel support articles. The issue still hot in the Cpanel database forum. Here’s how to address and fix this issue:

Step-by-Step Fix

1. Downgrade MySQL
First, you need to downgrade MySQL to a version before the issue occurred. Use the following command:

yum downgrade mysql-community-*

2. Version Lock MySQL
To prevent the update from reoccurring, you should lock the MySQL version:

dnf install python3-dnf-plugin-versionlock
yum versionlock mysql-community-*

Unfortunately, these steps alone might not fully resolve the issue, as was the case with our server. Despite downgrading MySQL, our server did not recover, necessitating further support from cPanel, CloudLinux, and third-party experts.

Recovery Process

It took nearly a full day to fix the issue. Previously, I’ve encountered similar issues with InnoDB and resolved them by switching the database engine to MyISAM. However, this situation was different.

Fortunately, our server was prepared with daily MySQL backups. The main challenge was that MySQL was down, so we couldn’t restore the database immediately. Here’s the detailed recovery process:

1. Rename the MySQL Directory
Since /var/lib/mysql was unusable, I renamed it to avoid conflicts:

mv /var/lib/mysql /var/lib/mysql-old

Then creating new mysql folder inside /var/lib and give proper permission.

2. Restart MySQL
After renaming the directory, restarting MySQL brought the database back online:

systemctl restart mysqld

3. Restore the MySQL Database
With MySQL running again, I restored the mysql.sql database:

mysql mysql < /path/to/backup/mysql.sql

4. Monitoring and Final Restoration
After monitoring for stability, I confidently restored the remaining databases using script to restore. This script facilitated the complete recovery of all databases.

5. Fixing CloudLinux Integration
Using CloudLinux, it was crucial to run the following command to prevent the “error establishing database connection” message:

cagefs -r

Running this command resolved the issue, ensuring the databases were accessible and the server was fully operational.

Conclusion
Handling MySQL issues after cPanel updates can be challenging, especially with InnoDB corruption. By following the outlined steps and ensuring regular backups, you can minimize downtime and restore services effectively. Always keep your system updated with the latest support insights and solutions to maintain optimal server performance.

The post Resolving MySQL Issues After Daily cPanel Updates appeared first on https://inertz.org.

The Core Objective

Our primary goal is to develop a Perl script capable of:

1. Identifying and moving the most recent weekly or monthly backups to a specific directory, /backup/backup-delete, for further actions, such as deletion or archiving.
2. Generating a new backup using the /scripts/pkgacct command if no recent backups are available, ensuring data safety even in the absence of scheduled backups.

Step-by-Step Guide to the Improved Perl Backup Script

Preparing Your Environment

Ensure your Perl environment is correctly set up with strict error reporting and warnings enabled. This practice helps in catching potential issues early in the script execution process.

Script Breakdown

1. Parameter Handling: The script starts by accepting a username as an input parameter. This is crucial for specifying which user account to backup.
2. Backup Search: It then searches for the most recent weekly and monthly backups. This step involves checking the /backup/weekly/ and /backup/monthly/ directories for the latest user.tar.gz file.
3. Error Handling Improvements: By incorporating error handling mechanisms, the script robustly manages situations where backup moving commands might fail, ensuring the administrator is alerted to any issues during the process.
4. Direct Backup Creation: If no existing backups are found, the script directly invokes the /scripts/pkgacct command to generate a new backup, specifying the output directory to avoid unnecessary file movements.
5. Clean and Informative Output: Throughout the process, the script provides clear feedback on its actions, whether it’s moving an existing backup or creating a new one, enhancing transparency for system administrators.

Why This Script Stands Out

• Efficiency: By directly checking and handling the most recent backups, the script saves time and reduces the likelihood of manual errors.
• Reliability: With improved error handling, the script ensures that administrators are aware of any issues immediately, allowing for quick intervention.
• Automation Ready: This script can be easily integrated into broader system administration workflows, facilitating automated backup checks and creation with minimal human intervention.

First you must edit ‘/usr/local/cpanel/scripts/prekillacct’ using nano or vi and copy below;

#!/bin/bash
/scripts/prekillacct.l.v.e-manager.bak "$@"

Then edit the file ‘/scripts/prekillacct.l.v.e-manager.bak’ and copy the script below;

#!/usr/bin/perl
use strict;
use warnings;

# Assuming the script is called with something like: script.pl user=username
my %OPTS = @ARGV;
my $user = $OPTS{'user'}; # This might need adjustment depending on how you're planning to pass the username.

# Paths for weekly and monthly backups
my $backupw = `ls -td /backup/weekly/*/accounts/$user.tar.gz 2>/dev/null | head -1`;
chomp $backupw;
my $backupm = `ls -td /backup/monthly/*/accounts/$user.tar.gz 2>/dev/null | head -1`;
chomp $backupm;

my $backup_found = 0;

# Commands to move backups
if (-f $backupw) {
    my $cmdw = "mv $backupw /backup/backup-delete/$user-weekly.tar.gz";
    system($cmdw) == 0 or warn "Failed to move weekly backup: $!";
    $backup_found = 1;
}

if (-f $backupm) {
    my $cmdm = "mv $backupm /backup/backup-delete/$user-monthly.tar.gz";
    system($cmdm) == 0 or warn "Failed to move monthly backup: $!";
    $backup_found = 1;
}

if (!$backup_found) {
    print "No existing backup found for $user. Creating a new backup...\n";
    system("/scripts/pkgacct $user /backup/backup-delete") == 0 or die "Failed to create backup: $!";
    # No need to move the backup file as we're specifying the output directory in the command.
}

print "Backup process completed.\n";

Final Thoughts

This enhanced Perl script for managing backups is a testament to the flexibility and power of Perl in system administration tasks. Whether you’re looking to refine your existing backup processes or implement a new system, this script offers a robust foundation for managing your data backup needs efficiently and reliably.

Remember, while this script is tailored for a specific use case, the principles and techniques applied here—such as error handling, direct command execution, and process feedback—are universally applicable across a wide range of system administration tasks.

Happy scripting, and may your data always be safe and sound!

The post How to Manage Backups in Perl: A Guide for Cpanel Sysadmins appeared first on https://inertz.org.

Apple recently launched the iPhone 15 Pro and iPhone 15 Pro Max, featuring a design that combines strong yet lightweight titanium and customizable Action buttons. The standout camera features include a 48MP Main camera and an exclusive 5x Telephoto camera. A17 Pro ensures pro-level performance with significant improvements in GPU, CPU, and Neural Engine. Photo enhancements include better Night mode and Smart HDR available for third-party apps. iPhone 15 Pro offers high-speed data transfer via USB 3 and supports Roadside Assistance via satellite for off-grid safety.

The design highlights include titanium, a new brushed texture, and contoured edges. The Super Retina XDR display with Always-On and ProMotion technologies offers an exceptional visual experience. The new Action button replaces the traditional switch, providing users with more options to access the camera, flashlight, Voice Memos, Focus modes, Translate, and accessibility features.

A17 Pro delivers impressive capabilities with a faster CPU, advanced GPU, and accelerated Neural Engine. iPhone 15 Pro also offers high-speed data transfer via USB 3 and supports Roadside Assistance via satellite for off-grid safety.

In terms of security and wireless connectivity, iPhone 15 Pro offers MagSafe and Qi2 wireless charging support. Improved audio quality for phone calls, including FaceTime, is another great feature. Users can use eSIM when traveling for convenient international roaming. Furthermore, iPhone 15 Pro comes with the second-generation Ultra Wideband chip, enabling longer-range Precision Finding for Find My friends and supports Wi-Fi 6E for better wireless performance.

Additional features include support for Thread, the introduction of profiles in Safari, and more in iOS 17. The devices are designed with sustainability in mind, with recycled materials used in their construction.

The starting price for iPhone 15 Pro is RM5,499, with various storage capacity options. Pre-orders start on September 15, and the iPhone will be available on September 22.

The post iPhone 15 Pro and iPhone 15 Pro Max: Lightweight Titanium Design, Advanced Cameras, and Pro Performance appeared first on https://inertz.org.

Keep it Simple and Memorable
Simplicity and memorability are vital for both users and search engines. Opt for a domain name that is easy to remember and type. Avoid complex spellings, numbers, or hyphens that may confuse users and hinder your SEO efforts.

Reflect Your Brand Identity
Your domain name should reflect your brand and the nature of your business. Consistency between your brand and domain name helps build trust and recognition among your audience and search engines.

Prioritize Short and Concise Names
Short domain names are more user-friendly and have a higher chance of being remembered. Additionally, search engines prefer concise domain names that clearly represent your brand.

Choose the Right Domain Extension
While “.com” is the most popular and preferred extension, other relevant extensions like “.net” or “.co” can also be SEO-friendly. Consider your target audience and the nature of your business when choosing the right extension.

Avoid Copyright and Trademark Issues
Perform thorough research to ensure your desired domain name is not already trademarked or copyrighted by another entity. Avoiding legal issues will protect your brand’s reputation and SEO efforts.

Incorporate Relevant Keywords
Strategically include relevant keywords in your domain name to improve your chances of ranking higher in search engine results. However, don’t overstuff keywords as it may have a negative impact on SEO.

Eliminate Numbers and Hyphens
Numbers and hyphens can be confusing and hard to remember. A hyphenated domain name may also be associated with spammy websites. Stick to a simple name without these elements for better SEO.

Check Social Media Availability
Consistency across your domain name and social media handles is essential for branding and SEO. Ensure that your chosen domain name is available as a username on major social media platforms.

Think Long-Term
Choosing a domain name is a long-term commitment. Changing domain names later can hurt your SEO and confuse your audience. Select a name that will stand the test of time.

Avoid Slang and Unusual Spellings
Unique spellings and slang may seem creative, but they can hinder your SEO efforts. A clear and straightforward domain name is more likely to rank higher and resonate with users.

Test Pronunciation
Share potential domain names with others and ask for feedback on pronunciation. A domain name that is easily pronounceable can lead to more word-of-mouth referrals and improved SEO.

Think Global
If your brand caters to an international audience or has global aspirations, avoid region-specific domain names. A globally friendly domain name is more inclusive and easier to remember.

Conclusion

Choosing an SEO-friendly domain name is a fundamental aspect of building a successful online brand. By following these 12 tips, you can select a domain name that is not only brand-aligned and memorable but also optimized for better search engine rankings. Invest time and effort in this process to set the stage for a strong online presence and greater visibility for your brand.

The post How to Choose the Perfect Domain Name for Your Brand appeared first on https://inertz.org.

For each user, it checks if a backup file exists for the user by running the ls command on the backup path and grepping for the user’s filename with the .tar.gz extension. If the backup file exists, the script prints “Backup available for [user]”. If the backup file does not exist, the script prints “Backup not available for [user]”. The script is very easy to understand.

Note: This script assumes that the user’s backup file is named [username].tar.gz and is located in a directory structure that matches the backup path specified. If the backup file names or directory structure are different, the script will need to be modified accordingly.

#!/bin/bash
# Path to check for backups
backup_path="/backup/*/*/accounts/*.tar.gz"

for user in `ls -A /var/cpanel/users` ;
do
# Check if backup file exists for user
if ls $backup_path 2>/dev/null | grep -q "/$user.tar.gz$"; then
     echo "Backup available for $user"
  else
     echo "Backup not available for $user"
  fi

done

The post Bash script to check the availability of backup for cpanel account appeared first on https://inertz.org.

Heartbeat works by regularly checking the status of each server in the network, using a variety of techniques such as sending ping requests or checking for specific services to be running. If a server is found to be unhealthy, heartbeat will automatically redirect incoming traffic to other healthy servers in the network.

To achieve high availability with heartbeat, it is important to have multiple servers in the network, as this allows for redundancy and failover capabilities. These servers should be configured to run heartbeat, and should be monitored and managed carefully to ensure that they are always operating at their best.

In addition to providing high availability, heartbeat also offers other benefits, such as allowing for automatic scaling of the network to meet changing traffic needs, and providing detailed monitoring and reporting capabilities to help identify and troubleshoot potential issues.

How to achieve high availability with 100% uptime? We all know it is possible to have high availability website but the configuration might be too technical for some person. I have successfully simulated and achieve high availability web server using heartbeat software. Since we are using Centos 7, there are no binary heartbeat software for Centos 7, and we need to compile the software from a source code.

I simulate Heartbeat using only 4 servers. 2 servers for haproxy load balance share with heartbeat while 2 servers for web server. You can find the manual to install the haproxy here. Technically the simple diagram same as below;

To compile the software from source code, we need to install some software and library. Below software are required;

yum install -y gcc gcc-c++ autoconf automake libtool glib2-devel libxml2 libxml2-devel bzip2 bzip2-devel e2fsprogs-devel libxslt-devel libtool-ltdl-devel asciidoc

*Below package maybe required if you install minimal Centos

yum install -y psmisc cifs-utils nfs-utils OpenIPMI-libs openhpi perl-TimeDate sbd bc libuuid-devel

Next step is to download the source code;

wget -c http://hg.linux-ha.org/glue/archive/0a7add1d9996.tar.bz2
wget -c https://github.com/ClusterLabs/resource-agents/archive/v3.9.6.tar.gz
wget -c http://hg.linux-ha.org/heartbeat-STABLE_3_0/archive/958e11be8686.tar.bz2

Compile the Cluster-glue first. (you must extract 0a7add1d9996.tar.bz2)

./autogen.sh
./configure --prefix=/usr/local/heartbeat --with-daemon-user=hacluster --with-daemon-group=haclient --enable-fatal-warnings=no
make
make install

Compile Resource-agents next.

tar -zxvf resource-agents-3.9.6.tar.gz
cd resource-agents-3.9.6
./autogen.sh
./configure --prefix=/usr/local/heartbeat --with-daemon-user=hacluster --with-daemon-group=haclient --enable-fatal-warnings=no
make
make install

Compile the Heartbeat.

./bootstrap
export CFLAGS="$CFLAGS -I/usr/local/heartbeat/include -L/usr/local/heartbeat/lib"
./configure --prefix=/usr/local/heartbeat --with-daemon-user=hacluster --with-daemon-group=haclient --enable-fatal-warnings=no
make
make install

The post Achieving high availability with heartbeat appeared first on https://inertz.org.

Load balancing can be achieved through various methods, including hardware-based load balancers, software-based load balancers, and cloud-based load balancing services.

Hardware-based load balancers are dedicated devices that are installed in the network and perform load balancing functions by routing incoming traffic to the appropriate server. These devices are typically expensive and require skilled personnel to manage and maintain them.

Software-based load balancers are programs that are installed on the web servers themselves and perform load balancing functions by distributing incoming traffic among the servers in the network. These programs are typically less expensive than hardware-based load balancers and require less technical expertise to manage and maintain.

Cloud-based load balancing services are provided by cloud hosting providers and offer load balancing as part of their services. These services are typically easy to set up and manage, and can scale up or down depending on the traffic needs of the website.

Load balancing is important for several reasons. First, it ensures that incoming traffic is distributed evenly among the servers in the network, which helps to prevent any one server from becoming overloaded and slowing down the website. Second, it provides redundancy and failover capabilities, so that if one server goes down, incoming traffic can be routed to other servers in the network. Third, it allows for scalability and flexibility, as the number of servers in the network can be easily increased or decreased to meet changing traffic needs.

In conclusion, web server load balancing is a critical component of any website, as it helps to ensure smooth performance, provides redundancy and failover capabilities, and allows for scalability and flexibility. Whether using hardware-based, software-based, or cloud-based load balancing solutions, it is important to carefully evaluate the needs of the website and choose the appropriate solution to ensure optimal performance and reliability.

The post What is load balancing for web server appeared first on https://inertz.org.

I have write a simple shell script to show how many backup have been created for the account and listing the backup. The script is for my own use and my own note. I is very usefull if you have many backup and want simpler way to check the backup availability instead using WHM.

#!/bin/bash
# Shell script to check backup availability

echo ""
echo Shell script to check backup availability
read -p 'Username: ' username
echo There are
find /backup/*/*/accounts/ -maxdepth 1 -name $username* | wc -l
echo Backup available for $username
echo ""
echo Backup available for $username as below :
echo "Weekly"
ls -lath /backup/weekly/*/accounts/$username*
echo "Monthly"
ls -lath /backup/monthly/*/accounts/$username*

Output :

[root@wp4 backup]# ./backup-available.sh

Shell script to check backup availability
Username: inertz
There are
2
Backup available for inertz

Backup available for inertz as below :
Weekly
-rw------- 1 root root 3.6G Nov  5 10:47 /backup/weekly/2022-11-05/accounts/inertz.tar.gz
Monthly
-rw------- 1 root root 3.6G Oct 15 10:57 /backup/monthly/2022-10-15/accounts/inertz.tar.gz

The post Simple shell script to check backup availability for Cpanel account appeared first on https://inertz.org.

Below is the batch script.

@echo off
set basedir=D:
set workdir=D:\Backup\Mysql

set mysql="C:\Program Files\MySQL\MySQL Server 5.7\bin\mysql.exe"
set mysqldump="C:\Program Files\MySQL\MySQL Server 5.7\bin\mysqldump.exe"
set mysqluser=dbuser
set mysqlpassword=dbpassword

%mysql% -u%mysqluser% -p%mysqlpassword% -s -N -e "SHOW DATABASES" | for /F "usebackq" %%D in (`findstr /V "information_schema performance_schema"`) do %mysqldump% %%D --single-transaction -u%mysqluser% -p%mysqlpassword% > %workdir%\%%D.sql

Just save the file as mysqlbackup.bat and put in D drive.

The post MySQL backup using batch file Windows appeared first on https://inertz.org.