abbbi

most cringe read since a long time. This kid needs to grow up. It literally hurts reading his blog posts.

i looked at containerssh once and it was way to featureful for me. I came up with a simple ssh daemon that basically does spawn arbitary containers on ssh login and destroys on exit: https://github.com/abbbi/sshcont

If i could start over again i would love to work as forester. I even considered working as lumberjack. I got required certificates, im legally allowed to work in the industry doing sawork (as in, felling trees, even if not private property).

I know it is an highly physical demanding and also very risky job. Now that a second child arives, obviously, life changing again, i just cant do it, i need to feed two kinds soon and these kind of jobs are not well payed.

So ill stick to doing my own firewood once a year, a couple of days outside in the woods and keep dreaming about it.

Live goes by too fast.

so that comes quite right. Im currently working on a codebase that has evolved over 30-ish years. The makefiles are quite a mess and since ages, the software has been built sequentially which results in build times beeing much longer than required.

Of course the project consists of multiple module which you should be able to build seperately, thus recursive calls are quite common amongst the makefiles.

First test with only a hand full of jobs (-j) already failed in the beginning, i could fix these quite fast (missing makefile targets).

Now i have the situation that on some build systems (with faster CPU) i still see races, where the same makfile target for a subproject runs at the same time and overwrites each others target files. On other build systems it works without any issue. However, ive still failed to reproduce the failure manually, it usually happens during automatic build invoked by jenkins or gitlab.

Is there a way to make "make" simulate those builds so one could tell where the cause for the races is in detail?

exactly.

shares some insights:

https://arstechnica.com/civis/threads/winamp-really-whips-op...

sorry, but this was a real shitshow. I dont understand: wtf makes people think spamming an repo in the way they did is in any way useful?

this site rocks wtf, your completely drawn into a nice story. Never had such an urge to dig deeper since a long time i opened a site.

Proxy written in golang that will emulate a Proxmox backup server and work on one or more S3 buckets

used it for years, .. then switched to i3. Never looked back :)

there is the AuthorizedKeyscommand feature that allows for a command to fetch keys not yet existing on a system. Gitlab uses it to fetch keys from a database, for central user and access management. They also ship a own sshd implementation which does kinda neat lookup things for very big databases.

theres already projects solving central ssh key management, for example:

https://github.com/ierror/ssh-permit-a38 (distributes via authorized keys)

https://github.com/netlore/OpenAKC

https://tenshidev.medium.com/centralized-ssh-authentication-...

and

https://docs.gitlab.com/ee/administration/operations/fast_ss...

Schedule: https://debconf24.debconf.org/schedule/ Streams: https://debconf24.debconf.org/ -> Video streams

it depends. Doing a complete disaster recovery of a windows system IMHO can be a real struggle. Especially if you have to restore a system to different hardware, which the system state backup that microsoft offers does not support afaik.

Backing up a linux system in combination with REAR:

https://github.com/rear/rear

and a backup utility of your choice for the regular backup has never failed me so far. I used it to restore linux systems to complete different hardware without any troubles.

wyng backup does this. It uses the device mappers thin_dump tools to allow for incremental backups between snapshots, too:

https://github.com/tasket/wyng-backup

edit: requires lvm thin provisioned volumes

There is also thin-send-recv which basically does the same as zfs send/recv just with lvm:

https://github.com/LINBIT/thin-send-recv

it uses the same functions of the device mapper to allow incremental sync of lvm thin volumes.

for RHEL based distributions you can do the same with an LVM and using boom boot manager.

https://github.com/snapshotmanager/boom-boot

Marcan is an beast, this guy really loves to go down the rabbit holes.

looks nice, does it support presets like datasette?

1) you create an container image based on the upstream image that supports bootc, using a Containerfile that serves what ever purpose you want.

2) you push that container image to some registry

3) you use the bootc image container to create an qcow file from the image you have built (or you install the image on a bare metal system)

4) you boot up the virtual machine or bare metal system, which now includes "bootc" utilties too

5) from this point on you can update the container image you have created in step 1) and you automatically roll forward the booted virtual machine or bare metal system to the latest image you have relased (or rollback, if your updated image breaks stuff) using the included bootc utility

Currently the image that supports this seems to be limited to centos:stream9, or rhel9:

https://www.redhat.com/en/blog/image-mode-red-hat-enterprise...

Ah... nice to see dylan is still alive. I used kiss linux for a while. It always makes me wonder. There is an obviously very talented programmer, creating multiple projects that all kick of in some kind of a way (or very good documentation, like his bash bible). And then, all of a sudden, dead silence and goes ahead with a completely different way of life.

proxmox is using LVM for direct attached raw volumes. LVM is just a logical volume manager for linux, which gives you more features than using old fashioned disk partitioning. I guess they chose this path for windows virtual machine migration because windows running on vmware before, does usually not have the required virtio drivers installed to support the qemu hypervisors virtio solution for disk bus virtualization out of the box. It would mean the hypervisor has to simulate IDE or SCSI bus which comes with great overhead perfomance wise (in the case of migration)

So an direct attached lvm volume is the best solution performance wise. In the vmware world this would be an direct attached raw device either from local disk or SAN.

For fresh install on proxmox its better to chose qcow as disk image format with virtio-scsi bus (comparable to vhdx, vmdk, qemus disk format) and add virtio drivers during windows setup.

yeah, but that will slow down your app and may help in a short run, but you basically just shift the problem and make it even worse if your workload gets even higher.

back in the days where we hit this issue (mostly on windows systems) i used to create a little stress tool, you would be surprised how fast you reach the database-locked state.

ive just put it here: https://github.com/abbbi/sqlitestress

maybe its useful for some people to simulate their workloads.

WAL does not help with "database locked" situations. At some point you will see them even with WAL enabled, and your application frontend code has to deal with the timeout and retry or whatever.

another article praising sqlite in production and working around a known sqlite limitation: concurrent writes. As they link in the article:

But, my favorite feature of the gem is its improved concurrency support.

[..] https://fractaledmind.github.io/2023/12/11/sqlite-on-rails-i...

Really. At the point you are experiencing database locked in your productive app that uses sqlite as backend, i would strongly suggest to use another database backend that was designed with concurrent writes in mind.

Nothing against sqlite in production, its nice, as long as your workload meets its feature set.

is the podman machine still limited to fedora?

windows PE is way smaller, boots live around ~250 MB in size. Of course without any namely applications.

sad :( I still prefer IRC over all these other solutions like discord. They just don't feel right.

it works if there is low traffic, as soon as you got bigger transactions or the amount of concurrent writes becomes heavier, you will at some point (even with WAL enabled) get "database locked" issues. You can work around that on application level to a certain point, but in general, if you are at that point, you should really consider using another database backend.

well, i just wanted to get a feeling what experience it would be using their web console and it seems they still have some limitations in place that have long been solved by other "hyperconverged vm-deploy" players.

Want to spin up not only 1 but 20 instances via the console? Nope. Any kind of guest agent in the virtual machine? For direct interop? How is the guest filesystem freezed during snapshot creation? Checkpoints for incremental vm backup? They seem to use raw images, not qcow2? Why?

etc..

just fooling around with their demo web console ..

"A disk cannot be added or attached unless the instance is creating or stopped." "A network interface cannot be created or edited unless the instance is stopped."

really?