bash: ldconfig: command not found

You might encounter this error or something very similar, especially when you are using sudo instead of changing to root with su (see my article on how to enable sudo).

Problem

The problem is that programs like ldconfig are located in the  /sbin folder, but this folder is not added to the PATH variable.

If you don’t know what PATH is:

The path variable is essentially a list of folders. When you type a command in bash (the terminal/command line) like this:

ldconfig

then bash will go through all the folders listed in the PATH variable and see if a program with that name is in that folder. If it finds that program, it will execute it.

The problem here is that PATH (the list of directories where bash will look for the program) does not contain the folder /sbin. But because the program is in this folder and bash does not look there, bash will not find the program and instead annoy you with an error.

Solution

The solution is to add  “/sbin” to the PATH variable. This can be done by editing the file “/etc/profile”.

Type

sudo nano /etc/profile

or – if you are more comfortable with a GUI based text editor – you can also type

sudo gedit /etc/profile

At the beginning of the file, you will see the following:

if [ "`id -u`" -eq 0 ]; then
  PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
else
  PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
fi

This sets the PATH variable for the root user and every other user. The first line that starts with “PATH=…” sets the PATH for the root user and the second line sets PATH for everybody else. So the code fragment basically translates to:

if user=root then
  PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
otherwise
  PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"

The second line is what we have to care right now. The directories in the list are separated by a colon, so the list contains the following directories:

• /usr/local/bin

• /usr/bin

• /bin

• /usr/local/games

• /usr/games

We want to add a few directories to that, namely:

• /usr/local/sbin

• /usr/sbin

• /sbin

For ldconfig and a lot of other programs, adding “/sbin” would be enough, but I added the others as well, because I thought: “I don’t wanna come back two more times, just because I might realize later that I should have added them as well in the first place”

You could add the directories anywhere in the list, but I like to add them in the same order they appear in the PATH variable for the root user, so I will change the beginning of the file to this (remember to separate the directories with a colon):

if user=root then
  PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
otherwise
  PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/games:/usr/games"
fi

Save the file; when using nano, just

• hit “Ctrl+X” to quit
• then “Y” to confirm that you want to save the modified version
• then hit the enter key to confirm the filename

And finally: Log out and log back in.

What Aliases Are

Here is a short introduction to aliases in case you have not idea what they are:

An alias is simply a different name for a specific command line command. You can call an alias like any other program and the shell will then replace the alias with the command it represents.

If you find yourself typing”aptitude” a lot you could, for example, define an alias “a” for this command instead. Now, instead of typing

aptitude install <package>

you just need to type

a install <package>

Bash will recognize that the command a is really just an alias that stands for “aptitude” and therefore replace a with “aptitude”. You could make your like even easier by assigning an alias “ai” to the command “aptitude install”. Then, when typing

ai <package>

bash will notice that the command “ai” is really just an alias for “aptitude install” and replace “ai” accordingly. Therefore, the command that bash will execute is:

aptitude install <package>

Permanently Storing Your Aliases

It is important to note than running the commands below will only change the alias definitions for the current shell. The changes will not appear in other shells and they will be lost when closing the shell (and logout/shutdown/reboot). This basically means that the changes are only temporary.

Therefore, if you want to permanently define new aliases, you can create new file named

.bash_aliases

in your homefolder (the file will most likely not exist already) and put all you alias definitions in there. Alternatively you can add the definitions to the file

.bashrc

in your home folder, but it’s cleaner to have a separate file for the aliases and the .bashrc should already check for a file named .bash_aliases, so you only need to create the .bash_aliases and the file will automatically loaded.

It is important to note that the .bashrc and therefore the .bash_aliases will only be read when the shell is created. Therefore, you won’t see the changes to .bash_aliases immediately. You need to either create a new shell after saving your modified .bash_aliases or (re)load the .bash_aliases file like this:

. ~/.bash_aliases

You can, of course, create an an alias for this command in your .bash_aliases file…

List All Aliases

To get a list of all aliases which are currently defined, all you need to do is to run:

alias

This will list all defined aliases, one per line, like this:

alias la='ls -la'
alias ls='ls --color=auto'
alias lx='ls -lAh --group-directories-first'

List A Specific Alias

To only get the value of a specific alias, you can type:

alias <name>

You can also use this command to display several aliases:

alias <name1> <name2> ...

Example 1

alias la

will display

alias la='ls -la'

Example 2

alias ls la

will display:

alias ls='ls --color=auto'
alias la='ls -la'

Create A New Alias / Change An Existing Alias

Creating a new alias or changing the value of an existing alias can be done in the same way:

alias <name>=<value>

For example, creating an alias “www” to avoid typing “cd /var/www” all the time, can be done like this:

alias www='cd /var/www'

Combining Aliases

When defining an alias it is possible to use another alias. Let me show you two examples of how this might be put to use:

Supplying (additional) options

The only predefined alias on Debian is

ls='ls --color=auto

By defining an alias la like this:

alias la='ls -la'

You already used an alias for defining the new alias. When typing

la

bash will now recognize that “la” is an alias and replace it with its value:

ls -la

But now, again, bash will recognize that “ls” is an alias as well and replace this will its value “ls –color=auto”, which results in the command:

ls --color=auto -la

(bash will not recognize ls an alias again, so this is where it stops)

In this example the alias “la” used the already defined alias “ls” (which adds coloring to the command ls) to add the additional options “-l” and “-a” to it. This can be used for various purposes. If you want to define various aliases for the ls command, for example, it might be a good idea to create an alias that already contains the common options (like coloring) you want to use for all the other aliases. This will shorten the alias values, which makes them easier to manage. Instead of defining the following aliases:

