Mood lighting for your Hue bulbs

 

This project will create a real time random dynamic mood lighting based
on the hue color bulbs.
A method named mood will be created that will run as a thread.
A single argument will be passed which is the name of the bulb.
1. If the bulb is currently off then turn it on.
2. Get the current color and brightness of the bulb.
3. Generate a random color and brightness.
4. Generate a random transition time between 0.5 and 5 seonds.
5. Calculate the number of 0.1 second steps to get to the new color.
6. Calculate the increment in brightness for each step.
7. Calculate the increment in color for each step.
8. Loop through the number of steps and set the new color and brightness.
9. Sleep for 0.1 seconds.
10. Repeat.

https://github.com/mainmeister/hume.git

Keeping your NextDNS IP Address up to date

 

Automating IP Updates for NextDNS: A Technical Deep Dive

In an increasingly dynamic digital landscape, maintaining consistent and reliable network configurations is paramount for professionals and enthusiasts alike. A common challenge for users of DNS services like NextDNS is ensuring that their registered IP address remains synchronized with their current public IP, particularly in environments with dynamic IP assignments. While some services offer paid solutions for this, a robust and cost-effective method can be implemented using standard Linux automation tools.

This guide outlines a method to automatically update your NextDNS account's associated IP address using a simple Python script and a cron job, circumventing the need for a third-party service. This process is particularly relevant for those managing home or small-office networks where the public IP address may change at the discretion of the Internet Service Provider (ISP).

Leveraging the NextDNS API

NextDNS provides a straightforward HTTPS GET endpoint designed specifically for updating linked IP addresses. This endpoint is accessible through the "Linked IP" section of the NextDNS setup page. The core of this automation lies in making a simple GET request to this endpoint with the appropriate configuration details.

The following Python script, setnextdns.py, demonstrates how to accomplish this using the requests library, a standard tool for making HTTP requests in Python.

Python

import requests
from typing import NoReturn


def update_nextdns_ip(nextdns_url: str) -> NoReturn:
    """
    Updates the IP address associated with the NextDNS account
    by making a GET request to the provided URL.

    Args:
        nextdns_url (str): The specific NextDNS update URL.
    """
    try:
        response = requests.get(nextdns_url, timeout=10)
        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
        print("IP address update successful.")
    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")


if __name__ == "__main__":
    # Replace with your specific NextDNS update URL from the setup page
    URL = "https://link-ip.nextdns.io/<your_unique_id>/<your_configuration_id>"
    update_nextdns_ip(nextdns_url=URL)

To use this script, you must first install the requests library if it's not already present in your environment:

Bash

pip install requests

After saving the script, make it executable by running the following command in your terminal:

Bash

chmod +x setnextdns.py

Automating with Cron

To ensure the script runs automatically, a cron job can be scheduled. Cron is a powerful time-based job scheduler available on Unix-like operating systems. By adding a single line to your crontab, you can instruct the system to execute the script at a regular interval.

For a daily update at midnight, the following entry can be added to your crontab. This is a conservative approach, as IP addresses typically do not change multiple times a day.

Bash

0 0 * * * /path/to/your/script/setnextdns.py >/dev/null 2>&1

To view or edit your crontab entries, use the following commands:

Bash

# To list current crontab entries
crontab -l

# To edit crontab entries
crontab -e

By implementing this simple yet effective solution, users can ensure their NextDNS configuration remains current and functional without relying on external services. This method highlights the power of combining readily available tools to solve common technical challenges.

---

Unit Test

Python

import unittest
import requests
from unittest.mock import patch, Mock
from setnextdns import update_nextdns_ip


class TestNextDNSUpdater(unittest.TestCase):
    """
    Unit tests for the NextDNS IP updater script.
    """

    @patch('requests.get')
    def test_update_nextdns_ip_success(self, mock_get: Mock) -> None:
        """
        Test case for a successful API call to update NextDNS IP.
        """
        mock_response = Mock()
        mock_response.raise_for_status.return_value = None
        mock_get.return_value = mock_response

        # Use a dummy URL for testing purposes
        url = "https://test.url.com"
        with patch('sys.stdout', new_callable=Mock) as mock_stdout:
            update_nextdns_ip(nextdns_url=url)
            self.assertIn("IP address update successful.", mock_stdout.getvalue())
        mock_get.assert_called_once_with(url, timeout=10)

    @patch('requests.get')
    def test_update_nextdns_ip_failure(self, mock_get: Mock) -> None:
        """
        Test case for a failed API call (e.g., connection error).
        """
        mock_get.side_effect = requests.exceptions.RequestException("Test Error")

        # Use a dummy URL for testing purposes
        url = "https://test.url.com"
        with patch('sys.stdout', new_callable=Mock) as mock_stdout:
            update_nextdns_ip(nextdns_url=url)
            self.assertIn("An error occurred: Test Error", mock_stdout.getvalue())
        mock_get.assert_called_once_with(url, timeout=10)


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