Solution: To increase the inotify watches limit, follow these steps:

1. Open a terminal and check the current value with:
   cat /proc/sys/fs/inotify/max_user_watches

2. Temporarily increase the value (e.g., to 524288) by running:
   sudo sysctl fs.inotify.max_user_watches=524288

3. To make the change permanent, edit the /etc/sysctl.conf file:
   sudo nano /etc/sysctl.conf

4. Add this line at the end of the file:
   fs.inotify.max_user_watches=524288

5. Save the file and apply the change with:
   sudo sysctl -p


After these steps, the system should allow more inotify watchers, and the error should no longer appear.

The post Error: Terminating since out of inotify watches. Consider increasing /proc/sys/fs/inotify/max_user_watches appeared first on CNERIS.

1. Locate the session_start() code
   Search your theme or active plugins for the session_start() function. It may be in the theme’s functions.php file or in a custom plugin.
2. Add session_write_close() after session_start()
   Ensure session_write_close() is called after each session_start() call, before making any HTTP requests. This will close the session and allow the REST API to work correctly. For example:
   session_start();
// Your code here
session_write_close();

3. Use the init hook in WordPress
   If session_start() needs to be in functions.php, make sure to wrap it in the init hook and use session_write_close() like this:
   add_action('init', function() {
if (!session_id()) {
session_start();
session_write_close();
}
});

The post A PHP session was created by a session_start() function call. This interferes with REST API and loopback requests. The session should be closed by session_write_close() before making any HTTP requests. appeared first on CNERIS.

Code to Assign Default Featured Image by Category

1. Open your theme’s functions.php file (preferably a child theme to avoid losing changes with updates).
2. Add the following code, replacing the URLs with your default images for each category:

function set_default_thumbnail($post_id) {
if (has_post_thumbnail($post_id)) {
return;
}

// Define default images for each category
$default_images = [
‘category-1’ => ‘https://your-site.com/wp-content/uploads/category-image1.jpg’,
‘category-2’ => ‘https://your-site.com/wp-content/uploads/category-image2.jpg’,
‘category-3’ => ‘https://your-site.com/wp-content/uploads/category-image3.jpg’,
];

// Get post categories
$categories = get_the_category($post_id);

// Check if categories are assigned and find a matching default image
foreach ($categories as $category) {
if (array_key_exists($category->slug, $default_images)) {
$image_url = $default_images[$category->slug];

// Download image and set as featured image
$image_id = attach_image_from_url($image_url, $post_id);
if ($image_id) {
set_post_thumbnail($post_id, $image_id);
}
break;
}
}
}
add_action(‘save_post’, ‘set_default_thumbnail’);

// Function to download and attach the image to the post
function attach_image_from_url($image_url, $post_id) {
$upload_dir = wp_upload_dir();
$image_data = file_get_contents($image_url);
$filename = basename($image_url);

if (wp_mkdir_p($upload_dir[‘path’])) {
$file = $upload_dir[‘path’] . ‘/’ . $filename;
} else {
$file = $upload_dir[‘basedir’] . ‘/’ . $filename;
}

file_put_contents($file, $image_data);

$wp_filetype = wp_check_filetype($filename, null);
$attachment = [
‘post_mime_type’ => $wp_filetype[‘type’],
‘post_title’ => sanitize_file_name($filename),
‘post_content’ => ”,
‘post_status’ => ‘inherit’
];

$attach_id = wp_insert_attachment($attachment, $file, $post_id);
require_once(ABSPATH . ‘wp-admin/includes/image.php’);
$attach_data = wp_generate_attachment_metadata($attach_id, $file);
wp_update_attachment_metadata($attach_id, $attach_data);

return $attach_id;
}

Code Explanation

• $default_images: Defines default images for each category using the category slug as the key and the image URL as the value.
• set_default_thumbnail: This function runs when a post is saved. If the post has no featured image, it finds the first category with a default image in $default_images and sets it as the featured image.
• attach_image_from_url: This function downloads the image from the URL and attaches it to the post as a media file, making it the featured image.

This code will automatically assign a default featured image for new or edited posts based on their category.

Note: Make sure to test this code in a development environment before implementing it on your live site, and replace the example URLs with your actual default image URLs.

The post How you can set a default featured image for each post category appeared first on CNERIS.

1. FIM (Framebuffer Image Viewer)

• FIM is a command-line image viewer that utilizes the framebuffer to display images directly in the terminal.
• Installation:
  sudo apt install fim

• Usage:
  fim image.jpg

• Example: Run fim /path/to/image.jpg to open an image in the terminal. FIM allows navigation through multiple images in a folder with arrow keys.

2. VIU

• Viu is another lightweight image viewer for the terminal, compatible with color images in most terminals.
• Installation (requires cargo from Rust):
  cargo install viu

• Usage:
  viu image.jpg

• Example: Run viu /path/to/image.jpg for a quick view. Viu is great for 24-bit color terminals.

3. Catimg

• Catimg converts images into ASCII format to display in the terminal.
• Installation:
  sudo apt install catimg

• Usage:
  catimg image.jpg

• Example: Run catimg /path/to/image.jpg to view an ASCII representation of the image.

The post JPG Image Viewers in Linux Terminal appeared first on CNERIS.

