cperrin.xyz

What can we do about the vibe committer

2026-06-19T00:00:00+00:00

I recently had a discussion on Mastodon that was sparked by a post of the Software Freedom Conservancy about the handling of LLM-gen-AI submissions. There are many people who are very opposed to letting LLM-generated code into their projects. This is an understandable standpoint given concerns like legality, unethical sourcing, resource usage, and concentration of power.

Apart from that, it is completely reasonable for a maintainer to set rules for submissions. A FOSS license doesn’t mean that a maintainer even has to interact with anyone. It just provides the source.

Still, it made me think about the impact these rules might have and in which cases they might turn into a net negative.

Maintainers make the rules. They are entrusted with maintaining a version of the code that others might want to contribute to. Often that is a single person who not only made something they wanted to share, but also took it upon themselves to help others improve it. For this we should be grateful for their work and respect their wishes.

But that is not how the world works. Through ignorance, entitlement, or malice, maintainers are often confronted with demands or hostility. Their boundaries get ignored, and frustrations rise. LLM-generated code is fertile ground for this. While some see it as the holy grail, others see it as the devil. This strong polarizing effect, combined with ignored boundaries, can easily lead to clashes.

Solid Snake and Benny Hill

Every clash can be very stressful for all sides. This is especially true if innocent people get caught in the crossfire. In my years as a software developer I have seen a lot of bad code. More recently, some code has triggered my vibe code sensor, but it was written by a human.

On the other hand, I believe I could probably hide the origin of a code submission. I would never do that, especially not to deceive. This makes me think that many people out there have the same knowledge and no problem with deception.

This could lead to some people sneaking their LLM code in like Solid Snake into a secret base, and others being chased away by an angry maintainer like in a Benny Hill sketch.

Distrust leads to anger, anger leads to a bad time for everyone

I am, of course, not the first person to think about nefarious actors trying to sneak past defenses. I am sure the most passionate maintainers are constantly aware of this, constantly on the lookout for the slightest hint of LLM involvement, always vigilant.

Or constantly concerned with the source of a submission in addition to the quality, always suspicious. From my observations, this can be coupled with anger - maybe anger about LLMs, about disregard of boundaries, or about the extra work they have to put in.

At this point, it begs the question of who is winning anything here. Even more, some people are definitely losing. The maintainers, new programmers, and the FOSS community as a whole are negatively affected, while vibe coders and LLM companies still get what they want a lot of the time.

Pragmatic principles

This all sounds very bad for people who have principles. Standing by principles might hurt someone innocent and even the maintainer, but abandoning principles might hurt just as much. My personal way out: pragmatic principles.

What I mean by that is searching specifically for the fights I can win and that are a net positive. Some of my guiding principles are:

Don’t search for signs of LLM-generated code in a submission, but don’t ignore them
If in doubt, either assume it’s human or communicate doubts
Evaluate submissions primarily on code quality
Assume people want to help
Remember that we all make mistakes
Concentrate on the positives

Afterword

I want to make it clear that I want everyone to set boundaries as they think right, and that everyone should respect those boundaries. I wish for a world where it is a given that the principles of others are respected.

The pragmatic approach is only my way to cope when I can’t protect my principles in a way that is healthy or even successful. I am aware that this is not easy if a project is run over by slop. It’s not a complete solution and not for everyone.

Triggering Veeam Backups on Linux with SystemD

2026-01-28T00:00:00+00:00

Veeam Backup is, in my opinion, one of the best free backup solutions available. The Linux version particularly shines with its ability to create snapshot backups of Ext4 partitions.

Unfortunately, the Linux version has a major drawback compared to its Windows counterpart: backup scheduling is extremely limited. You can only specify the day and hour for when backups should run. If the computer is asleep or powered off at that time, the backup won’t execute and, more importantly, won’t be rescheduled.

To work around this limitation, I had to get creative and combine SystemD timers, SystemD services, and some scripting.

Veeam CLI

You can also control Veeam jobs from outside the Terminal UI using the veeamconfig tool.

For example, you can start a backup with the following command:

veeamconfig job run --name "<JOBNAME>"

The catch is that this command is non-blocking and returns immediately. To check if the backup has completed and its status, you need to run:

