According to Gizmodo, the outage was on the Time Warner network, but sources at Rackspace indicate that Level 3 was particularly hard-hit.

Anyone else experience this issue of have ongoing problems?

Update: Time Warner’s twitter feed has more information on this problem, along with a slew of response tweets to affected customers:

Again, we’re recovering from a brief inet outage affecting most of our srvce areas.Pls attempt to connect again.Still down? DM us w/ yr info

In this post, I’ll demonstrate two different methods for adding more disk space to a Xen virtual machine. Unless otherwise indicated, all systems described here are running fully up-to-date versions of CentOS 5.6 (Final), and all Xen domU instances are using file based disk images.

When a file-backed virtual machine runs out of space, one way to gain additional space is to add a second file-backed virtual disk. Note that you could also add a physical disk, and the steps would largely be the same, but that is left as an exercise for the reader.

Create a new virtual disk

First, create a sparse file to use as the new disk image. In this case, we will create a new 10G image file. Note that creating a sparse file in this way will be very fast, but it will only actually use 1M of space on disk (as reported by df), so keep in mind that the actual usage can increase up to the total size of the file you are creating (here, 10G).

# cd /var/lib/xen/images
# dd if=/dev/zero of=new_disk.img oflag=direct bs=1M seek=10239 count=1

Add the Disk to the Virtual Machine

Once you have the new disk image created, you will need to add it to the virtual machine. First, modify the disk entry of the config file so that the disk is recognized when the virtual machine is restarted. In this case, the second entry is the one being added:

disk = [
    "tap:aio:/var/lib/xen/images/original.img,xvda,w",
    "tap:aio:/var/lib/xen/images/new_disk.img,xvdb,w"
]

Note: Be sure that you use a device name that is not already being used by the domain. In this case, only xvda was in use so using xvdb for the new disk device name is fine.

At this point, you can restart the virtual machine to have the disk recognized, but you can also dynamically add the new storage to the domU without restarting by using the xm utility and the block-attach sub-command (substitute the name of your domain in the following command):

# xm block-attach MyDomain tap:aio:/var/lib/xen/images/new_disk.img xvdb w

You can use the block-list sub-command to confirm that the device was added to the running virtual machine; prior to running xm block-attach, only one device would have been listed here:

# xm block-list MyDomain
Vdev  BE handle state evt-ch ring-ref BE-path
51712    0    0     4      6      8     /local/domain/0/backend/tap/3/51712  
51728    0    0     4      8      12    /local/domain/0/backend/tap/3/51728  

Once the domU knows about the new disk, you can configure it for use. Log into the virtual machine and use fdisk to create a new partition table. Here we create a single partition using the default type of 83 (Linux):

# fdisk /dev/xvdb
Device contains neither a valid DOS partition table, nor Sun, SGI or OSF disklabel
Building a new DOS disklabel. Changes will remain in memory only,
until you decide to write them. After that, of course, the previous
content won't be recoverable.


The number of cylinders for this disk is set to 1305.
There is nothing wrong with that, but this is larger than 1024,
and could in certain setups cause problems with:
1) software that runs at boot time (e.g., old versions of LILO)
2) booting and partitioning software from other OSs
   (e.g., DOS FDISK, OS/2 FDISK)
Warning: invalid flag 0x0000 of partition table 4 will be corrected by w(rite)

Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-1305, default 1): 
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-1305, default 1305): 
Using default value 1305

Command (m for help): p

Disk /dev/xvdb: 10.7 GB, 10737418240 bytes
255 heads, 63 sectors/track, 1305 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

    Device Boot      Start         End      Blocks   Id  System
/dev/xvdb1               1        1305    10482381   83  Linux

Command (m for help): w
The partition table has been altered!

Calling ioctl() to re-read partition table.
Syncing disks.
# 

Once the partition table is initialized, there are two paths you can take to add the new space to the virtual machine:

• Mount the new space as a traditional partition
• Incorporate the new space into an LVM group

In general, my preference is to add the space to an LVM group, but there are valid reasons for both methods so each is be presented here for completeness.

Mount the new partition traditionally