alias la='ls -la --color=auto'
alias lh='ls -lh --color=auto'
alias lx='ls -lAh --color=auto --group-directories-first'

you could define them like this:

alias la='ls -a'
alias lh='ls -h'
alias ls='ls -l --color=auto'
alias lx='lh -A --group-directories-first'

In this example the alias ls already carried the “-l” and “–color=auto” option, therefore avoiding the others to specify them as well. The definition of the lx alias uses the lh alias, which additionally carries the “-h” option. You should be careful when using this approach, because creating two many connections between aliases can make management more complicated instead of simplifying it and also create some unwanted side effects.

 Supplying (additional) arguments

Similar to applying additional command line options, you can supply additional arguments to

Delete An Alias

To delete an alias you need to use the unalias command:

unalias <name>

It is also possible to delete several aliases at once:

unalias <name1> <name2> ...

Example

To delete the www alias that we just created, type:

unalias www

you will be surprised that if offers you the possibility to change the time the system has to be idle for the monitor to be turned off from 1 minute to 1 hour. But what is missing is an option to turn this function off entirely.

Fortunately, it is possible to do that, just not in System Settings and you can either do that from command line or with a GUI.

Explanation

I will not explain GSettings here, but just in case you don’t know: GSettings (which replaces GConf) is used to store the configuration of the GNOME desktops. Don’t worry, you don’t need to know GSettings to follow the instructions below. But GSettings is also used to store the information about when to turn off the display. The keys that are important here are the following:

org.gnome.settings-daemon.plugins.power sleep-display-ac
org.gnome.settings-daemon.plugins.power sleep-display-battery
org.gnome.desktop.session idle-delay

Those are the keys that the System Settings GUI is changing when you use it.

The first two determine when the display is turned off (on a desktop system that is always plugged in the first value is the important one. The second key is used in case the system is running on a battery, which is important for portable devices like notebooks and tablets).

The third key is important, because it is used to determine when to start the screensaver and lock the screen, although there are additional values that target those two in org.gnome.desktop.session.

The values of all three keys are in seconds (so a value of 600 stands for 600s = 10min).

But because the System Settings GUI does change these three keys altogether and there is a connection between these three, it is probably a good idea for most people to change all three to the same value by hand as well.

Using Command Line

You can use the gsettings command to change the values of the keys.

First, let’s see what the values of these keys are. You can do that by running the following three commands.

gsettings get org.gnome.settings-daemon.plugins.power sleep-display-ac
gsettings get org.gnome.settings-daemon.plugins.power sleep-display-battery
gsettings get org.gnome.desktop.session idle-delay

Each command will print the value of the given key. You will notice (most likely) that all three values are equal and that they reflect the value that is displayed in System Settings. If you change the value in System Settings, you will notice that these three keys do change accordingly.

To set these by hand you can use the following three commands:

gsettings set org.gnome.settings-daemon.plugins.power sleep-display-ac <value>
gsettings set org.gnome.settings-daemon.plugins.power sleep-display-battery <value>
gsettings set org.gnome.desktop.session idle-delay <value>

Just replace <value> with the number of seconds you want the system to wait before turning off the display (and potentially locking the screen). To tell the system that it should let the display turned on forever, you can use the value 0:

gsettings set org.gnome.settings-daemon.plugins.power sleep-display-ac 0
gsettings set org.gnome.settings-daemon.plugins.power sleep-display-battery 0
gsettings set org.gnome.desktop.session idle-delay 0

Using A GUI

To change the keys you can use “dconf Editor “. You can start the program by one of the following ways:

• go to Applications and either
• search for dconf or
• look for it under “System Tools” or
• press Alt+F2 and enter: dconf-editor or
• open a terminal and run “dconf-editor”

Once dconf Editor starts, you will see the following window:

The dconf-editor window after starting the I

On the left side you now need to navigate to “org.gnome.settings-daemon.plugins.power” (that means: open “org”, then – within “org” – open “gnome” and so on until you reach “power”). Then, you need to find the keys “sleep-display-ac” and “sleep-display-battery” on the right side:

The dconf-edtior window after navigating to the first key

Change both numbers to 0 to prevent the system from turning off the display.

After that you should navigate to “org.gnome.desktop.session” on the left side and change the key “idle-delay” (on the right side) to 0 as well.

After that, just quit the editor (the changes are automatically saved).

When using a virtual machine in VirtualBox you might want to switch to a different console by hitting

where <n> stands for the number of the console you want to access (like Ctrl+Alt+F1 to get a text console and Ctrl+Alt+F7 to get back to your X session).

Unfortunately, key combinations with Ctrl+Alt like the mentioned Ctrl+Alt+F<n> or Ctrl+Alt+Del will not be sent to the guest operating system. Instead, Ctrl+Alt+F<n> will only let you change consoles on your host and Ctrl+Alt+Del will magically disappear and effect neither the host nor the guest OS.

VirtualBox offers two menu entries (under the menu entry “Machine”) to send Ctrl+Alt+Del and Ctrl+Alt+Backspace to the guest OS, but does not offer such a feature for other key combinations.

Solution

Fortunately, you can use the host key (the right Ctrl key by default) as a substitute for Ctrl+Alt. Therefore when pressing

HOST+F<n>

VirtualBox will send

to the guest OS and this will let you change consoles in your guest and also use other key combination that include Ctrl+Alt.

Links

https://www.virtualbox.org/manual/ch01.html#idp7685232

There are several ways one can batch rename files in Linux. One of the possibilities is the linux command rename.

Usage

To rename files you have to supply a Perl expression. Using Perl expressions might be scary for beginners (because they look like someone hit his head on the keyboard), but they allow for complex renaming with a minimum of characters.