veeamconfig job status --name "<JOBNAME>"

Since this command is also non-blocking, the only solution is polling. We need to repeatedly check if the job is still running until it either completes successfully or fails.

Here’s the key part of the polling script that handles the job monitoring:

# Extract session ID from job start output
SESSION_ID=$(echo "$OUTPUT" | grep -oP 'Session ID: \[\{\K[^}]+')

# Poll session status until completion
while true; do
    STATUS=$(/usr/bin/veeamconfig session info --id "$SESSION_ID" | grep "State:")
    STATE=$(echo "$STATUS" | grep -oP 'State:\s+\K\w+')
    
    if [ "$STATE" = "Success" ] || [ "$STATE" = "Warning" ]; then
        echo "Job completed with state: $STATE"
        exit 0
    elif [ "$STATE" = "Failed" ]; then
        echo "Job failed!"
        exit 1
    fi
    
    echo "Job still running... State: $STATE"
    sleep $POLL_INTERVAL
done

The script also includes signal handling to gracefully stop backups if needed.

SystemD

The SystemD side was much more straightforward. SystemD timers allow me to wake the computer from sleep mode to start the backup. For this, you only need to set the option WakeSystem=true in the [Timer] block.

The service unit was just as little of a problem with the script. I only had to prevent the computer from going back to sleep while the backup is running. For this, I used systemd-inhibit.

SystemD Service

The service unit runs our script while preventing the system from sleeping during backups:

[Unit]
Description=Veeam Backup Job %i
After=network.target

[Service]
Type=simple
ExecStart=systemd-inhibit --what "sleep:idle:shutdown" --why "Veeam Backup %i" --who "Veeam Job" --mode "block-weak" /usr/local/bin/veeam-run-polling %i
Restart=no

SystemD Timer

This timer wakes your system and runs the backup every other day at 10:30 AM:

[Unit]
Description=Veeam Backup Timer for Job %i

[Timer]
OnCalendar=*-*-1/2 10:30:00
Persistent=true
WakeSystem=true
DeferReactivation=true
Unit=veeam-run@%i.service

[Install]
WantedBy=timers.target

All unit files and the script can be found at https://git.screebo.net/cperrin/veeam-systemd-timers.

2026: The Year Windows Annoyed Us Too Much

2026-01-03T00:00:00+00:00

In the last few days, I’ve read several blog posts talking about how 2026 is the year of the Linux desktop, and that’s a great thing. However, I think many of the headlines and posts on this topic should have a different title: “The Year Windows Annoyed Us Too Much.”

A History of “Verschlimmbesserung”

For years now, Microsoft has been steadily making its operating system worse through supposed “improvements” (Verschlimmbesserung). Windows Vista was a difficult step because many computers weren’t ready for it yet, but there was at least technical progress that was successfully concluded with Windows 7.

One step that many couldn’t follow was the switch to Windows 8. Then-CEO of Microsoft, Steve Ballmer, was convinced of making Windows a universally applicable operating system. Whether on a tablet, a phone, a desktop, or an entirely new device, Windows should be the right choice. In doing so, he created a system that served almost no one well. On the desktop, the full-screen interface constantly got in the way and changed the workflow. There were few tablets, and those that existed struggled with the fact that all worthwhile programs weren’t adapted for touch, and the system was way too heavy. On phones, the system never gained traction because no one developed apps for it, making it unattractive. Other unwelcome innovations of Windows 8 included the Microsoft account login, where users were forced to log in with an online Microsoft account instead of a local one.

Some of the design decisions of Windows 8 were then “partially reversed” with Windows 8.1. The mandatory full-screen start menu was removed, and the system became more usable again. Nevertheless, Microsoft was already starting with its next great idea: automatic syncing of documents to OneDrive. Instead of asking users, Microsoft simply assumed users would love it if their data just landed in the Microsoft cloud. Additionally, the free storage was too small for most people anyway. But then you can just pay for it.

The “Forever” Windows

Windows 10 was then the “forever” Windows. It was supposed to be the last version of Windows and be continuously developed. The operating concept was now more classic again, but in many corners, things were strategically degraded. The start menu no longer just searched for programs but also documents and even online. Accordingly, it was slow and inaccurate. The tradition of pre-installed third-party software was continued with apps like Candy Crush and LinkedIn, which were automatically installed after a fresh installation of the system.