This is the best option if you need to create isolated space for a specific purpose, or if you do not have LVM available to you on the virtual machine. In either case, the first step is to create a filesystem on the new partition. Here, the standard ext3 format is used:

# mkfs.ext3 /dev/xvdb1

Next, a directory must be created to serve as the mount point for the new partition. I like to create mount points with permissions 000 to prevent data from accidentally being written to the directories when the partition is not mounted; any files living in the mount point will be hidden when the partition gets mounted, and making it non-writable, is a good way to help prevent that.

# mkdir -m 000 /extraspace

Create an entry for the new mount point in /etc/fstab (so that it is mounted on boot) and mount the partition. Make changes the the following mount options as needed for your system:

# echo "/dev/xvdb1 /extraspace ext3 defaults 1 3" >> /etc/fstab
# mount /extraspace

Finally, use df to confirm that the new partition is mounted and available for use:

# df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/mapper/VolGroup00-LogVol00
                       45G   40G  2.4G  95% /
/dev/xvda1             99M   22M   73M  23% /boot
tmpfs                 1.0G     0  1.0G   0% /dev/shm
/dev/xvdb1            9.9G  151M  9.2G   2% /extraspace

Incorporate the new space into an LVM group

As an alternative to mounting the new disk in the filesystem, you can also add it as a physical volume to an existing LVM volume group. This is the best option if you need to increase the size of an existing disk transparently without disrupting existing operations.

If you choose to add the disk this way, start by following the procedure for creating the new partition table using fdisk as described previously, but be sure to use the t command to change the partition type to 8e (Linux LVM). The additional output of fdisk for this portion of the process will resemble the following:

Command (m for help): t
Selected partition 1
Hex code (type L to list codes): 8e
Changed system type of partition 1 to 8e (Linux LVM)

Command (m for help): p

Disk /dev/xvdb: 10.7 GB, 10737418240 bytes
255 heads, 63 sectors/track, 1305 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

    Device Boot      Start         End      Blocks   Id  System
/dev/xvdb1               1        1305    10482381   8e  Linux LVM

Command (m for help):

Once the partition has been initialized, use the LVM tools to create a new physical volume with the xvdb1 partition that was just created. Then add the physical volume to the volumegroup of your choice, and extend your logical volume to use all available space.

In this example, I am using volume group VolGroup00 and logical volume LogVol00; these are the defaults for a standard CentOS LVM configuration.

# pvcreate /dev/xvdb1
  Physical volume "/dev/xvdb1" successfully created
# vgextend VolGroup00 /dev/xvdb1
  Volume group "VolGroup00" successfully extended
# lvextend -l+100%FREE -r VolGroup00/LogVol00
  Extending logical volume LogVol00 to 55.88 GB
  Logical volume LogVol00 successfully resized
resize2fs 1.39 (29-May-2006)
Filesystem at /dev/mapper/VolGroup00-LogVol00 is mounted on /; on-line resizing required
Performing an on-line resize of /dev/mapper/VolGroup00-LogVol00 to 14647296 (4k) blocks.
The filesystem on /dev/mapper/VolGroup00-LogVol00 is now 14647296 blocks long.

Note: LVM will automatically re-size the filesystem on the logical volume, which is nice.

Finally, compare the file system disk space usage with the output of the previous df command to confirm that the additional space is indeed available:

# df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/mapper/VolGroup00-LogVol00
                       55G   40G   12G  78% /
/dev/xvda1             99M   22M   73M  23% /boot
tmpfs                 1.0G     0  1.0G   0% /dev/shm

Conclusion

In the end, adding additional space to a Xen virtual machine is not that difficult. Please let me know if you have found this tutorial helpful, or if you have had similar experiences modifying disks on a Xen domU.

Stay tuned for my next article on migrating a Xen virtual machine from a file based container to an LVM-backed block device.

Node.js is a server-side JavaScript environment that uses an asynchronous event-driven model. This allows Node.js to get excellent performance based on the architectures of many Internet applications.

The event-driven model and Node.js framework makes it ridiculously simple to build web services like the following “Hello World” example from the Node.js webpage:

var http = require('http');

http.createServer(function (request, response) {
  response.writeHead(200, {'Content-Type': 'text/plain'});
  response.end('Hello World\n');
}).listen(8124);

