Alan Ivey

I had previously written a post on one method of upgrading PHP from 5.1 to 5.2 on CentOS and Red Hat servers by creating new RPMs. Since then, I have found a much better way to create PHP 5.2.17 (or newer) RPMs to easily upgrade (and later remove, if you want) the older version available by default. I'll presume you have no prior experience building PHP RPMs.

We start by adding the Extra Packages for Enterprise Linux (EPEL) repository to our server. EPEL is safe to add as an additional repository and leave enabled because it provides complementary packages only and will not conflict with the CentOS or Red Hat repositories. Since their installation method may change, I won't reproduce it here; instead head over to the installation portion of the FAQ and it's just one line to get started with EPEL.

With EPEL enabled, we will need just one new package to build RPMs: Mock. Mock will create a chroot, download what's necessary to build your RPM, build, and cleanup afterwards. Mock only requires a couple of python packages as dependencies; it will not require a compiler or anything like that since mock will grab them as needed during operation. I will presume you are not running as root so I will use sudo as necessary. To install mock:

$ sudo yum install mock

That's it. You can run all mock operations with the 'sudo' command to run as root, but your packages will be built inside the chroot as a non-root user. Or, if you prefer to not use sudo when running mock, add your user to the mock group (where username is your user):

$ sudo /usr/sbin/usermod -G mock username

Using the source code from php.net and creating a RPM spec file from scratch would be a lot of work, so we'll grab a source RPM for PHP 5.2. I've found that Remi has the most up-to-date RPM spec with the latest patches and robust install scripts. Browse Remi's SRPMS and download the latest PHP 5.2 file. As of this writing, it's php-5.2.17-1.remi.src.rpm. On your system, download it with wget in your home directory:

$ cd ~
$ wget http://rpms.famillecollet.com/SRPMS/php-5.2.17-1.remi.src.rpm

Now, we could just run mock and rebuild this source RPM and hopefully install the results, but it would fail due to not having sqlite2-devel installed. Remi provides sqlite2 and sqlite2-devel, so you could add Remi's yum repository to your mock settings, but then it would grab Remi's other updated packages like MySQL 5.5 and others during the PHP build. My goal here is to only build PHP against Base CentOS and EPEL packages. So, we have to edit the spec file and rebuild the source RPM before passing it off to mock. Don't worry; while there are a few steps, it's not very difficult if you follow closely.

To unpack the source RPM we just downloaded into our home directory, we'll need to set up the .rpmmacros file in our home directory. Why? Without it, it will attempt to extract to /usr/src/redhat, and only root can use that directory, and you should never build any packages as a privileged user. We'll create the macros file and the directories it needs from your home directory:

$ cd ~
$ echo '%_topdir %(echo $HOME)/rpmbuild' > ~/.rpmmacros
$ mkdir -p ~/rpmbuild/{SOURCES,SPECS,SRPMS}

Unpack the source RPM. This will extract the PHP 5.2.17 source and any patches and configuration files into ~/rpmbuild/SOURCES, and the spec file will be in ~/rpmbuild/SPECS:

$ rpm -ivh php-5.2.17-1.remi.src.rpm

Now we need to make a couple of changes to the spec file. We'll change to the SPECS directory and make a copy of Remi's spec file so we can keep it for reference:

$ cd ~/rpmbuild/SPECS
$ cp -a php52.spec php.spec

Open up php.spec in your favorite text editor and let's have the PHP configure script use the bundled SQLite2 libraries instead of searching for ones on your system:

1. Find the line "BuildRequires: sqlite2-devel >= 2.8.0" and delete it
2. Find "--with-sqlite=shared,%{_prefix} \" and replace it with "--with-sqlite=shared \"
3. Optionally: Add your own lines to the %changelog describing that you removed the sqlite2-devel build requirement
4. Optionally: Remove the first 4 lines after "%pre common" to remove Remi's note about their forums