The “improvements” came gradually: OneDrive was touted ever more aggressively, Edge made itself the default browser, more and more apps that nobody wanted appeared in the taskbar, and much more. Every major update brought some improvements and many downgrades.

Windows 11 and AI

A strong shift in mood toward Microsoft was felt with the announcement of Windows 11. The Windows that was actually supposed to be the “forever” Windows would be replaced. And this time, many PCs were not allowed to come along. With Windows 11, Microsoft made TPM 2.0 and Secure Boot mandatory. For much older hardware, this was the end. The strong encouragement to use a Microsoft account in Windows 10 now became a requirement. Of course, this could be bypassed with a few tricks, but Microsoft quickly made it clear: “This is no longer your operating system; you are just a guest here.”

This mentality was only expanded further, and the pressure increased. Users were frustrated; we just wanted to use our computers. But then the unexpected happened that was to change the world: ChatGPT.

The gates were opened, tech companies got scared, and seemingly overnight, AI was what was supposed to rule everything. From now on, everything had to have AI. AI chat, AI search, AI-AI. If it didn’t have AI, it wasn’t good. The more invasive, the more intrusive, the more unavoidable, the better. AI in Windows, AI in Paint, AI in Word, AI in Excel, AI in Notepad. Nothing was safe. AI was even supposed to play our games for us from now on.

A Valve for Frustration

While Microsoft was working on designing our desktop more and more according to their ideas, a small company called Valve was quietly working on its own solution. With the Steam Deck, they brought a PC to the market, shaped like an overweight Nintendo Switch console. The hardware itself was very interesting, but the truly exciting part was the software. The special thing was that the device ran Linux.

It must be said that Valve had already tried once in the past to bring a Linux console to the market. Then conceived as a living room device, the hope was that by leading by example, other developers would also release their games for Linux. However, that did not happen.

But Valve had learned from it and invested a lot of money and time behind the scenes to make Windows games not just runnable on Linux, but run well. The Steam Deck was proof that it worked even without Microsoft and that the mantra that you can’t play games on Linux was from now on false. Of course, not everything was perfect from the start. But the foundation was laid, the infrastructure was there, and the dam was broken.

The Perfect Wave

Since the launch of the Steam Deck, a lot has happened in game support, and most titles run without problems (sometimes even better than under Windows). Only anti-cheat software still causes issues. Valve has announced more hardware that skips Windows. This, coupled with the increasing annoyance of Windows, has now convinced many people to give Linux a chance. And that is great news for everyone. When Microsoft suddenly has to compete with a free operating system that respects the user and constantly gets better, it can’t be bad for anyone. I very much hope for the year of the Linux desktop. It won’t always be easy, because not everyone wants to just play, and Linux still has many sharp edges.

For me personally, however, the year of the Linux desktop already began in 2025, and I can only benefit if more people take the step with me.

The Fediverse, Meta, and Threads

2023-07-04T00:00:00+00:00

The Fediverse is growing. Spurred by the problems at Twitter and Reddit, more and more users are now venturing onto alternative platforms. Especially Mastodon, Lemmy, and KBin have experienced an explosive surge in users recently. This didn’t happen without problems, of course, but it at least shows that there might be a way not to throw all data into the gullets of large corporations.

With the ActivityPub protocol as the glue between all Fediverse projects, the formation of silos should finally come to an end. Everyone can talk to everyone: Mastodon with Pixelfed, Pleroma with PeerTube, Lemmy with KBin. The boundaries between projects are blurring, even if sometimes content from one software makes no sense in the interface of another. But this is where the problem begins.

Meta Threads

Because even at the large corporations, the mills don’t stand still, even if it might sometimes seem that way. Meta (formerly Facebook) has decided to also be part of the Fediverse revolution. With a new project now named Threads, they want to connect to the Fediverse. It’s supposed to be a kind of microblogging platform like Twitter or Mastodon. The announcements and leaks were, of course, received in the Fediverse with great anticipation and recognition. NOT!