console.log('Server running at http://127.0.0.1:8124/');

Installation

The online wiki provides instructions on installing Node.js as an unmanaged package, but I prefer to handle as much as possible with RPM. To that end, I put together a simple spec file that can be used to build Node.js RPMs for use on RedHat or CentOS systems (or any other system that uses RPM as a package management tool).

The first thing you’ll need to do is download the latest Node.js source package. At the time of this writing, v0.4.6 is the most current version of Node.js available. I like to use curl to download the sources directly into the default rpm sources directory, but you could also use wget or simply download the package via your web browser. You’ll also need to make sure that Node.js source ends up in the right place if you are not building the RPM as root, or if you like to put your build structure somewhere other than /usr/src/redhat.

curl -sR -o /usr/src/redhat/SOURCES/node-v0.4.6.tar.gz \

http://nodejs.org/dist/node-v0.4.6.tar.gz

Once you have the source in place, download the Node.js spec file and place it into /usr/src/redhat/SPECS (or the appropriate spec folder). To build the RPM, execute rpmbuild as follows:

rpmbuild -ba /usr/src/redhat/SPECS/nodejs.spec

Once the build completes, you will find your RPMs in the /usr/src/redhat/RPMS folder.

More Information

For more information about Node.js, visit the following online resources:

• Node.js Homepage
• Mailing List
• IRC #node.js on freenode.net

One of the downfalls to the approach outlined in the previous article is that the keyword reports produced by the filters display %20 instead of spaces in the User Defined Value, as shown in the following screenshot:

My first reaction was to try and create a Search and Replace filter in the Google Analytics profile, but Google does not allow you to enter a single space in the Replace String field, instead treating that field as being empty. Other people recommend using an underscore instead of a space as the replacement character.

The solution is to use a non-breaking space (Option+Space on OSX, or Alt+0160 on Windows). The only other issue is that the filters will only replace once instance of %20 with a space, so you’ll need to create several (I usually create five or six and call it a day).

After you make this change, note that it will take a few days to start seeing it take effect. Here’s a screenshot with the updated filters in place, also notice that I’ve put the rank information at the front of the user defined field so that it is always visible.

The new format promises to reveal much more information about the search result rankings that was previously available, and this post will show you how to take advantage of that information to tune your SEO efforts using Google Analytics.

Starting this week, you may start seeing a new referring URL format for visitors coming from Google search result pages. Up to now, the usual referrer for clicks on search results for the term “flowers”, for example, would be something like this:

http://www.google.com/search?hl=en&q=flowers&btnG=Google+Search

Now you will start seeing some referrer strings that look like this:

http://www.google.com/url?sa=t&source=web&ct=res&cd=7&url=http%3A%2F%2Fwww.example.com%2Fmypage.htm&ei=0SjdSa-1N5O8M_qW8dQN&rct=j&q=flowers&usg=AFQjCNHJXSUh7Vw7oubPaO3tZOzz-F-u_w&sig2=X8uCFh6IoPtnwmvGMULQfw

What does that mean for me?

Common speculation is that the cd parameter in the referral URL indicates the position of your page in the search results, and this has been confirmed by Matt Cutts.

Knowing what position your pages hold in the SERPS for a given keyword can be enormously helpful to your SEO efforts, so it makes sense to start tracking this new data. Prior to the change in referer, it was possible to track your SEO rankings with Google Analytics, but you could only get information about the page on which you were ranking for a keyword search, not your overall position.

Create a New Profile

You are definitely going to want to create a new profile within Google Analytics so that you do not interfere with the data that is already being collected for your site (The profile that we are about to set up will only capture data for organic search results from Google that use the new referer string).

Sign in to your Google Analytics account and “Add a Profile for an Existing domain”. You can give it any name you like, I chose to use “Google SERP Ranking”.

Create the Filters

The first thing that we need to do is create a couple of filters to make sure that only organic google searches are included in this profile. Order is important, so make sure that you either create your filters in the order that they are described here, or that you go back when you are finished and reorder them appropriately.

1. Include Organic Search Results

Create your first custom include filter using the Campaign Medium filter field and a filter pattern of organic.

2. Include Google Search Results