1. Edit the wp-config.php file:
   • Access the wp-config.php file in your WordPress installation.
   • Add the following line of code before the line that says “/* That’s all, stop editing! */”:
     define('WP_MEMORY_LIMIT', '256M');


   This sets the memory limit to 256 MB. You can adjust the value depending on your needs, such as 128M or 512M.

2. Edit php.ini (optional):
   • If you have access to the php.ini file on your server, find the line:
     memory_limit = 128M

   • Change the value to a higher one, like 256M or more, according to your requirements.
3. Restart the server:
   • After making the changes, if you modified the php.ini file, you need to restart the server for the changes to take effect.

The post How to increase the memory limit in WordPress (wp_max_memory_limit)? appeared first on CNERIS.

1. Database issues: If your server relies on a database (like MySQL or MariaDB), slow or unoptimized queries can delay response generation. Ensure that tables are properly indexed and that there are no queries taking too long to execute.
2. Server performance: If your server is underperforming (CPU overload, low RAM, or high disk usage), request processing will be slower. Check resource usage using tools like top or htop to identify bottlenecks.
3. Web server configuration: If your web server (such as Apache or Nginx) is not optimized, it could cause delays. Reviewing configurations like output compression (Gzip), caching usage, and concurrent connection parameters can help improve TTFB.
4. Slow connection to external networks: If your server relies on external services (APIs, data sources) or is located in a data center far from your users, network latency can increase the TTFB.
5. Caching: If caching is not properly used, every request needs to be processed from scratch. Setting up appropriate caching on the server can significantly reduce TTFB.

The post why does my server have a high ttfb? appeared first on CNERIS.

1. SSL Labs:
   • Use the free service from SSL Labs to perform a comprehensive analysis of your SSL certificate, including the SSL/TLS negotiation.
   • Simply enter your website URL, and it will generate a detailed report about supported SSL/TLS versions, cipher configurations, and more.
2. OpenSSL:
   • From the command line, you can use openssl to test SSL/TLS negotiations.
   • Example:
     openssl s_client -connect yourwebsite.com:443


     This will give you details about the SSL handshake process, including TLS version and certificates.

3. Nmap:
   • Nmap, with the ssl-enum-ciphers script, can help you verify SSL negotiations.
   • Example:
     nmap --script ssl-enum-ciphers -p 443 yourwebsite.com

The post How can I test the SSL negotiation of my website appeared first on CNERIS.

1. Load testing: Use tools like Apache JMeter, Loader.io, or k6 to simulate multiple users making requests to your website simultaneously. This will help you determine how many requests your website can handle before performance starts to degrade.
2. Server resource monitoring: During load testing, monitor the server’s CPU, memory, and bandwidth usage to identify bottlenecks.
3. Web server tuning: Adjust the web server configuration to optimize the handling of concurrent connections, such as setting the maximum number of simultaneous connections (e.g., in Apache or Nginx).
4. Test results: Load testing tools will provide a detailed report that shows the maximum number of requests your server can efficiently handle.

The post How can I measure the number of requests a website can handle? appeared first on CNERIS.

1. Apache

Apache allows configuring the number of concurrent connections through its modules and directives in the main configuration file, usually located at /etc/apache2/apache2.conf or /etc/httpd/httpd.conf, depending on the operating system.

Key parameters:

• MaxRequestWorkers: Defines the maximum number of simultaneous requests that Apache can handle.
  <IfModule mpm_prefork_module>
MaxRequestWorkers 150
</IfModule>

• ServerLimit: Defines the maximum number of processes Apache can spawn.
  <IfModule mpm_worker_module>
ServerLimit 256
</IfModule>

• MaxConnectionsPerChild: Defines the maximum number of connections each child process handles before being recycled.
  MaxConnectionsPerChild 1000


After making these changes, restart Apache with:

2. Nginx

In Nginx, the configuration of simultaneous connections is mainly controlled through the following parameters in the configuration file located at /etc/nginx/nginx.conf:

Key parameters:

• worker_processes: Defines the number of worker processes Nginx will run. This should align with the number of CPU cores on the server.
  worker_processes auto;

• worker_connections: Defines the maximum number of simultaneous connections that a single worker process can handle.
  worker_connections 1024;

• events: This section allows configuring event handling parameters, such as the I/O method used.
  events {
worker_connections 1024;
}


The total number of simultaneous connections Nginx can handle is the product of worker_processes and worker_connections.

Once the changes are made, restart Nginx with:

3. PHP-FPM

If your web application uses PHP-FPM to handle PHP requests, you should configure the number of concurrent connections in the php-fpm.conf file or in the pool files, located in /etc/php/7.4/fpm/pool.d/www.conf (the path may vary depending on the PHP version).

Key parameters:

• pm.max_children: Sets the maximum number of PHP-FPM processes that can run simultaneously.
  pm.max_children = 50

• pm.start_servers: The number of processes that start when the service begins.
  pm.start_servers = 5

• pm.max_spare_servers: The maximum number of spare (idle) processes.
  pm.max_spare_servers = 10


After making changes, restart PHP-FPM:

The post Where can I configure the number of connections on the hosting? appeared first on CNERIS.

1. Open the MySQL command line:
   mysql -u root -p

2. Once inside MySQL, run the following command to see the maximum allowed connections:
   SHOW VARIABLES LIKE 'max_connections';


   This will display the current value of max_connections, which is the maximum number of simultaneous connections MySQL can handle.

The post how many maximum connections your MySQL server allows appeared first on CNERIS.