Many critics were reminded of the strategy coined by Microsoft: “Embrace, Extend, Extinguish.” This involves first welcoming a project with open arms to attract users, then equipping it with proprietary extensions that are incompatible with the original, and thus slowly pushing the competitor out of the market until it is extinguished. It’s not hard to see how Meta could use such a strategy against the Fediverse.

But the critics go further. As we all know, at the latest after the Cambridge Analytica scandal, Meta has significant problems with data protection. Additionally, their primary business model consists of creating and capitalizing on detailed user profiles. And here, the strength of the Fediverse becomes a potential weakness.

Federation Not Just in Star Trek

The problem can be understood most easily with a small excursion into the subject of ActivityPub. As mentioned at the beginning, it is the protocol that enables communication between all Fediverse projects. As soon as, for example, a Mastodon instance like mastodon.social allows its users to follow users from other instances and vice versa, that server is considered federated. This applies equally to groups, communities, magazines, or other “things” you can follow. As soon as a user on Instance A follows a user on Instance B, all public updates from the user on Instance B are sent to Instance A and stored on Instance A.

The attentive reader may have discovered the problem here. If a Threads user now follows a user on a Fediverse instance, data from Fediverse users inevitably ends up on Meta servers. This can be restricted by an instance defederating from Threads, thus blocking the instance’s communication with Threads. Many instance operators have already announced this step, while others want to wait and see. Opinions are certainly divided.

My bits alone!

I’m not the biggest fan of Meta and the rest myself, but I must say that I see the panic as somewhat misdirected. I’m also not thrilled that my data flows to the large corporations, but I have also decided to publish this data. An analogy for this would be standing in a marketplace to shout your opinion to the world and then getting annoyed if someone writes it down.

The concept hasn’t changed from Facebook, Twitter & Co. The data there is indeed in its own silos, but even there, data is forwarded to advertising partners and analysis firms, scraped from public pages, and processed otherwise. In the Fediverse, it’s just more obvious that the data is being forwarded. And that’s not a criticism of the Fediverse. That’s the core principle of the Fediverse.

What is the solution to the problem? My answer: There is none. At least not in the way many would like. As a society, we have forgotten that it’s not always good to stand in the marketplace and start shouting. We have started showing strangers our baby photos, sharing our location, and revealing our innermost selves. All without really making clear what the implications are. Partly they were obscured from us, partly we ignored them.

The problems of the Fediverse, like the solution, are not new. We need to reveal less about ourselves. We must be aware that a sent Toot, just like an Instagram post, is no longer in our hands after sending. They can be processed, correlated, and made into a personal profile. For that, you don’t even need Threads from Meta. The public sharing of data is incompatible with a desire for control.

We can try to strengthen the rights of users through laws and make the processing of data more difficult, but ultimately, even without big evil companies, one thing remains the same:

Social Media is not Private Media

New is Always Better (?)

2021-09-16T00:00:00+00:00

I have something to confess. I have a problem. I’m not sure if my problem has a name, so I’ll give it one. I call it “Neoprogrammism.” What is it? Well, it’s best explained with an example.

Example 1

I’m now well-versed in Python and Django from several projects, but I’m not as familiar with JavaScript. There’s a new project to generate APIs directly from the database schema that relies entirely on JavaScript? I’ll take it!

Example 2

JavaScript isn’t that familiar to me, but I like CSS. To make my life easier and follow best practices better, I decide on a CSS framework. Now, there are a lot of established frameworks in this area, but I recently read with half my brain in an article that there’s a new slim framework. Better take that one!

What I mean to say is…

Neoprogrammism can affect us all because few of us are immune to the latest “bling.” It’s often tempting to use the latest and “greatest” for a new project. That doesn’t necessarily have to be a bad thing. New projects sometimes do things better or have a chance of receiving support for longer in the future.

However, one must not forget that there might be a reason why “older projects” are still there and being actively developed. There might also be good reasons why these projects work the way they do. Additionally, there has been more time to build an ecosystem around them.

The most important question I ask myself to defeat my Neoprogrammism is whether I only want to use something because it’s new or trendy.

New Design for the Blog

2020-02-20T00:00:00+00:00

The era of downloaded and adapted designs is over. My first own design sees the light of day. I call it cperrin-hugo-theme. Poetic, isn’t it?