Although I won’t go into detail about Perl expressions here, I will try to make it a little easier for beginners to use them for batch renaming.

According to the man page of rename, this is the way to use rename:

rename [ -v ] [ -n ] [ -f ] perlexpr [ files ]

If you have not worked with Perl expressions before, this might not be enough to get you started. So let me present you with the way one would probably use rename most of the time:

rename 's/OLD/NEW/' FILES

OLD is an expressions which describes a pattern in the name filenames. If rename can find this pattern in the name of a file, it will replace this part of the filename with what is defined as NEW. The files rename should rename are defined by FILES.

Let me provide you with two examples:

Examples

Example 1 – Replacing a single word/string

Let’s start with a very simple example: Imagine, you have a lot of images that are named

picture 1.jpg
picture 2.jpg
...

and you would like to replace the word “picture” with the word “image”, so that the files will be named like this:

image 1.jpg
image 2.jpg
...

As describes under usage, OLD represents the part that we want to replace. As we want  to replace the word “picture”, in this example OLD will be “picture”.

And because NEW defines with what OLD is replaced with, in our example. We want the OLD(=”picture”) to be replaced with “image”, so here NEW=”image”.

And because we want to do this only for all the pictures which name starts with “picture” FILES will be “picture*.jpg”.

Therefore the general command

rename 's/OLD/NEW/' FILES

becomes:

rename 's/picture/image/' picture*.jpg

It might have not been necessary for us to restrict this to the the files “picture*.jpg”. We might have just used *.jpg (all files in the current directory with the extension .jpg) or even * (all files in the current directory), because rename will only change the filename, if the pattern OLD (here: “picture”) is found in the filename. You have to be careful, though. A file with the name “just a picture.jpg” would have been renamed to “just a image.jpg”, because we told rename to replace “picture” with “image”.

Example 2

Let’s go back to Example 1. One problem I mentioned is that running

rename 's/picture/image' *.jpg

to rename files like “picture 23.jpg” to “image 23.jpg” would also rename files like “just a picture.jpg” to “just a image.jpg”, because rename would find the word “picture” and replace it with “image”, although this is not what we intended.

We could prevent this by calling rename like this:

rename 's/picture/image' picture*.jpg

This would call rename only for the .jpg files starting with the word “picture”. But this is not really a solution, because files like “picture of a sunset.jpg” would still be renamed to “image of a sunset.jpg”.

To make sure that rename really does what we want it to do, we need to be very clear about what should be renamed. Because what we want is not to replace the word “picture” with the word “image” in every case, we want to replace the word “picture” with the word “image”, but only for the files which name consists of the word “picture”, then a space and then a number and then the extension “.jpg”.

This can be achieved with the following command:

rename 's/^picture( [0-9]*\.jpg)$/image$1/' *.jpg

This might look a little scary, but is a good example of what you can do with Perl expressions. Because this would only rename the desired files. Files like “my picture 11.jpg” or “picture 28 (beach).jpg” would not be renamed and in this example that is exactly what we want to do.

Let me go through the different parts of the expression above briefly, to give you an idea of how this works. Keep in mind that this just an example and not intended as a complete tutorial. I will just try to explain to you the various elements of this expression to show you some of the possibilities and to demystify them a little bit.

When you compare the command to the general form under “Usage”, you will see that in this case:

• OLD = ^picture( [0-9]*\.jpg)$
• NEW = image$1
• FILES = *.jpg

In this example OLD makes sure that only the desired files are renamed by defining the structure of what we are looking for exactly. This works, because OLD defines what should be renamed. That means that files where the pattern/structure defined by OLD can not be found will not be renamed. Therefore, OLD automatically works as a filter to make sure that only the desired files get renamed. The trick is to make sure that OLD and NEW reflect what you wish to do. Let’s dissect it:

Let’s ignore the “^” at the beginning, the “$” at the end, the parentheses and the “\”  at the moment. This leaves the following:

picture [0-9]*.jpg

This describes our basic structure. First, we have the word “picture”, then a space. [0-9] means any character from 0 to 9, which essentially means “a digit” and when putting a “*” after it, it means that there can be “any number of” digits. We need this, because we don’t know how many digits there will be. We can have files like “picture 7.jpg”, where there is only 1 digit or files like “picture 1432.jpg”, where he have four of them. So, “[0-9]*” stands for “any number of digits”, which just means: a number. And then we have “.jpg”, our extensions.

It is important to note that  “[0-9]*” really means “any number of digits” and that “any number” could also mean 0. This means that the number is optional and a file named “picture .jpg” would also be renamed. In this example it probably would not make a real difference, but in general you need to be careful. If there really has to be a number and it can not be optional, you can use a “+” instead of a “*”, because “[0-9]+” means “at least one digit”.  But because it will not be a problem in this case, we will keep the “*”.

Now, let’s add the parts we ignored:

The “.” is a special character which stand for “any character”. But in our pattern, we want to make clear that the filename ends with “.jpg”. But “.jpg” would be interpreted as “any character, then j, then p, then g”. Therefore a file like “picture 234Xjpg” would be renamed, because the . (which stand for “any character”) would be “X” in this case. But really want to make sure that the file ends with “.jpg” and therefore need to make it clear that the “.” really stand for “.” and not for “any character”. This can be done by escaping it with a “\”. Therefore, we need to write “\.jpg”.

The parentheses are added, because the pattern we are creating will be matching the complete filename. If we would run a command like this:

rename 's/^picture [0-9]*\ .jpg$/image/' *.jpg