Create another custom include filter using the Campaign Source filter field and a filter pattern of google.

3. Include New Google Referral URL

Create the final custom include filter using the Referral filter field and a filter pattern of google.com/(search|url).*\bcd=\d*.

4. Extract Keyword and Ranking Data

The last filter we need to create is an advanced filter that will extract data from the referal string and create custom output that will be viewable in our reports. Create an advanced custom filter, and set the pulldowns, text areas and radio buttons as shown in the screenshot. This will extract the keywords and SERP position from the referal string and replace the output with our own custom string in the format <keyword> (Rank: <position>)

For clarity, here are the three regular expressions from the previous screenshot:

\bq=([^&]*)
\bcd=(\d*)
$A1 (Rank: $B1)

Visualizing Results

Once you have created the new profile and filters, and have started receiving traffic, you should be able to see the keyword/ranking data in any of your reports when you change the dimension to User Defined Value.

Please share your experiences with this or any other helpful Google Analytics tricks that you use!

Update: You can also replace the %20 with a space in your reports by adding some additional filters

Webgrind is an Xdebug profiling web frontend in PHP5. It implements a subset of the features of kcachegrind and installs in seconds and works on all platforms.–Webgrind

Anyone who has ever needed to profile code is probably familiar with KcacheGrind (a profile data visualization tool). KcacheGrind provides a way to visualize the profile data from a program execution, allowing you to quickly and easily see where the program is spending its time. Knowing where the execution bottlenecks are allows you to focus your optimization efforts in the correct places.

For a long time, the Xdebug extension for PHP has been able to (among other things) dump execution profile information to disk in a format that is usable by KcacheGrind, which is great if you are running Linux with KDE.

The webgrind project provides a web-based replacement for KcacheGrind that can be installed on any operating system, allowing you to visualize a portion of the Xdebug profiling data through a browser.

Installation

Before using webgrind, you must first install Xdebug.

Installing webgrind is pretty simple:

1. Download webgrind
2. Unzip webgrind in your web server’s document root
3. Configure Xdebug and webgrind
4. Point your browser to where you installed webgrind

Configuration

Unfortunately, webgrind does not often work “out-of-the-box”… There are a few configuration details that need to be dealt with in order to start profiling your code. The following PHP configuration directives can be used to control the behavior of Xcebug:

xdebug.profiler_enable

This directive actually turns on Xdebug’s internal profiler. You must set this to 1 in order to have Xdebug actually produce output for webgrind to analyze.

xdebug.profiler_enable_trigger

If you enable this option, profiles will only be generated if you pass a GET/POST parameter or cookie with the name XDEBUG_PROFILE, e.g., http://localhost/script.php?XDEBUG_PROFILE. You must not enable xdebug.profiler_enable if you use this option.

xdebug.profiler_output_dir

This directive tells Xdebug where to put the profile data. By default, it is set to ‘/tmp’, which is usually fine. If you want, you can probably omit this from your Xdebug configuration.

xdebug.profiler_output_name

This value tells Xdebug how to create filenames for the data it writes to disk. By default, the value is set to cachegrind.out.%p, where %p will be replaced with the process ID. This is bad, and you will definitely need to change it. The problem is that Apache processes serve multiple requests, so each request in a given process will overwrite the profiling data from previous requests. Other possible format specifiers can be used.

xdebug.profiler_append

Enabling this option will cause xdebug to append data to the output file if it already exists (the default behavior is to overwrite the output file). This is a handy option if you need to average out the profiling data over multiple script executions. In that case, be sure to set xdebug.profiler_output_name using a format that will ensure that each successive page load uses the same profiler output name, e.g., cachegrind.out.%s.

Assuming you have already loaded the Xdebug extension, the following additional PHP configuration directives should be a good starting point for you:

xdebug.profiler_enable = 1
xdebug.profiler_output_name = cachegrind.out.%t.%p

That’s it, you should be ready to profile your PHP code with Xdebug and Cachegrind!

PageRank is a link analysis algorithm used by the Google Internet search engine that assigns a numerical weighting to each element of a hyperlinked set of documents, such as the World Wide Web, with the purpose of “measuring” its relative importance within the set.