But that’s not the only new thing. I came up with my own brand-hot and ultra-creative logo to make the crowds scream.

Does the work make sense, considering how many posts I’ve written since the beginning of the blog? Certainly not! Was it fun? Yeah. Was it a good way not to do what I should be doing? Definitely!!

Ansible: DevOps Made Easy

2017-09-08T00:00:00+00:00

The problem is quite old: A large number of servers need to be set up or homogenized, ideally with minimal effort. This problem has been solved several times. So-called orchestration tools execute specific commands on multiple systems based on predefined instructions.

Examples of such tools are Puppet, Chef, or CFEngine. However, these representatives have one major disadvantage for me: they require a client to be installed on the remote side for execution.

This is where Ansible comes in. Ansible uses only an SSH connection to execute scripts or playbooks on the clients.

The best way to demonstrate the simplicity of Ansible is with a small example in which a list of packages is installed via apt. First, we create the basic structure:

mkdir ansible
cd ansible

Next, we need to create an inventory, which is a list of servers and groups on which the playbooks will be executed.

# ansible/inventory
[group1]
server1
server2
server3

In this example, we have a group called group1 containing servers 1-3.

Next, we need to create a playbook containing the instructions for Ansible:

# ansible/site.yml
---
- hosts: all                 # select servers
  become: yes                # execute as sudo
  tasks:                     # list of tasks
    - name: Install packages # name for the task
      apt:                   # use the APT module
        name: "{{ items }}"  # name of the package
        state: present       # status of the package
      with_items:            # loop with a list. fills {{ items }}
        - program1
        - program2
        - program3

This playbook installs the programs program1-3 via apt.

To run this playbook, we just need to execute:

ansible-playbook site.yml

If you haven’t set up SSH key authentication, you need to append the -k option. To authenticate with a user other than the currently logged-in user, use the -u <username> option.

That’s it. Ansible should now connect to all servers via SSH and install the listed packages. If the packages are already installed, Ansible will simply skip them.

Ansible now has a huge number of modules to choose from, allowing you to use Ansible in a wide variety of use cases.

Seafile: OwnCloud, Only Better

2017-01-02T00:00:00+00:00

Anyone who has read my post about OwnCloud will know that I strive to store my data, if possible, not with Dropbox & Co. In the past, OwnCloud was the best and simplest solution, but for some time now, there has been an alternative that is worth seeing: Seafile.

Seafile offers free sync clients for every common platform (Windows, Linux, macOS, Android, iOS).

In the background, the application, written in Python, works in two parts. The seafile application controls the saving and syncing of data. It uses a filesystem based on git, which means that by default, all files are versioned. The other part is seahub, which provides the web interface to Seafile.

From my perspective, Seafile has the major advantage that it is not written in PHP. One has to torture PHP very much to extract functionality like OwnCloud from it. This is noticeable in performance. Likewise, the separation of the web interface and the sync server is advantageous. Sync clients speak directly to the sync server, and the website is just another sync client.

Moving to Hugo and a New Domain

2016-05-19T00:00:00+00:00

I have long maintained a WordPress blog and rarely posted anything. In the process, I repeatedly noticed how slow WordPress actually is. Additionally, I need PHP and a database to keep everything running. This, coupled with the fact that there were recurring security vulnerabilities in WordPress, led me to search for an alternative.

Since I don’t need much dynamic content on my website, I looked for a static site generator and came across Hugo.

Hugo is an application written in Go that generates static HTML files from Markdown files and templates. I now deliver these only with an Nginx and have a beautiful blog without PHP and MySQL. Thanks to Disqus, I don’t even have to give up a comment function.

To make my life even easier, I use Gogs and Drone.io to automatically build my blog and copy it to the server. For this, I use the following .drone.yml:

build:
  production:
    image: publysher/hugo
    commands:
      - hugo --destination=<production_source>
    when:
      branch: master
  staging:
    image: publysher/hugo
    commands:
      - hugo --destination=<staging_source> --buildDrafts=true --buildFuture=true --baseUrl=<staging_url>