A file like “picture 23.jgp” would be renamed to “image” and not to “image 23.jpg”. This is because our pattern “^picture [0-9]*\.jpg$” describes the whole filename. So the complete filename would be replace with “image”. But we just want to replace “picture” and keep the rest.

We can do this by telling rename that we want to keep everything after “picture”. While we can’t do this directly, we can put every after “picture” in parentheses and then later use this part to build our new filename, because everything within the parentheses will be saved accessible later as “$1″, so if we use the pattern

picture( [0-9]*\.jpg)

We can now see that the space, the number and the extension “.jpg” are within the parentheses and we can access this part as “$1″. When the filename is “picture 83.jpg”, $1 will therefore contain ” 83.jpg”. Then, when we define our replacement, we can tell rename to use “image$1″ as our replacement for the filename. Because $1 contains the space, the number and the extension, this would translate to “image 83.jpg”.

Now, what’s left are “^” and “$”. “^” stand for the beginning of the filename. This makes sure that files like “some picture 44.jpg” would not be renamed. This is because a pattern like “picture” means: find the word picture anywhere. Whereas “^picture” essentially means: find the word picture at the beginning of the input(=filename).

Similarly, “$” stand for the end of the input (here: filename). We use this to make sure that something like “picture 74.jpg.gz” does not get renamed.

Combining “^” and “$” therefore ensures that the filename only consists of the pattern we defined and there is nothing before “picture” and nothing after our “.jpg”.

Therefore, our final pattern is:

^picture( [0-9]*\.jpg)$

And the command to rename the files is, again:

rename 's/^picture [0-9]*\ .jpg$/image/' *.jpg

Example 4 – add a prefix to all filenames (added on 2012-05-20)

In case you want to add a prefix at the beginning of a filename, you can use this line:

rename ‘s/(.*)/PREFIX$1/’ FILES

Substitute PREFIX to whatever you want to put in front of the filename and substitute FILES for the files you want to rename (see Example 6 below for some examples)

If you run

rename ‘s/(.*)/foo_$1/’ *.txt

All the .txt files in the current directory will get an “foo_” in front of of their name. (So info.txt would be renamed to foo_info.txt, for example)

Example 5 – add a suffix to all filenames (added on 2012-05-20)

Adding a suffix at the end of a filename can be as simple as adding a prefix; you could simply run:

rename 's/(.*)/$1SUFFIX/' FILES