It took 2 small tweaks to remove the sqlite2-devel RPM requirement not found in our standard repositories. See php.spec.diff to see only the changes we made; or php.spec for the complete file if you do not want to edit it yourself.

The hard part is now over! It's easy from here on out. First step is to build the newly-edited spec into your own source RPM. But first, if you don't have "rpmbuild" available, it's a quick install via yum:

$ sudo yum install rpm-build

It's possible your system may have already had the yum package rpm-build installed. We'll build our source RPM with "-bs" to build the source, and "--nodeps" to prevent our system from checking all of the "Requires" in the spec since we're just building the source:

$ rpmbuild --nodeps -bs php.spec
Wrote: /home/username/rpmbuild/SRPMS/php-5.2.17-1.src.rpm

rpmbuild will show you where it wrote your source RPM. All we have to do is provide it to mock; "-v" will give us verbose output and "-r epel-5-x86_64" will use the mock profile at "/etc/mock/epel-5-x86_64.cfg". If you're on a 32-bit system, change "epel-5-x86_64" to "epel-5-i386":

$ cd ~/rpmbuild/SRPMS
$ mock -v -r epel-5-x86_64 php-5.2.17-1.src.rpm

The output shows you that mock is creating a chroot, downloading the bare essentials needed for a chroot and compiling tools, ccache to speed up compilation, and the packages in all "Requires" lines in the spec file. When mock is finished with the build after several minutes, you'll see output similar to:

INFO: Done(php-5.2.17-1.src.rpm) Config(epel-5-x86_64) 10 minutes 20 seconds
INFO: Results and/or logs in: /var/lib/mock/epel-5-x86_64/result

The /var/lib/mock/epel-5-x86_64/results/ folder will contain all of your PHP RPMs, including another source RPM. You can now either install these PHP packages by hand, or you can dump them into your own Yum repository and install with yum. 

TL;DR

$ sudo yum install mock
$ sudo /usr/sbin/usermod -G mock username
$ cd ~
$ wget http://rpms.famillecollet.com/SRPMS/php-5.2.17-1.remi.src.rpm
$ echo '%_topdir %(echo $HOME)/rpmbuild' > ~/.rpmmacros
$ mkdir -p ~/rpmbuild/{SOURCES,SPECS,SRPMS}
$ rpm -ivh php-5.2.17-1.remi.src.rpm
$ cd ~/rpmbuild/SPECS
$ cp -a php52.spec php.spec
$ sed -i "/BuildRequires\: sqlite2-devel/d" php.spec
$ sed -i "s/--with-sqlite=shared,%{_prefix}/--with-sqlite=shared/" php.spec
$ sudo yum install rpm-build
$ rpmbuild --nodeps -bs php.spec
$ cd ~/rpmbuild/SRPMS
$ mock -v -r epel-5-x86_64 php-5.2.17-1.src.rpm

Resulting RPMs will be in /var/lib/epel-5-x86_64/results. If on a 32-bit system, replace epel-5-x86_64 with epel-5-i386.

Permalink | Leave a comment  »

In addition to hosting Drupal sites, we also host a number of WordPress sites. Similar to checking all of our Drupal core versions, we needed an easy way to quickly see what versions we are running on all of our WordPress sites. Kudos to Ethan for getting this one kicked off; here is a bash script to check your definable $WEBHOME (where you deposit all of your WordPress webroots) and scan for WordPress versions.

Note: this requires bash, grep, wc, sed, awk, and tree. If your system doesn't have tree, it's usually pretty easy to get from EPEL/Homebrew/apt-get/[mac]ports/etc.

#!/bin/bash
 
# Where to start scanning
WEBHOME=/var/www/vhosts
 
