With the tmp partition full, the server will experience many random issues such as server crashes. Your sites will quickly go down and leave you head-scratching.

Fortunately, it's quite easy to resize the /tmp partition on cPanel servers — especially if it is the default one created by cPanel installs. There's a handy script at /scripts/securetmp.

Open this file:

pico /scripts/securetmp


And find this line:

my $tmpdsksize = 512000; # Must be larger than 250000


Change it to a larger number than 512 MB. Say you want it to be 2 GB:

my $tmpdsksize = 2097152; # 2GB for the /tmp folder


Now close and save the file.

We need to stop all services that may be using this folder. For me, this includes MySQL, Apache and Nginx.

service mysql stop
service nginx stop
service httpd stop


Now we will simply unmount the /tmp folder and recreate it. Here's the sequence of commands to create it:

lsof /tmp
umount -l /tmp
umount -l /var/tmp
rm -fv /usr/tmpDSK
/scripts/securetmp


Done. You can verify the size of the /tmp folder among others:

df -h


This should show you something like this:

...
/usr/tmpDSK ext3 2.0G 996M 1.1G 51% /tmp
...


NOTE: If you have any problems, for instance, the size of the recreated /tmp folder is not really 2GB despite that code in the /scripts/securetmp we changed, it may be because of some settings you have in the /etc/fstab file. Take a look at it and comment out any lines that interfere with the LABEL for /tmp mount.

On Windows, there is the fantastic SSH2 tool SecureCRT. Or if you're cash crunched, a combination of Putty and Putty Connection Manager works for many.

On Mac OSX and Unix/Linux systems, one doesn't truly need an SSH client at all, because the "Terminal" application is inbuilt. People talk of iTerm and such, but I have still to see a value add for such tools.

But one does miss the convenience of SecureCRT on OSX, because I have still to find a true SecureCRT alternative for the Mac platform. Something that allows me to make pre-determined connections so I can just click on them to connect (which tools like JellyfiSSH do) and then logs me in directly without prompting for a password (which JellyfiSHH does not do).

So I have simply made aliases in my [code].profile[/code] file, which gets executed everytime you start your Terminal window (so it's a good place to put your shortcuts and any code you wish to execute when the terminal starts, such as paths).

1. Start the Terminal.
2. Open the profile file for the current user (you).

pico .profile

3. Enter a new line for our shortcut.

alias s='ssh -2 -p 22 user@host.com'

Quick explanation for that command in step 3. The letter "s" is the shortcut I make for connecting to the sniptools.com server. Change it to what you wish. This will mean that when I start Terminal, all I need to do is type "s" and it connects me via SSH to the sniptools.com server. The "-p" switch is an important one because some of us with paranoid security settings might have a different port number than the default port 22 for secure SSH. The rest user/host stuff is self-explanatory. The "-2" is to force SSH2 connections instead of older vanilla SSH.

Now. Save the profile file and source it to try it out:

source .profile

Sourcing is only for this one time, for your current Terminal window, which had already executed the profile file *before* we added this alias. When you start a new Terminal session, these aliases et al will be automatically set for you.

Done. Now your profile has the alias for "s". From now when you type "s" in your Terminal, it will connect, but it will ask you for a password. To get rid of the nagging password, we need to create public authentication key for the domain. This, in fact is what SecureCRT does behind the scenes on Windows too.

Here are the steps to accomplish this. Run these one-time commands in order from the Terminal window.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# generate pub and priv keys, leave the passphrase empty
# (simply press ENTER when asked for it)
ssh-keygen
 
#copy the pub key to the remote computer
#(change port number if different from the usual 22)
#change "user" to your user name
#change "host" to your domain name
scp -P 22 ~/.ssh/id_rsa.pub user@host:~/
 
#log on to the remote computer
ssh -p 22 user@host
 
#create the .ssh directory in the root login directory, if it doesn't already exist
mkdir .ssh
 
#append key to file
cat id_rsa.pub >> ~/.ssh/authorized_keys
 
#delete the public key file, no longer needed
rm -f id_rsa.pub
 
#log off the remote server
exit
 
#logon to the remote server, without password prompt
ssh -2 -p 22 user@host

That's it. This is a huge timesaver. Now all I need to do to login to the sniptools.com server is type one letter, "s" in the Terminal, and I'm on! Follow these instructions for each host you connect to on a regular basis and you'll love the convenience henceforth.

Yet, for all its merits and addictive features, PostgreSQL is a beast to upgrade between major version releases.

If you were going from 8.2.x to the latest stable at the time of this writing, 8.3.x, then the move from the 8.2 series to 8.3 would require you to dump/restore your entire database. Not a simple chore if you have a 100 GB worth of critical data, but you have no choice as the innards of PG typically change between "major upgrades". For this, replication technologies such as Slony are a useful option as you can install the new database separately, replicate the data over, and then make a switch when the two databases are mirrored — thereby avoiding the downtime of the hassle (here's an informative PGCON presentation).

Fortunately, minor version upgrades are much simpler.

No dump/restore is needed. If you were to go from, say 8.2.3 to 8.2.9, all you would have to do is to upgrade the RPMs. I'm assuming Linux here but the same would work for other platforms.

1. Check what version you have currently installed:

   rpm -qa | grep postgres | tee /root/rpm_pgsql

2. Stop your postgres server

   /sbin/service postgresql stop

3. We will now simply execute the RPM upgrade command, which of course assumes that you have the latest RPMs downloaded from the PG website. Notice below that they're all lumped into the same command to prevent any (unlikely) possibility of dependency issues, so make sure all of this appears on one line — the backslash is included here for formatting (so it won't break on the command line).

   rpm -Uvh 
     postgresql-8.2.9-1PGDG.rhel4.i386.rpm 
     postgresql-contrib-8.2.9-1PGDG.rhel4.i386.rpm 
     postgresql-devel-8.2.9-1PGDG.rhel4.i386.rpm 
     postgresql-libs-8.2.9-1PGDG.rhel4.i386.rpm 
     postgresql-server-8.2.9-1PGDG.rhel4.i386.rpm

4. Hopefully that went without a hitch. Now restart the postgresql server:

   service postgresql restart

That's it. That should do it. It is highly unlikely that you'll see errors. And if you're running an older 8.2.x, it's highly recommended you upgrade to 8.2.9 anyway due to performance increases and some bug fixes.

find {/path/to/folder/} -type f -size +{size-in-kb}k -exec ls -lh {} \; | awk '{ print $9 ": " $5 }'

Which lists the largest files in the folder /path/to/folder. You could just use the ls command too, as such:

ls -lhS

But there is a simpler, more efficient method to do this:

du -xak .|sort -n|tail -50

But the best method involves a small Perl hack that shows a very neatly laid out listing of largest files:

du -k | sort -n | perl -ne 'if ( /^(\d+)\s+(.*$)/){$l=log($1+.1);$m=int($l/log(1024)); printf  ("%6.1f\t%s\t%25s  %s\n",($1/(2**(10*$m))),(("K","M","G","T","P")[$m]),"*"x (1.5*$l),$2);}'