Running Nextcloud on TrueNAS behind Nginx Reverse Proxy

Brandon Fong — Sat, 14 Dec 2024 18:29:27 +0000

How I got mine to work with Nextcloud running on TrueNAS using a Rpi 3 my DNS provider & Nginx Proxy.

Cloudflare

Create an A record pointing domain to private address of your Nginx Proxy Manager: npm.example.com
Create a CNAME record for all subdomains: *.example.com

Pi-hole (Docker Tag 2024.07.0 Pi-hole v5.18.3 FTL v5.25.2 Web Interface v5.21) configuration

Add DNS record pointing to the Nginx Proxy Manager host: npm.example.com -> 192.168.x.x
Add a CNAME record: nc.example.com -> npm.example.com

TrueNAS (ElectricEel-24.10.0.2) Config

clear the Host name field
Use the truenas_default certificate
No additional environment variables
Uncheck Use different port for URL rewrites
Port 9001

Nginx Proxy Manager (v2.12.1)

Proxy Host entry:
- Domain Names: nc.example.com
- Scheme: https
- Forward Hostname / IP: Truenas' private ip on my network
- Port: 9001
- Custom Nginx Config:
```
  client_body_buffer_size 512k;
  proxy_read_timeout 86400s;
  client_max_body_size 0;
```
SSL Certificate creation:
- Follow Step 2 from this tutorial

Nextcloud `config.php` modifications

'overwrite.cli.url' => 'https://nc.example.com'
'overwritehost' => 'nc.example.com'
'overwriteprotocol' => 'https'
Add nc.example.com to trusted_domains
Add Pihole's ip address to trusted_proxies
I'd also back this file up as I don't know what will happen to it during an update through TrueNAS

Range-Based For Loop Implementation

Brandon Fong — Tue, 10 Dec 2024 17:47:21 +0000

I was interested in learning how to make my Linked List class adhere to a range-based for loop. I eventually saw a really good stackoverflow response that helped me figure out how to do it. This is my attempt at showing you how I implemented this feature with minimal lines of code. I will be speaking in context of a Linked List class.

Recall this is what the CPP documentation says about the Range-Based For Loop:


for ( range-declaration : range-expression )

loop-statement

range-declaration = the variable you are going to use to hold onto the node object
range-expression = the Linked List class

What you need for your Linked List class are two things:

Two methods:

Iterator begin() { return this->first(); }
Iterator end() { return NULL; }

begin() returns the first node of your Linked List (note first() returns a class Node) and end() will return NULL to identify the end of the list.

An Iterator class

Notice both methods return Iterator. This is a nested class inside the Linked List:

class Iterator {
private:
    Node * _curr;
public:
    Iterator(Node * n) : _curr(n) {}
    L operator*() const { 
        return this->_curr->object();
    }
    Iterator & operator++() { // pre-inc
        this->_curr = this->_curr->next();
        return *this;
    }
    Iterator operator++(int) { // post-inc
        Iterator old = *this;
        this->operator++();
        return old;
    }
    bool operator!=(const Iterator& i) {
        return !(*this == i);
    }
    bool operator==(const Iterator& i) {
        return this->_curr == i._curr;
    }
};

What I needed in this class, respectfully, was: a constructor that allows me return a Node coming from my Linked Lists’s begin(); then overloaders for the iteration, comparisons, and casting. Nest this class inside of the LinkedList class.

Simple and it did the job. What I needed was an iterator class that handles the iterative requirements for the range-based for loop. I also need to provide two accessor methods in my LinkedList class so the for loop can use it. You can see a demonstration of using my LinkedList class here.

Forem: Brandon Fong