What is my PageRank?

There are a number of ways to check your PageRank, but some of the easiest and most useful come in the form of Firefox plugins. These are a few of the most popular:

• SEO For Firefox
• SearchStatus
• Live PageRank

My Member Access and UserVoice WordPress plugin pages received an increase in PageRank, but for the most part pages here retained the same ranking. How did your site fare after this Google PageRank update?

Here’s a sample of what people are saying on Twitter about the latest Google PageRank update:

• @KennethMoody: The Google Pagerank God has been been good. – 8:24
• @jredd77: Celebrating my website’s PageRank increase from 0/10 to 3/10 overnight. – 9:21
• @highonbeingdave: Finally got my web site from 0 to 1 on PageRank! Yippie! (cheap thrills come easily) – 10:26

Join the conversation!

A common problem is that WordPress is unable to access the filesystem directly, which results in a page indicating that “To perform the requested action, connection information is required.“

If you feel that your WordPress installation should not be asking you for this information, or you simply do not want WordPress to use this method of plugin management, you may be able to work around it.

What is Causing This?

Whenever you use the WordPress control panel to automatically install, upgrade, or delete plugins, WordPress must make changes to files on the filesystem.

Before making any changes, WordPress first checks to see whether or not it has access to directly manipulate the file system.

If WordPress does not have the necessary permissions to modify the filesystem directly, you will be asked for FTP credentials so that WordPress can try to do what it needs to via FTP.

Why Can’t WordPress Write To The Filesystem?

In order to understand why WordPress can’t write to the filesystem, we need to take a look at some WordPress internals.

The following code is from the get_filesystem_method() method in the wp-admin/includes/file.php file:

if( function_exists('getmyuid') && function_exists('fileowner') ){
    $temp_file = wp_tempnam();
    if ( getmyuid() == fileowner($temp_file) )
        $method = 'direct';
    unlink($temp_file);
}

This code creates a temporary file and confirms that the file just created is owned by the same user that owns the script currently being run. In the case of installing plugins, the script being run is wp-admin/plugin-install.php.

This may seem a little counter-intuitive, since the only thing WordPress really needs to be able to do is write to the wp-content/plugins directory.

What Can I Do About It?

In order to fix this issue, you will need to make sure that the scripts which need to write to the filesystem are owned by the same user that apache is running as.

Many hosting companies will run your apache instance using your user account, and all of your files will be owned by the same account. In those cases, you will probably not have the issue described here.

If your hosting company is running apache as a system user, and your files are owned by your own account, your only option may be to enter your FTP credentials here and allow WordPress to use FTP.

If you are running on a hosting company that gives you root access, or you have installed WordPress on your own development machine at home or at work, you should be able to modify the filesystem permissions to allow WordPress to directly access the filesystem.

The easiest way to do this is to find out what user apache is running as and change ownership of the entire WordPress directory to that user. For example, if apache is running as ‘httpd’, you could use the following commands on your WordPress installation directory:

# chown -R httpd: wordpress

Note that not all versions of chown are equal. If that command does not work, see your local chown man page for usage information.

Tip: In order to find out what user your instance of apache is running as, create a test script with the following content:

<?php echo(exec("whoami")); ?>

Thanks Suzanne!

Do you have any Firefox add-ons that you can’t live without? Leave a comment and tell us about them!

If you navigate the the Settings tab, and click on the Reading sub-menu option, you will see the Front page displays WordPress configuration option. This option allows you to specify whether your front page, i.e., the page displayed when a user visits your main site URL, will contain a listing of your latest posts, or a different, static page.

Your latest posts

Selecting this radio option will make your latest posts show up on the front page of your site

A static page

Selecting this radio option allows you to choose a static page as your front page

Front page

The page that you select in this pull-down will now be displayed when a user visits the front page of your site.

Posts page

The page that you select in this pull-down will now display your latest posts instead of any content that it might currently contain (you don’t have to use this option).

What’s the Point?

This functionality makes it easy for WordPress administrators to handle sites with formats that make it more appropriate to show a static page as the front page, but that also want to be able to show the default listing of recent posts without making any template modifications.

I hope you found this article helpful, please feel free to contact me with any of your WordPress questions!