The problem is that this might not be what you expected, because the suffix will be added at the end of the filename, which also means after the suffix the file might already have to denote its type (e.g. “.txt”, “.tar”, “.jpg” etc. Running

rename 's/(.*)/$1boo/' info.tar

would rename the file “info.tar” to “info.tar.boo”. If that is what you want, you can use the line above, but if you would want to rename it to “infoboo.tar”, then you can use the following line:

rename 's/(.*)\.(.*)/$1SUFFIX.$2/' FILES

with this, running

rename 's/(.*)\.(.*)/$1boo.$2/' FILES

would rename “info.tar” to “infoboo.tar”.

Be aware that this will not work for files with suffixes that contain two dots (like “archive.tar.gz”).

Improvement 1 (Update 2012-05-22):

The fact that files like “archive.tar.gz” would be renamed as well and the result would certainly not be as hoped, we can try to improve the pattern above a little bit:

rename 's/^([^.]*)\.([^.]*)$/$1SUFFIX.$2/' FILES

This approach will only rename files that only contain a single dot and leave all other files alone.

Improvement 2 (Update 2012-05-22):

If you want to rename files with extensions like “.tar.gz” correctly, you can use the following approach:

rename 's/^([^.]*)\.(.*)$/$1SUFFIX.$2/' FILES

This will essentially add the suffix directly in front of the first dot. However, this approach will not work in case you have files that contain dots that are not supposed to be part of the file extension (in “some.great.file.txt”, the suffix “111″ would be added like this: “some111.great.file.txt”)

Example 6 – how to define which files to rename (added on 2012-05-20)

In the beginning I noted the general form of how to use rename:

rename 's/OLD/NEW/' FILES

I now want to give you some simple examples of what you can do with “FILES”, which tells rename which files it
should try to rename in the first place. This list is by no means complete. It just provides you with a few (hopefully useful) examples.

• to rename a single file just state its name. Example: backup.tar
• to rename several specific files just list all their names. Example: backup.tar mypicture.jpg asong.ogg
• to rename all files in the current directory just use “*” (without the “).
• to rename all files with a specific ending (e.g. .jpg) use “*ENDING”. Example: *.jpg
• to rename files with different endings, just list them all. Example: *.jpg *.jpeg *.mp3 *.txt *.ar
• to rename files that start with the same word/characters use “START*”. Example: my* old*
• to rename files that contain the same word/sequence of characters use “*WITHIN*”. Example: *good*
• you can combine all of those things. Example: my*.txt *boo*.jpg foo* test.tmp

Conclusion

I hope that this article succeeds in demonstrating how rename can be used to batch rename files (not in detail, but at least in pushing you in the right direction). And I also hope that while covering Perl expressions in detail is beyond the scope of this article, the second example gives you an idea of how powerful and useful they can be and why it can make sense to learn more about them.

Basic Usage

Creating directories in the current working directory

The most basic usage of mkdir is the following:

mkdir <name>

This will create a new directory with the given name in the current directory. Therefore, if your username is “me” and in the terminal you are using you are currently in your home folder (/home/me) then running the command

mkdir backup

will create a the directory /home/me/backup.

Creating directories using relative or absolute paths

You do not need to be in a directory do create a new directory in it. You can, for example, use relative or absolute  paths to create them.

Let’s assume you are in your home folder (/home/me) and you just created the folder backup (/home/me/backup). And now you want to create a folder named “old” in it. Then you can either call mkdir with a relative path:

mkdir backup/old

or with the absolute path:

mkdir /home/me/backup/old

Note, however, that if you would call

mkdir backup/old

and the directory “backup” would not exist already in the current folder, then you would get an error.  This is, because calling mkdir like this:

mkdir <path>/<name>

will create the directory <name> in the directory <path> only if <path> already exists. Otherwise, mkdir will quit with an error message. This is the default behavior of mkdir.

Options

There are a few options which can be quite useful when creating directories.

-p, –parents

Under “Basic Usage”, I mentioned that the path you want to create a new directory in, needs to exists or otherwise you will get an error. You can use the option “-p” or “–parents” to change that behavior. With this option, mkdir will create all the directories that don’t exists already, not just the last one. If you would call

mkdir -p backup/old

or

mkdir --parents backup/old

in your home directory and the directory “backup” would not exist already, then the -p options will tell mkdir to create this directory as well instead of quitting with an error message. This option is therefore very useful if you need to create a directory, but you are not sure if the directory you want to create it in already exists. Even if you know that this directory does not exist yet, you can use the -p option to reduce the number of necessary calls.

If you know that there currently is no backup (or are not sure) and you want to create the folder backup/old, then calling

mkdir backup/old

could result in an error if the directory “backup” would not exist. This is a problem especially in scripts. Without the -p option you would have to make two calls to mkdir; one to create the “backup” directory (to ensure it is there) and one to create the directory “old” itself:

mkdir backup
mkdir old

When creating deeper directory structures, more than two calls might be needed. Think about creating the folder “backup/server/2011/11/30″ in your home folder (/home/me). You would have to create every folder separately:

mkdir backup
mkdir backup/server
mkdir backup/server/2011
mkdir backup/server/2011/11
mkdir backup/server/2011/11/30

With the -p option you just need to call mkdir once:

mkdir -p backup/server/2011/11/30

and everything will be created for you.

It is also worth noting that using the “-p” option will prevent errors in case the directory already exists. Without the “-p” option, running

mkdir backup

would result in the following error message in case the directory backup already exists:

mkdir: cannot create directory `backup': File exists

However, running

mkdir -p backup

will prevent the error message from being printed. Running mkdir with the  “-p” can therefore be interpreted as “make sure the following directory exists”.

-v, –verbose

When using the “-v”/”–verbose” option, mkdir will ouput a message for the directory  it created.

Calling

mkdir backup

will therefore either output

mkdir: created directory `backup'

if the directory did not exist already or print the previously mentioned error message in case the directory was already there. When combining the “-v” option” with the “-p” option, mkdir will output a message for every directory it created.

Typing

mkdir -p -v backup/server/2011/11/30

or even shorter

mkdir -pv backup/server/2011/11/30

would create the following output if none of the directories would already exist:

mkdir: created directory `backup'
mkdir: created directory `backup/server'
mkdir: created directory `backup/server/2011'
mkdir: created directory `backup/server/2011/11'
mkdir: created directory `backup/server/2011/11/30'

If, for example, the directory “backup/server” already existed, then mkdir would only need to create the last three directories and therefore the output would be:

mkdir: created directory `backup/server/2011'
mkdir: created directory `backup/server/2011/11'
mkdir: created directory `backup/server/2011/11/30'

Using this option therefore provides feedback about which directories already existed and which had to be created. Because the “-p” option suppresses error messages about already existing directories, you won’t get error messages about the fact that “backup” and “backup/server” could not be created, because they were already there. The messages from mkdir about which directories have been created would therefore only implicitly tell you which directories existed beforehand.

-m, –mode=MODE

Using the “-m” option you can set the permission on the directory you want to create. If you want to create a directory which should be  fully accessible by everyone, you could type

mkdir -m 777 backup

or

mkdir -m a=rwx backup

It is important to note that when combining this option with the “-p” option, the mode only affects the last directory. Calling

mkdir -p -m 777 backup/server/2011/11/30

would therefore create all the directories necessary, but the permissions specified with the “-m” option will be only assigned to the directory “30″ and not to the other directories. Their permissions are instead determined by the current umask.

It is also worthy to note that the permissions of the directory “30″ would not be changed in case it already existed. This is especially important to point out, because the “-p” option will prevent all error messages about already existing directories. Therefore, running this command does not give you any feedback about the permissions the directory “30″ has after running the command. If it already existed, the permissions will be left untouched and if it didn’t exist, the permissions will be set as defined by the “-m” option.

Therefore, if you are not sure if the directory already existed, but want to make sure that the permissions are set correctly, you could either run the command with the -v option (which will then tell you if the directory “30″ was created) and then use chmod if necessary or – if you are writing a script – you should just run chmod afterwards instead of using the “-m” option:

mkdir -p backup/server/2011/11/30
chmod 777 backup/server/2011/11/30

Although using additional programs (like GIMP, for example) would get the job done, you do not need them, because VirtualBox does offer screenshot functionality on the command line. And using the built-in function has two advantages:

• The screenshot will only include what is seen in the virtual machine and won’t include the VirtualBox window the machine is running in or even the whole Desktop, so there is no need to edit the screenshot.
• The screenshots can be made without user-interaction, which is nice if you need to create screenshots automatically with a script or a cron job (e.g. if you want to take a screenshot every 5 minutes – for whatever reason you might have – you could completely automate the task).

The command to take a screenshot generally looks like this:

VBoxManage controlvm <uuid> screenshotpng <file>

or like this

VBoxManage controlvm <name> screenshotpng <file>

depending on whether you want to use the UUID or the name of the virtual machine. The name for the virtual machine can be obtained directly from the VirtualBox Manager window or from the window of the running virtual machine:

Obtaining the name of a virtual machine

As you can see in the screenshot, the name of the virtual machine is “Debian Server 1″.

If we wanted to take a screenshot of the machine and save it as “server.png”, we could therefore use the following command:

VBoxManage controlvm "Debian Server 1" screenshotspng server.png

And this is what the screenshot would look like:

Screenshot of the virtual machine

Appendix: Using UUIDs

UUIDs vs Names

You might also want to think about using the UUID instead of the name of a virtual machine, depending on your situation. Both have their advantages and disadvantages, especially when working with scripts. I am not going to cover this topic in-depth, but let give you something to think about. The advantage of using UUIDs is that you can rename your virtual machines without having to edit the scripts which reference the, directly, because the UUID will stay the same. This is especially useful if you might want to migrate your virtual machine to a different host, because if the new host already has a virtual machine with the same name you have to rename one of them.

But now think of the following situation: You have a virtual machine named “server” that you want to migrate to a new host. And you wrote some scripts that somehow work with this VM by using it’s name. The new host already has a VM named “server”, which prevents importing the VM.  So you just rename the VM you want to migreate to “server2″ and add it, which works great, because there was no VM with the name “server2″ before.  But now your scripts, which reference a VM called “server”, suddenly work on the VM which was already there and not on the VM you migrated (which is now called “server2″) and for which the scripts were written. It’s very easy to forget to alter your scripts to reflect the name change after renaming a virtual machine. But an even bigger problem is: Because there still is a VM called “server”, you don’t even get an error message.

On the other side, two advantages of using the name of the virtual machine that I can think of, are the fact that the name is very easy to see and change in the VirtualBox GUI, so working with VM names in VirtualBox is easier. And if you use the command line,  typing a name is certainly easier and faster (depending on the names you use, of course) than typing the UUID.

Therefore, I personally prefer using the names when using the command line directly and using the UUIDs in scripts.

Getting the UUID

In case you want to get the UUID of a virtual machine, you can type the following:

VBoxManage showvminfo <name>

This will print a  lot of info, though. To just get the line with the UUID, you can type:

VBoxManage showvminfo <name> | grep ^UUID

In this example, you would type:

 VBoxManage showvminfo "Debian Server 1" | grep ^UUID

which  gives you something like this:

UUID:        e9e99378-3332-42f4-a6a3-d5490123fe33

And if you really just want the UUID, you might use the following:

VBoxManage showvminfo "Debian Server 1" | grep ^UUID | sed 's/UUID: *//'

to get an output like this:

9e99378-3332-42f4-a6a3-d5490123fe33

When converting FLAC files to MP3, the first problem you will notice is that lame does not support FLAC files. This might now seem like big problem, because you can easily decode FLAC files using the command line tool flac and then use the decoded file with lame.

The Problem

The real problem is that you will loose your metadata in this process, so the tags you added to your FLAC won’t be copied to the MP3 file. While you could “easily” add them by hand, it is pretty annoying to do that even if you only want to convert a handful of files.

The solution

The solution is to extract the metadata from the FLAC file using metaflac and to use the options lame provides to inject the tags into the MP3 file when calling lame.

Note:

This section is merely provided to explain the steps involved. You do not need to read this nor do you need to do this by hand, since I offer you a small script that will do these steps for you (look at the very first line of the article or below under “Download” to download the script).

Step 1 – Extract the Metadata

To extract a single tag, you can use metaflac like this:

metaflac --show-tag=<tag> <file>

To extract the artist of the track from the file named “1 – Let It In.flac”, you could call:

metaflac --show-tag=ARTIST "1 - Let It In.flac"

In general you will get a result like this:

<TAG>=<VALUE>

In the mentioned example you might get the following:

ARTIST=Josh Woodward

 Step 2 – Fomat the Metadata

We only need the name of the artist, so we need to get rid of  “ARTIST=”. This can be easily achieved with sed.  The general way of replacing something with sed is this:

sed 's/OLD/NEW/'

OLD is the part that you want to replace and NEW is the part that you want to replace it with. What we want to replace is “ARTIST=” (which is our OLD) and what we want to replace it with is nothing (which will essentially remove OLD), so our NEW is empty. And this is what we get:

sed 's/ARTIST=//'

But that would only work for the ARTIST tag. A general solution would be to remove anything up to and including the equal sign. I won’t go into detail on this one, but this would be achieved by setting OLD to “.*=” and the line would look like this:

sed 's/.*=//'

To make this work, we need to we need to pass the output of metaflac to our sed command, which we would do like this:

metaflac --show-tag=ARTIST "1 - Let It In.flac" | sed 's/.*=//'

This way the output of metaflac (“ARTIST=Josh Woodward”) is send to our sed command, which then removes the “ARTIST=” part and thus we get the output:

Josh Woodward

Step 3 – Store the tag

While the line from Step 2 works, it merely prints the tag. What we need to do is to store the tag somehow, so that we can use it again later for adding the tag to the MP3 file. To store the output of a command in a variable, you generally type:

<var>=`<command>`

(Those are not single quotes in this line, but backticks/grave accents) This will execute <command> and then store the output to the variable <var>.

In this example we could do this:

ARTIST=`metaflac –show-tag=ARTIST “1 – Let It In.flac” | sed ‘s/.*=//’`

This would execute out metaflac command and save the output (“Josh Woodward”) in the variable ARTIST.

We can test if everything worked by printing the value of ARTIST:

echo $ARTIST

which should now give us:

Josh Woodward

Step 4 – Passing the tags to lame

In general, calling lame (and using VBR mode) would work like this:

lame -V <oldfile> <mp3file>

If you want lame to save metadata to the mp3 file, you can use several options do to this. To continue our example, let’s assume we want to add the name of the artist (that we have stored in the variable ARTIST in the last step) to the new MP3 file. This can be done with the –ta option:

lame -V --ta "$ARTIST" <oldfile> <mp3file>

In a similar way, we can add other tags to the mp3 file as well. Here is a small table that shows you the options lame offers to add metadata, the name of the FLAC tag that theese options correspond to and what they mean.

Step 5 – Passing the FLAC to lame

We have not solved the original problem yet: you can not pass a flac file to lame. We could decode the FLAC to WAV and then pass the WAV file to lame, but we don’t need do really create a WAV file, because we can just decode the FLAC and pass the decoded data directly to lame. To do this, we need to call flac with two options:

• -d to tell it we want to decode a flac file
• -c, so that the decoded data is not written to a file, but to stdout

Then, we can tell lame that it should read the data from stdin instead of from a file, which can be done by providing a dash for the <oldfile> parameter. Now we can connect them both with a pipe and the decoded flac data will directly flow into our lame command:

flac -c -d <flacfile>| lame - <mp3file>

In our example, we would get something like this (which includes adding the ARTIST tag and a VBR quality of 6):

flac -c -d "1 - Let It In.flac" | lame -V 6 --ta "$ARTIST" - "1 - Let It In.mp3"

Now that the basic  steps involved are covered, we can let a script do the work.

The Script

I wrote a small script that converts a FLAC file to MP3 while preserving  the following tags (=all the tags listed in “Step 4″ above):

• Track Title
• Track Artist
• Album Title
• Year
• Comment
• Tracknumber
• Total number of tracks
• Genre

Download

You can download the script here: flac2mp3.sh

Usage

The script takes three arguments:

• The VBR quality (This corresponds to the -V option of lame, which means that you can use a number between 0 and 9, with smaller numbers meaning higher quality and bigger files). If you omit this option, -V 4 will be used.
• The filename of the FLAC file you want to convert
• The filename of the new MP3 file that you want to create.
• You can (but don’t have to) add “mtime” as the fourth argument in which case the script will not start the conversion if the MP3 file is newer than the FLAC file, which indicates that a conversion is not necessary. (If you don’t add “mtime”, the script will convert the files no matter what)

Example:

If you want to convert the file “1 – Let It In.flac” to “1 – Let It In.mp3″ with a VBR quality level of 3, you would call the script like this:

flac2mp3.sh 3 "1 - Let It In.flac" "1 - Let It In.mp3"

flac2mp3.sh 3 "1 - Let It In.flac" "1 - Let It In.mp3" mtime

Source

The script generally works as described under “The Solution”, but instead of repeating the line from “Step 3″ for every tag, it uses a more elegant approach (which in this case just means less code). But instead of posting the complete source code (which you can look at by download the script), let me just show you  the meat of the script (extracting the 8 tags and passing them to lame for conversion):

for tag in TITLE ARTIST ALBUM DATE COMMENT TRACKNUMBER TRACKTOTAL GENRE; do
    eval "$tag=\"`metaflac --show-tag=$tag "$FLAC" | sed 's/.*=//'`\""
done

flac -cd "$FLAC" | lame -V "$V" --tt "$TITLE" --ta "$ARTIST" --tl "$ALBUM" --ty "$DATE" --tc "$COMMENT" --tn "$TRACKNUMBER/$TRACKTOTAL" --tg "$GENRE" - "$MP3"

Update (2012-06-05)

I have updated the script a little. It’s now possible to append a “mtime” after the three arguments. When adding “mtime”, the script will only start the conversion if the MP3 file does not exist yet or the FLAC file is newer than the MP3 file.

This will avoid unnecessary conversions in case the MP3 is newer than the FLAC file, which indicates it is up-to-date. This is useful when using this script to somehow manage your library as it will reduce a large number of conversions.

One of the possibilities of taking screenshots in Linux is using

, a utility of the X Window System.

I just want to give a short overview on how to take interactive and non-interactive screenshots, view them and convert them to different formats.

Taking Screenshots

To take a screenshot you could just open a terminal and type ”

“, but by default

does not save the screenshot to a file (it outputs the image to stdout). To save the screenshot in a file, you can either use the

option of

:

xwd -out <filename>

or redirect the output of

to a file using the functionality offered by the shell:

xwd > <filename>

Just replace

with the name of the file you want to use for your screenshot. Examples:

xwd -out myshot.xwd

or

xwd > myshot.xwd

Notice the changed mouse pointer after typing one of these commands ? That’s because you now need to select the window of which you want to take a screenshot. The format

uses for the images it is called “X Window Dump” and the extension often used is

. I will cover the subject of converting the images to different formats (like JPEG or PNG) later.

Including the Window Frame

If you want to include the frame of the window in the screenshot, you have to add the

option. For example:

xwd -frame -out myshot.xwd

or

xwd -frame > myshot.xwd

Taking Screenshots Of The Whole Desktop

If you want to create a screenshot of the whole desktop instead of a single window, you can use the

option for that:

xwd -root -out myshot.xwd

or

xwd -root > myshot.xwd

Automated Screenshots Without Selecting The Window

It’s also possible to create screenshots of windows without the need to select them every time. This is especially useful if you want to make numerous screenshots of a single window (e.g. for a tutorial, a presentation, an article etc.).

To do this, you have to tell xwd which window you want to take a screenshot of on the command line, so that it does not have to ask. You can do this either by using the “resource id” of the window or the ”

property”. The value of the

property basically is the title of your window as it is displayed in the window title bar. Using this to create screenshots can be problematic (With Firefox, for example, this value depends on the title of the active tab, so going to a different tab will change the

property of the window).

To determine the resource id or the value of the

property, you can use the

tool. Just type this in the terminal:

xwininfo

And then, similar to

, click on the window you are interested in. It will then display a bunch of information about the window, which might look like this:

xwininfo: Window id: 0x40000e7 "Home of the Mozilla Project - Mozilla Firefox"

  Absolute upper-left X:  1287
  Absolute upper-left Y:  70
  Relative upper-left X:  0
  Relative upper-left Y:  0
  Width: 1159
  Height: 1501
  Depth: 24
  Visual: 0x21
  Visual Class: TrueColor
  Border width: 0
  Class: InputOutput
  Colormap: 0x20 (installed)
  Bit Gravity State: NorthWestGravity
  Window Gravity State: NorthWestGravity
  Backing Store State: NotUseful
  Save Under State: no
  Map State: IsViewable
  Override Redirect State: no
  Corners:  +1287+70  -114+70  -114-29  +1287-29
  -geometry 1159x1501+1279-21

The red and blue color was something I added for clarification. The red thing is the resource ID we are interested in and the blue thing is the

property that we also could use.

If we wanted to use the resource ID, we would do it like this

xwd -id  -out myshot.xwd

If we want to use the WM_NAME property, we would do this:

xwd -name  -out myshot.xwd

One important thing to note about this approach is that using the -frame option for xwd does not have any effect if you supply the id or name as well. That is, because the resource id for both cases is different. Therefore, if you want to include the window frame, you have to supply the

option to

to retrieve the correct resource id. You would then type:

xwininfo -frame

Just to show you that they really differ: In my case, right now, running

xwininfo

gives me:

xwininfo: Window id: 0x40000e7 "Home of the Mozilla Project - Mozilla Firefox"

while running

xwininfo -frame

and clicking on the same, unchanged window, gives me:

xwininfo: Window id: 0xe002df (has no name).

Viewing Screenshots

You can view the

-screenshots directly with the tool

. Just type:

xwud <filename>

for example:

xwud screenshot.xwd

Converting and Editing Screenshots

Converting Screenshots

You can easily convert the screenshots to “normal” image formats like JPEG or PNG with tools like ImageMagick. If you don’t have ImageMagick installed, it should be available through your repositories. For example, in Ubuntu/Debian you would simply type:

sudo aptitude install imagemagick

or

sudo apt-get install imagemagick

Once you have ImageMagick installed, you can convert an

image by using

. For example, to convert an

-screenshot named

to a JPEG file named

, type:

convert shot.xwd shot.jpg

You can convert the image to other formats as well, like PNG for example:

convert sot.xwd shot.png

Editing Screenshots

I won’t include a tutorial on editing screenshots here, but I just wanted to mention that you might not have to convert your screenshots to JPG or PNG (or something else) in order to edit them, because your image editor might already be able to load

files. GIMP, for example, can open them directly.

Problem

When using oggenc to convert a FLAC file to OGG Vorbis using oggenc, you might encounter the following error:

"ERROR: Input file <file> is not a supported format"

Explanation

One possible reason for this can be an ID3 tag in the flac file. This can happen if the program you used to create your FLAC files uses ID3 tags instead of native FLAC tags to store metadata.

You can confirm this by typing the following:

flac --ogg enc <file>

which would then output something like this:

ERROR: input file <file> has an ID3v2 tag

If this is the problem you are having, then the following should help you

Bad “Solutions”

The “solutions” I found on the web have drawbacks that I could not accept.

The first “solution” is to just rip the CD again with a different software or different options. This is annoying, because you need to go through the whole process again and ripping a CD can take a long time, depending on how you do it.

Another “solution” is to convert your FLACs to WAV files and then either to OGG or back to FLAC (to get “repaired” FLACs you can now use with oggenc). The drawback of this approach is that all the metadata gets lost during the conversion from FLAC to WAV, because WAV files can not hold metadata.

I am using quotes (“solution”) to make clear that I don’t really consider them solutions to the problem, because the amount of work that would be required makes them practically useless for large collections.

Solution

The “only” problem with the second “solution” is the lost metadata. Other than that the solution works fine. Fortunately it is possible to solve the problem by using a command line tool that is already installed with flac, but that most people don’t seem to know about: metaflac.

Metaflac can extract metadata from a FLAC file and add metadata to a FLAC file as well. Therefore, all we need to do is:

1. extract the metadata using metaflac
2. decode the FLAC to a WAV file
3. encode the WAV file back to FLAC
4. import the metadata using metaflac into the new FLAC file

Using a script to “repair” the FLACs

Because this is pretty annoying by hand, I wrote a script named “reflac”. You can either use the script in a terminal or “integrate” it with Nautilus.

Downloading the script

You can download the script here: reflac.sh

Using the script from the command line

The script can be used like this:

reflac.sh <flac file>...

Example 1:

refla.shc foo.flac bar.flac

Example 2:

reflac.sh *.flac

It just goes through the four steps for every file you throw at it.

Adding the script to Nautilus

If you don’t like the terminal that much, you can also use the script directly from Nautilus. Just copy the script to the folder ~/.gnome2/nautilus-scripts/ (To copy the script to this location from within Nautilus, download the script

Just as a disclaimer: This is a quick & dirty script I wrote and I don’t really see something in it that could go horribly wrong. Nevertheless, there is ALWAYS a risk when using software, so backing up your data is YOUR responsibility. And always keep in mind: “If it’s worth saving, it’s worth backing up!”.

Download

Download the script here: reflac.sh