publish:
  rsync:
    host: <server>
    user: <user>
    source: <staging_source>
    target: <staging_target>
    recursive: true
  rsync:
    host: <server>
    user: <user>
    source: <production_source>
    target: <production_target>
    recursive: true
    when:
      branch: master

This ensures that every push to my Gogs repo triggers a build and loads a production and a staging version onto the server. It’s almost magic.

To top it all off, I have acquired a new and more personal domain. My blog will be found at https://cperrin.xyz in the future.

PAMMySQLTools: Manage libnss-mysql and pam-mysql Users via the Shell

2016-05-13T00:00:00+00:00

Through my work, I faced the problem that we wanted to authenticate users centrally via MySQL. This is not inherently a problem thanks to libnss-mysql and pam-mysql, but unfortunately, there is a lack of programs to manage users effectively.

Therefore, I have written tools that imitate the Linux programs user{add,mod,del} and group{add,mod,del} and published them as PAMMySQLTools on PyPI.

Installation

Thanks to pip, you only need to run the command:

pip install pammysqltools

pip3 install pammysqltools

to install the tools. This will install the following programs:

myuseradd
myusermod
myuserdel
mygroupadd
mygroupmod
mygroupdel
myimportusers
myimportgroups

The myuser* and mygroup* tools are mostly modeled after the Linux programs and behave largely the same.

The tools myimportusers and myimportgroups import users from /etc/passwd and /etc/groups, or /etc/shadow and /etc/gshadow.

For an overview of the arguments, simply append --help.

Example: myuseradd

$ myuseradd --help
Usage: myuseradd [OPTIONS] LOGIN

Options:
  -b, --basedir BASE_DIR          base directory for the home directory of the
                                  new account
  -c, --comment COMMENT           GECOS field of the new account
  -d, --home-dir HOME_DIR         home directory of the new account
  -e, --expiredate EXPIRE_DATE    expiration date of the new account
  -f, --inactive INACTIVE         password inactivity period of the new
                                  account
  -g, --gid GROUP                 name or ID of the primary group of the new
                                  account
  -G, --groups GROUPS             list of supplementary groups of the new
                                  account
  -k, --skel SKEL_DIR             use this alternative skeleton directory
  -K, --key KEY=VALUE             override /etc/login.defs defaults
  -M, --no-create-home / -m, --create-home
                                  do not create the user's home directory
  -U, --no-user-group / -N, --user-group
                                  do not create a group with the same name as
                                  the user
  -o, --non-unique                allow to create users with duplicate (non-
                                  unique) UID
  -p, --password PASSWORD         encrypted password of the new account
  -r, --system                    create a system account
  -s, --shell SHELL               login shell of the new account
  -u, --uid UID                   user ID of the new account
  --config CONF_PATH              path to the config file for this tool
  --help                          Show this message and exit.

Configuration

To customize the database connection and the naming of tables and columns, the file /etc/pam_mysql_manager.conf must be created according to this scheme. Alternatively, the path to the configuration file can be passed with the --config argument. For all options not specified here, the values in the sample file are the defaults.

Once everything is set up, you’re ready to go.

Examples

Create a user:

$ myuseradd testuser

Change the shell:

$ myusermod -s /bin/zsh testuser

Import groups without passwords:

$ mygroupimport -i

CARP & HAProxy: High-Availability for Beginners

2012-12-21T00:00:00+00:00

The field of high-availability in the web area is often complicated, large, and hard to grasp. But it doesn’t have to be, thanks to CARP and HAProxy. The combination of these two techniques makes it possible to distribute requests to multiple servers and thereby avoid the single-point-of-failure problem. For this, we only need at least 2 computers with FreeBSD (or another BSD system with CARP support) that are in the same subnet and some time to set up the following software:

HAProxy

HAProxy is a reverse TCP proxy with load-balancing functionality. It distributes the load to multiple (backend) servers and detects when one of them is no longer reachable. HAProxy can be used for balancing both MySQL requests and HTTP requests. I will focus exclusively on the latter here.

Installation

The easiest way to install it is through the ports tree:

cd /usr/ports/net/haproxy
make install clean

This compiles and installs HAProxy on the system.

Configuration

The configuration file for HAProxy is located at /usr/local/etc/haproxy.conf. A starting point for a working configuration could be the following:

global
        daemon
        maxconn 256

