Fixing Nginx "connect() failed (111: Unknown error)" on Ubuntu 22 using Odoo 16

Troubleshooting Connection Errors with Odoo and Nginx

Running into a connection error like "connect() failed (111: Unknown error)" can be frustrating, especially when it appears during an otherwise standard setup of Odoo 16 using Nginx as a reverse proxy on Ubuntu 22. This issue can be particularly puzzling when everything works smoothly on an Ubuntu 20 environment, but fails when deployed on a newer version.

Imagine you're simply trying to check the on-hand quantity of a product in Odoo, but the data request just seems to hang. 😖 You’ve checked the configurations, restarted the services, and reviewed logs, but the solution remains elusive. This error commonly appears when Nginx is unable to connect to the upstream service, which is crucial for Odoo’s API calls to function correctly.

This article explores the potential causes and effective troubleshooting steps to address this connectivity issue. We’ll dive into the Nginx configuration, examine Odoo's port settings, and look at any version incompatibilities that might be at play. Ultimately, we aim to bridge the gap between your server and Odoo so you can get back to business as usual.

Let’s walk through each aspect of this setup to identify the problem, from common Nginx configurations to adjustments specific to Odoo 16, ensuring a seamless resolution for your Ubuntu 22 server.

Detailed Explanation of Script Usage and Commands

These scripts aim to resolve the common issue of "connect() failed (111: Unknown error)" in Odoo 16 when using Nginx as a reverse proxy on Ubuntu 22. The Nginx configuration script, in particular, establishes a connection between the frontend server and the backend (Odoo) application by defining “upstream” blocks. This part of the script tells Nginx where to route the requests by defining paths like "/websocket" for WebSocket connections, which are essential for real-time features like Odoo’s dynamic product quantity views. The "proxy_pass" command within each location block specifies the exact upstream server location, allowing seamless backend communications and facilitating request handling for various API endpoints.

The proxy_connect_timeout and proxy_read_timeout commands are essential to the configuration. They define the time limits for establishing connections and for maintaining idle connections between the frontend (Nginx) and the backend (Odoo). When a user clicks to view a product quantity, this connection and response time are critical. If Nginx cannot establish or maintain this connection for the specified time, it triggers the connection failure error. The script extends these timeout limits to allow more flexibility in cases where the backend may respond more slowly or process complex requests. This configuration prevents unnecessary interruptions, especially for users interacting with Odoo’s data-heavy pages, such as product inventory.

The Python script serves as a diagnostic tool for validating the connection between the backend and frontend servers by sending HTTP requests directly to Odoo’s API. Using the requests.get method, this script attempts to access a specified endpoint and verifies whether the server responds correctly. For instance, it can be used to test if clicking on Odoo's quantity button correctly triggers data retrieval. If successful, it logs the connection as "successful," while a failure raises an error message. This simple yet effective approach ensures that Nginx can access Odoo’s API, making troubleshooting faster when similar connectivity issues arise.

To further enhance error handling, the Python script includes a unit test setup that mocks server responses using the @patch decorator. This feature allows developers to simulate various response scenarios, such as a failed connection or a successful one, without requiring the actual Odoo server. By defining these tests, developers can run them anytime a change in configuration occurs, confirming whether the adjustments fix the issue. This modular approach to testing not only saves time but also ensures that connectivity is maintained across different environments, providing a more reliable setup for Odoo 16 in production. 🛠️

# Nginx Config - Adjusting Upstream and Timeout Configurations
upstream my-upstream {
    server 127.0.0.1:40162;
}
upstream my-upstream-im {
    server 127.0.0.1:42162;
}
server {
    listen 80;
    listen [::]:80;
    server_name my-domain.com;
    location / {
        proxy_pass http://my-upstream;
        proxy_connect_timeout 10s;
        proxy_read_timeout 30s;
        proxy_send_timeout 30s;
    }
}
server {
    listen 443 ssl;
    ssl_certificate /etc/letsencrypt/live/my-domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/my-domain.com/privkey.pem;
    location /websocket {
        proxy_pass http://my-upstream-im;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "Upgrade";
        proxy_connect_timeout 60s;
        proxy_read_timeout 60s;
    }
}

import requests
import logging

# Configure logging for output clarity
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Define the URL and headers for Odoo API endpoint
url = "http://127.0.0.1:40162/call_button"
headers = {"Content-Type": "application/json"}

def check_connection():
    try:
        response = requests.get(url, headers=headers, timeout=5)
        response.raise_for_status()
        logger.info("Connection Successful!")
    except requests.exceptions.RequestException as e:
        logger.error(f"Connection failed: {e}")

if __name__ == "__main__":
    check_connection()

import unittest
from unittest.mock import patch
import requests

class TestConnection(unittest.TestCase):
    @patch("requests.get")
    def test_successful_connection(self, mock_get):
        mock_get.return_value.status_code = 200
        response = requests.get("http://127.0.0.1:40162/call_button")
        self.assertEqual(response.status_code, 200)

    @patch("requests.get")
    def test_failed_connection(self, mock_get):
        mock_get.side_effect = requests.exceptions.ConnectionError
        with self.assertRaises(requests.exceptions.ConnectionError):
            requests.get("http://127.0.0.1:40162/call_button")

if __name__ == "__main__":
    unittest.main()

Understanding Websocket and Long-polling Setup for Odoo and Nginx

In the setup of Odoo 16 with Nginx as a reverse proxy on Ubuntu 22, achieving a seamless connection is essential for operations that rely on real-time data, like inventory management or order processing. Odoo uses websockets to keep data updated without needing constant page refreshes, improving both efficiency and user experience. Nginx acts as a “traffic director” in this setup, forwarding websocket connections to Odoo using custom configurations. Setting the correct parameters for websockets in Nginx, such as proxy_set_header Upgrade and Connection "Upgrade", is crucial for maintaining these real-time links.

Another critical aspect is configuring timeout settings in both the Nginx and Odoo configurations. By default, timeout values can cause issues if Odoo processes run longer than expected, which is common when handling extensive inventory data. Increasing values like proxy_read_timeout and proxy_connect_timeout in Nginx helps prevent connection breaks. This ensures that Odoo can complete processing data-intensive tasks without triggering the "connect() failed" error. Setting the timeouts strategically based on the typical processing time within Odoo helps balance user experience and resource management.

Lastly, managing access and securing the connection are vital. Adding headers like Access-Control-Allow-Origin enables Nginx to handle cross-origin requests, which is important if users access Odoo from multiple subdomains. Likewise, defining proper SSL configurations ensures secure connections over HTTPS. This setup not only supports better performance but also enhances security, protecting user data while still supporting seamless interactions. 🛡️