# Workaround to fix awk counting below
WEBHOMECOUNT=$(($(echo "${WEBHOME}"|grep -o "/"|wc -l| sed s/\ //g)+2))
 
# Other projects could use 'version.php' so we include 
# 'wp-includes/' in our search to limit it to WordPress
for i in $(tree -L 5 -if ${WEBHOME} | grep 'wp-includes/version.php'); do
  SITE=$(echo $i|awk -v count="$WEBHOMECOUNT" -F/ '{for(j=count;j<=NF-2;j++) \
        printf $j"/"}' | sed 's/.$//g')
  VERSION=$(grep "wp_version = " $i|awk -F\' '{print $2}')
  echo $SITE - $VERSION
done

As a result, you'll see output like this:

$ ./wordpress-version-check.sh
speedyupdates.com - 3.0.4
littlebehind.org - 3.0.3
scaredtoupgrade.com/blog - 2.8.2
kickinitoldschool.org/web/wordpress - 2.0.2

If you think there's a better way, or have any questions, let me know in the comments.

Permalink | Leave a comment  »

At EchoDitto, we host a lot of Drupal sites. Just about all of our web servers contain more than one completely separate Drupal cores since we develop most of our websites independently. We also keep an eye out on Drupal Security and when to apply core updates. Since we're not using Aegir, nor do we run every site off of a single multi-site core install, we need a quick and easy way to see what versions we're running.

Here's a shell script we recently developed to report the Drupal Core versions for all of our sites under a single parent folder. It works on Drupal 4 through 7. It's not been tested outside of our platform, or non-RHEL systems, but it should be universal as long as you have bash, find, awk, and grep. I decided not to use Drush because it would involve bootstrapping every site and invoking PHP; this is just more lightweight. Drush also would not work for Drupal 4 sites, which we surprisingly still have a couple kicking around still.

#!/bin/bash
 
# Where to start looking
WEBHOME=/var/www/vhosts
 
# Workaround to fix awk counting below, but it works
WEBHOMECOUNT=$(($(echo "${WEBHOME}"|grep -o "/"|wc -l| sed s/\ //g)+2))
 
# Change maxdepth from 5 to some other value if your webroot is not being detected
for i in $(find $WEBHOME -maxdepth 5 -type f -name system.module); do 
  # Grabs only the version number from the file as described 
  # at http://drupal.org/handbook/version-info
  VERSION=$(grep "VERSION" ${i}|awk -F\' '{print $4}')
 
  # Drupal 4 has the system.module file in a lower directory than 5+
  if [[ $VERSION == 4* ]]; then
    SITE=$(echo $i|awk -v count="$WEBHOMECOUNT" -F/ '{for(j=count;j<=NF-2;j++) \
           printf $j"/"}' | sed 's/.$//g')
  else
    SITE=$(echo $i|awk -v count="$WEBHOMECOUNT" -F/ '{for(j=count;j<=NF-3;j++) \
           printf $j"/"}' | sed 's/.$//g')
    if [ -z $VERSION ]; then
      # Drupal 7 does not keep the version number on system.module, despite the 
      # drupal.org page. Grab from changelog (disabled b/c it includes extra info)
      #VERSION="$(sed '3q;d' ${WEBHOME}/${SITE}/CHANGELOG.txt)"
      # All versions of Drupal have the version of the module in system.info, 
      # so we grab it here for D7. The only reason I'm not using this for all 
      # versions is because of the aforementioned drupal.org page
      VERSION=$(grep "version = \"" ${WEBHOME}/${SITE}/modules/system/system.info \
                | awk -F\" '{print $2}')
    fi
  fi
  echo $SITE - $VERSION
done

As a result, you'll see the directory tree after $WEBHOME where the root of the site is and the version number. Below is an example:

$ ./drupal-version-check.sh
mysite.org/www - 5.22
thissite.net - 4.7.11
subfolder/drupalftw.com - 6.12
blah.org/trunk - 7.0

If you have suggestions, please send them over. This script is still young and I'd love to see if anyone has any better ideas.

Permalink | Leave a comment  »