defaults
        mode http
        timeout connect 5000ms
        timeout client 5000ms
        timeout server 5000ms
        stats enable

frontend http-in
        option httplog
        log global
        default_backend servers

backend servers
        server server1 server1.example.com:8080 check
        server server2 server2.example.com:8080 check

CARP

CARP stands for “Common Address Redundancy Protocol”. It allows an IP address to be automatically taken over by another host if it is no longer reachable. The prerequisite for this is that all computers are in the same network segment, as CARP works via broadcast.

Installation

Starting with FreeBSD 9.0, CARP is enabled by default. For older versions, support must either be compiled into the kernel or the kernel module must be activated with the entry:

if_carp_load="YES"

in the file /boot/loader.conf.

Configuration Files

The configuration of CARP is relatively simple. First, a master server is configured. This server holds the IP by default.

To do this, we need to create and configure a CARP interface. During operation, we use:

ifconfig carp0 create
ifconfig vhid 1 pass <password> 10.10.0.1/16

The password and the vhid number must be the same on all backup systems. To ensure this configuration works after a restart, we add the following lines to /etc/rc.conf:

cloned_interfaces="carp0"
ifconfig_carp0="vhid 1 pass <password> 10.10.0.1/16"

On the backup systems, the CARP interface is created in a similar way, but the “advskew” argument is inserted:

cloned_interfaces="carp0"
ifconfig_carp0="vhid 1 advskew 100 pass <password> 10.10.0.1/16"

The higher the value after “advskew”, the lower the priority if the main system fails.

OwnCloud: Self-Hosted Dropbox

2012-08-13T00:00:00+00:00

Dropbox is one of the most practical tools that help me in my daily work. Whether it’s just synchronizing data or even sharing it with others, it’s possible with just a few clicks.

Unfortunately, the whole thing has a serious drawback: My data is no longer with me! Although data in Dropbox is reportedly encrypted, you can NEVER be sure what might happen to your own data.

For this dilemma, there is now a solution: OwnCloud

OwnCloud is an Open Source PHP application to offer your own Dropbox-like service. With OwnCloud, it is easy to maintain full control over your data without much extra effort.

The installation is child’s play and doesn’t even necessarily require the installation of a MySQL server. By default, SQLite is used. The installation can be divided into two simple steps:

Webserver Configuration: There are templates for many servers on the OwnCloud website.
OwnCloud Setup: The setup of OwnCloud consists of ONE page. You only need to create an admin account and, if desired, specify a MySQL server.

Finished!

By now, there is also a sync client for almost every platform (Linux, Mac, Windows, Android, iOS).

However, OwnCloud wants to be more than just a simple Dropbox replacement. Here are some features:

Calendar
Music player for stored music
Contacts
Image gallery
Encryption of files on the server
Integration of Dropbox, GDrive, etc., into your own OwnCloud
Ampache/WebDAV/CalDAV/CardDAV server
Plugin interface
LDAP authentication

OwnCloud is definitely worth a look and has by now become a truly viable alternative to Dropbox and similar services.

cperrin.xyz

What can we do about the vibe committer

Consent is king

Solid Snake and Benny Hill

Distrust leads to anger, anger leads to a bad time for everyone

Pragmatic principles

Afterword

Triggering Veeam Backups on Linux with SystemD

Veeam CLI

SystemD

SystemD Service

SystemD Timer

2026: The Year Windows Annoyed Us Too Much

A History of “Verschlimmbesserung”

The “Forever” Windows

Windows 11 and AI

A Valve for Frustration

The Perfect Wave

The Fediverse, Meta, and Threads

Meta Threads

Federation Not Just in Star Trek

My bits alone!

Social Private Media

New is Always Better (?)

Example 1

Example 2

What I mean to say is…

New Design for the Blog

Ansible: DevOps Made Easy

Seafile: OwnCloud, Only Better

Moving to Hugo and a New Domain

PAMMySQLTools: Manage libnss-mysql and pam-mysql Users via the Shell

Installation

Configuration

Examples

CARP & HAProxy: High-Availability for Beginners

HAProxy

Installation

Configuration

CARP

Installation

Configuration Files

OwnCloud: Self-Hosted Dropbox