syncthing | Open Source Continuous File Synchronization

I have a docker_container which I want to deploy for multiple users and name traefik routes after the users. But i'm confused on how I can achieve this.

Here is what I have:

I'm trying to deploy okteto environment on Visual Studio Code to use Remote Development on Kubernetes.

Following the official steps (https://okteto.com/blog/remote-kubernetes-development/), I executed "Okteto: up" and selected manifest(vscode-remote-go/okteto.yml), but got this error:

Until now id do versionining with subfolder for each version and sync betwen computers with syncthing. It works but it's easy to do mistake editing wrong version and similar. So I was thinking to switch to some versioning software. Git seems to be capable to do that and much more. But seems that Git offer to much and I can't see correct way to do.

For example I do make project folder and write .gitignore file with list of files I don't want to be in Git (mostly compiling results) After that I do write some sources and then issue:

I wonder about an efficient way to copy files (on Linux, on a FS which supports copy-on-write (COW)). Specifically, I want that my implementation uses copy-on-write if possible, but otherwise falls back to other efficient variants. Specifically, I also care about server-side copy (supported by SMB, NFS and others), and also zero-copy (i.e. bypassing the CPU or memory if possible).

(This question is not really specific to any programming language. It could be C or C++, but also any other like Python, Go or whatever has bindings to the OS syscalls, or has any way to do a syscall. If this is confusing to you, just answer in C.)

It looks like ioctl_ficlonerange, ioctl_ficlone (i.e. ioctl with FICLONE or FICLONERANGE) support copy-on-write (COW). Specifically FICLONE is used by GNU cp (here, via --reflink).

Then there is also copy_file_range, which also seems to support COW, and server-side-copy. (LWN about copy_file_range.)

It sounds as if copy_file_range is more generic (e.g. it supports server-side-copy; not sure if that is supported by FICLONE).

However, copy_file_range seems to have some issues. E.g. here, Paul Eggert comments:

[copy_file_range]'s man page says it uses a size_t (not off_t) to count the number of bytes to be copied, which is a strange choice for a file-copying API.

Are there situations where FICLONE would work better/different than copy_file_range?

Are there situations where FICLONE would work better/different than FICLONERANGE?

Specifically, assuming the underlying FS supports this, and assume you want to copy a file. I ask about the support of these functions for the functionality of:

• Copy-on-write support
• Server-side copy support
• Zero-copy support

Are they (FICLONE, FICLONERANGE, copy_file_range) always performing exactly the same operation? (Assuming the underlying FS supports copy-on-write, and/or server-side copy.)

Or are there situations where it make sense to use copy_file_range instead of FICLONE? (E.g. COW only works with copy_file_range but not with FICLONE. Or the other way around. Or can this never happen?)

Or formulating the same question differently: Would copy_file_range always be fine, or are there situations where I would want to use FICLONE instead?

Why does GNU cp use FICLONE and not copy_file_range? (Is there a technical reason, or is this just historic?)

Related: GNU cp originally did not use reflink by default (see comment by the GNU coreutils maintainer Pádraig Brady). However, that was changed recently (this commit, bug report 24400), i.e. COW behavior is the default now (if possible) (--reflink=auto).

Related question about Python for COW support.

Related discussion about FICLONE vs copy_file_range by Python developers. I.e. this seems to be a valid question, and it's not totally clear whether to use FICLONE or copy_file_range.

Related Syncthing documentation about the choice of methods for copying data between files, and Syncthing issue about copy_file_range and others for efficient file copying, e.g. with COW support. It also suggests that it is not so clear that FICLONE would do the same as copy_file_range, so their solution is to just try all of them, and fallback to the next, in this order: ioctl (with FICLONE), copy_file_range, sendfile, duplicate_extents, standard.

Related issue by Go developers on the usage of copy_file_range. It sounds as if they agree that copy_file_range is always to be preferred over sendfile.

(Question copied from here but I don't see how this is too less focused. This question is very focused and asks a very specific thing (whether FICLONE and copy_file_range behave the same), and should be extremely clear. I formulated the question in multiple different ways, to make the question even more clear. This question is also extremely well researched, and should already be very valuable to the community as-is with all the references. I would have been very happy if I would have found such a question by itself, even without answers, when I started researching about the differences between FICLONE and copy_file_range.)

To preface this, I am working on a pull request for Syncthing - a continuous file synchronization software. The pull request will allow for an url to be seen for all connected remote machines from the GUI.

The problem I am having is the OPTIONS request is failing to the remote machines. Before the program displays an url to the remote machine, the maintainers have requested that that the GUI verifies the machine will allow the user to visit the remote machine GUI (GET request will fail if the machine has set authentication, so verifying an OPTIONS response is good enough). I can verify the CORS is setup properly. I can even send a curl request and go to the remote machine through the browser, but for whatever reason, the javascript OPTIONS request receives a network error. When I look at the remote machine that will respond to the request, no matter curl, javascript, or browser, it's sends a 201 request back. However, when I look into the chrome network console of the machine sending the request, I see the options request fails, but later on, it seems the request succeeds. My intuition was that the request timeout before the machine sends a valid response and retries. Still, after setting a longer options request header, it does not change result as if the timeout duration is not affecting the error.

This javascript snippet comes from the GUI using angular. It uses angular $http library.

Trying to make my first steps to the marvelous world of Python programming, I stumbled on the very beginning.

I'm trying to implement a virtual machine for Python bytecode on Python (for educational purposes). So, separating the process of making the bytecode and running it — kind of seems like a good idea. I would like to serialize code objects into files before deserializing and running it in a separated script.

Here is how the code of serializer looks like:

Of course, I'm using git for version control, which also serves (to an extent) to keep different computers in sync. Now consider this scenario: I've been working on some big changes on my computer, but I need to leave and want to continue on my laptop. But the code is broken in its current state; it might not even compile.

If I'm working all alone with a private repository I guess I could just go ahead and commit the mess to continue the work on my laptop. It does have a bad smell though.

But if I'm working with a team on the same repository that's a no-go. A branch might save me here, but that still smells like a workaround.

I've also thought of using a synchronization application like Syncthing, but I'm afraid that two different synchronization applications might bite each other at some point. I wouldn't forgo git when using Syncthing.

I'm aware that this question will likely not result in one single correct answer. But I think that this a common scenario programmers might face and hope that different ideas on how to deal with it will be considered helpful for the community.