halp's questions

I am trying to mirror a directory that changes over time to another directory. My problem is that rsync is not deleting files on destination if they aren't existing in source directory anymore. Here is a demo script:

#!/bin/sh

set -x

DIR1=/tmp/1
DIR2=/tmp/2

rm -rf $DIR1
rm -rf $DIR2

mkdir $DIR1
mkdir $DIR2

echo "foo" > $DIR1/a
echo "bar" > $DIR1/b

rsync -a $DIR1/* $DIR2

rm -f $DIR1/a

rsync -a --delete $DIR1/* $DIR2

ls -1 $DIR2

Here is the output:

+ DIR1=/tmp/1
+ DIR2=/tmp/2
+ rm -rf /tmp/1
+ rm -rf /tmp/2
+ mkdir /tmp/1
+ mkdir /tmp/2
+ echo foo
+ echo bar
+ rsync -a /tmp/1/a /tmp/1/b /tmp/2
+ rm -f /tmp/1/a
+ rsync -a --delete /tmp/1/b /tmp/2
+ ls -1 /tmp/2
a
b

As you can see, file "a" is still present in destination directory after rsync runs for the second time, which is not what I need. Am I misusing the '--delete' option?

When a process is exchanging data over network, I can think of at least the following parameters:

• a remote host:port pair - it identifies the remote endpoint (there's also the local host:port pair, but the port is generally randomized for outgoing connections, so I don't need it)
• is it TCP or UDP traffic
• is it incoming or outgoing traffic

How can I log all this data for a certain process during its whole lifetime? I need this on Linux. I'm not trying to block some traffic, just to log the above details.

As I understand, a network sniffer alone won't do it, since when an IP packet is coming from outside, the sniffer has no idea about which process the packet is for (since this is another layer, the application layer IIRC).

I want to learn one more Linux distribution. I'm serious and "one more" means the second one. I've been using a Linux distribution for almost a decade, I like it very much, but I want to learn something new additionally.

I plan to go with a common /home partition to always have my preciousss config files at hand. While I plan to spend most of the time in the new distribution, I expect to be dual-booting sometimes. My main concern is to not screw file permissions in my home due to my users having different UIDs in the two distributions. I know that when creating an user (at least when doing it using CLI tools like useradd) I can explicitly specify the UID. What to do if the install of the new distro would allow me to create an user, but won't allow me to choose the UID explicitly? Just skip this step or create a stub user, then later create an user from command line? And what to do if the UID of my user in my primary distro would be already taken in the new distro? Any other ways to avoid these eventual troubles?

Are there any additional problems if my /home is encrypted? I do it using the LUKS-enabled cryptsetup.

Currently I back up my personal files using a simple shell script that creates a tarball. It is being run by cron hourly.

I'm planning to switch to incremental backups (I will use duplicity), because this will minimize the data transfer over network.

This leads me to some general questions:

• when making incremental backups, what strategy to choose? As I understand, such a strategy implies creating a full backup, then some incremental backups. At some point, a full backup is made again and it starts a new set. My problem is I don't know how to decide how often I should make this full backup again. If I'm doing backups hourly, would it make sense to start the day with a full backup and do incremental ones later, or is there a better strategy?
• how many full sets of backups should I keep before starting to rotate them?

Goal: when running a FPS game in Linux, automate the setup of higher priority for its network traffic

I know such tasks are usually accomplished with a combination of iptables (to mark IP packets meeting certain criteria) and tc (to prioritize those IP packets).

Problems:

• earlier version of iptables had an --pid-owner option with a warning in the manpage that this is broken on SMP kernels. My recent version of iptables (1.4.7) doesn't mention this option in the manpage at all
• probably I can't use a single destination port to match traffic, because game servers run on different ports

I aim for a wrapper shell script which will:

• run the game executable
• find its name/pid
• based on this will increase the priority of network traffic for this process
• when I exit the game, will restore everything to defaults

Is this possible? I'm willing to go as far as dealing with custom netfilter modules, if there are any which could help.

What is the difference between renice and chrt commands in Linux?

I need to tune up a networking app for network specific things like:

• make it use a DNS server different than the default one from /etc/resolv.conf
• make sure it does not try to connect to certain hosts/ports using tcp/udp connections

I know I can get away with just modifying /etc/resolv.conf and writing some iptables rules, but going for a default DENY firewall policy for outgoing IP packets can trigger malfunctions in other services running on the server.

I know I can set up a virtual machine with a whole OS and run my app there, but it seems a bit overkill.

Is it possible to have a networking "jail" for a single app (think single Linux process) that could accept iptables-like rules for network traffic (think in terms of IP packets and above) allowed to and from this particular app? Maybe this is achievable through some dynamically loaded library that can deal with the networking layer, the same manner tsocks does, but more fine-grained?

To serve static content of a directory over http, one can simply navigate to that directory and type:

python -m SimpleHTTPServer 11111

which will start a http server on port 11111.

This hack is nice because it requires zero-config: no stand-alone web server, no config files at all.

Is it possible to extend this example, or have an alternate way to achieve this goal, but also have CGI support?

The final goal is to have a quick and lazy way of serving a web site from a certain directory. The site has static content (HTML pages, images), but also a CGI script. The CGI script must work properly when accessed via browser.

Of course I could setup a virtual host in apache, allow CGI inside it etc. But that's not a zero-config approach.