While Netalyzr didn’t clearly show what was going on with my Internet connection it did raise a red flag about network buffers that might be the issue. Unfortunately, that’s a router configuration issue on the part of my ISP so I’m not hopeful for a resolution. But I can always gather data then open a trouble ticket with the vendor.

Regardless, Netalyzr looks like a great tool for troubleshooting connectivity issues.

The Prey Project looked like a nice system for tracking stolen devices and has gotten a lot of good press recently. I decided to try it out. After getting everything setup and working I noticed a lot of Cygwin bash shells running the ping command. The commands accumulated eventually degrading system performance which is when I noticed.

Prey has a partial UNIX environment (MingW) contained in it and consists of shell scripts wrapping a number of UNIX utilities compiled for Windows. I say partial because it doesn’t include the “ping” command which is a dependency for the software. And the shell scripts apparently don’t take into account the potential for a user having other UNIX-like environments installed (Cygwin also has a bash shell and the ping command but there are others as well.) So what was happening is that script (pull) naively looks at what operating system it is installed on and for a ping command and issue what it believes are the correct command line arguments. For Windows it’s this:

ping -n 1 www.google.com

This doesn’t work because Cygwin’s ping.exe doesn’t have a “-n” switch. But for some reason doesn’t fail when it encounters an invalid option. Rather, it tried to ping the IP address 0.0.0.1. This doesn’t work, of course, but the ping command tries forever thus respawning new instances of the bash shell and ping until it kills your computer.

Anyway, I hard coded a change to the script on my system and filed a bug with the Prey developers.

I also submitted an email to the Cygwin mailing list describing the Cygwin ping issue.

http://news.ycombinator.com/item?id=2970637

UPDATE: I also found this helpful site: gitref.org

(Note that I’ve included gists at the bottom of the article with the important configuration files.)

I was using a Slicehost slice with a typical Apache/mod_php configuration but there wasn’t enough memory so it would start swapping with a little use which caused frequent outages. But rather than upgrade to the next sized Slice, I found that I could double my RAM for the same money simply by moving to Linode. So that was the first change I made. (FWIW, I’m not suggesting this as a performance enhancement but it’s definitely a better value.)

Next was a series of changes, some of which were noted in the Tumbledry article, some not. The Tumbledry article was thin on details so I did the research myself and came up with a number of articles with the best being this article on setting up nginx, PHP-FPM, APC, memcached and the W3 Total Cache WordPress plugin. The cryptkcoding article shows how to setup an Ubuntu Linux system for seriously fast WordPress performance that consumes incredible few system resources.

First, an ease of use feature that I discovered: someone did a build of PHP 5.3.8 for Ubuntu 10.04 LTS. Since PHP 5.3 includes PHP-FPM, you can keep everything package based.

To use these packages add these lines to /etc/apt/sources.lst:

deb http://ppa.launchpad.net/brianmercer/php/ubuntu lucid main
deb-src http://ppa.launchpad.net/brianmercer/php/ubuntu lucid main

After updating the sources list, run this command to update the apt cache:

sudo apt-get update

(For more details on using these packages, as well as setting up a similar system, checkout this HowToForge article. In particular, there are some useful comments at the bottom.)

Anyway, one of the main features of this setup was swapping out the Apache web server for nginx and PHP-FPM. Like most PHP developers, Apache and mod_php has been the default setup for PHP applications for years. However, I can now vouch for the nginx/PHP-FPM combo as both stable and fast production environment. (I will try out this combo for development on my next PHP project to see how it works.)

Importantly, the system now uses a UNIX socket for the connection between the web and application servers rather than TCP/IP. That means that for the core application and web services there are two UNIX sockets used, one between the web server and the application server then again between the the application server and the database server (MySQL clients use the UNIX socket when the “localhost” host name is used or the host name is blank.)

Anyway, to really see the difference the architecture changes made, I used a blitz.io Rush to hammer the two instances.

First up was the old Slicehost system. This is the Rush configuration I used (same as Tumbledry):

--pattern 1-250:60 -T 4000 -r california

The result: this rendered the system completely unresponsive and required a hard reboot. Here’s a shot of “top” before the system stopped responding. Note all the memory being consumed, load on the way up and lots of Apache processes:

Oh no! The system just died:

Next was the new Linode hosted solution. The result is that the new architecture sustained the Rush with virtually zero CPU usage (I’m not kidding) or any changes to memory usage. Varnish takes most of the load.

So as it turns out, I can also serve up 9 million hits per day from a small (512MB RAM), inexpensive ($20 per month) virtual server.

Here are the important configuration files:

nginx.conf:

nginx virtual host config:

php5-fpm.conf:

varnish:

wordpress.vcl (varnish site config):

During a system’s life cycle requirements change and components are refactored. This includes databases as well and particularly as data grows. Decisions and assumptions are made at the beginning of a system’s life cycle that may or may not hold up over years of operation and it’s good practice to continually analyze how well the initial design is working.

When doing analysis in support of refactoring database schemas in MySQL, I’ve found this little bit of SQL to be invaluable.

Code:

SELECT * FROM TABLE PROCEDURE analyse();

(I suggest giving it a try on a small table with few rows.)

PROCEDURE ANALYSE interrogates the values in a table, shows the smallest and largest values and suggests a type for each column. While the results frequently indicate that an ENUM type is the most appropriate you can add arguments to the ANALYSE procedure to get more rational suggestions. However, even with no arguments the results can be useful.

For example, you might see that the max value of a column actually is smaller than the type that it’s using. I’ve frequently seen INT(11) columns that would work fine as a MEDIUMINT or even TINYINT. Or your might find that an ENUM type is better since the distribution of values is small in a VARCHAR column. (The benefit of an ENUM is that the data is stored as an integer rather than the string value so its’ footprint on the disk can be significantly smaller).

Anyway, while it’s not a panacea, PROCECURE ANALYSE() is another helpful tool.

I should point out my previous article on the subject since there are parts of it that are still applicable.

This is likely applicable to other MySQL UDFs as well but I haven’t tried.

I used the MySQL 5.1.57 x64 version for my system and I downloaded the zip archive rather than the installer. (Note that the server can still be installed as a service but you will need to run the cmd.exe program as an administrator in order to run the command line installation process.)

I also used Microsoft Visual C++ Express 2010 for this and my Windows version is Windows 7 Ultimate x64.

In addition to VS C++, you will also need the Windows SDK for Windows 7 which you can download here. This addition is critical since it contains the x64 compiler and other tools.

When you have everything installed, follow the instructions on Roland Bouman’s blog post about building UDFs on Windows but stop before building and installing the function then follow these steps to 64bit glory (if you are specifically using udf_median, you might also be interested in this post):

1. Right-click on the project (not the solution), choose “Properties”. At the top of the dialog, from the “Configuration” dropdown, select “All Configurations”.
   
2. Next expand “Configuration Properties” then select “General”. In the field on the right labeled “Platform Toolset” make sure the value “Windows7.1SDK” is selected
   
3. Now let’s make it x64. At the top of the dialog box, click on the “Configuration Manager” button.
   
4. In the resultant grid, select the “Platform” dropdown and choose “New…”. When the “New Project Platform” comes up, select x64 from the top dropdown then click “OK” then “Close” then close the Properties dialog.
   
5. Now you can try building the project
   
6. If the build is successful, you find the .dll, in my case ufd_median.dll, in the “Debug” or “Release” folder. Put that in the MySQL lib/plugin/ directory
   
7. Install the plugin using SQL like this:
   
CREATE AGGREGATE FUNCTION median RETURNS REAL SONAME 'udf_median.dll';


And that should be it.

Here are a few things that I came across while setting up my project that might be helpful:

1. In one instance the linker reported this error:
   1>LINK : fatal error LNK1104: cannot open file 'kernel32.lib'
   The fix for this was making sure that the “Platform Toolset” in the project configuration properties was set to “Windows7.1SDK”
2. If you get this error:
   ERROR 1126 (HY000): Can't open shared library 'file.dll'
   this can sometimes mean that the .dll wasn’t compiled correctly (i.e. this is what you get when you try to use a 32bit .dll with a 64bit server) or the symbol exports didn’t work. I used the dumpbin program to make sure that the functions that needed to be exported were. Under the “Tools” menu in VC++, select “Visual Studio Command Prompt” then navigate to the directory with your .dll file and run this command:
   dumpbin /exports udf_median.dll
   You should see the exported functions in the output.
3. I did not have to alter any of the C code to make this work even though I saw some comments on Roland’s post indicating that might be necessary.

That’s about it. Feel free to contact me if you have any questions or if the steps didn’t work for you.

The tricky part of this setup is that everything is hosted on the same hardware node and we also have some web services that needed to be left untouched. These requirements implied some network configuration using iptables to force outbound web requests through the proxy.

So the first thing I needed to do was install squid. On this project we use CentOS on all our hosts so this was easily accomplished like this:

sudo yum install squid

Next was adjusting the configuration. The default squid.conf comes with lots of documentation which is helpful but makes the configuration file difficult to read and navigate so the first thing I did was get rid of it like so:

cd /etc/squid && sudo cp squid.conf squid.conf.orig && sudo egrep -v'^#' squid.conf > /tmp/squid.conf


This leaves a lot of empty lines in the file which can be removed like this:


sudo sed '/^$/d' /tmp/squid.conf > /tmp/squid.clean && sudo mv /tmp/squid.clean squid.conf


Next up was setting up networking and squid.

The squid site has a great set of examples, one of which looked like it suit my purposes nicely.

First I configured squid by adding this directive:

http_port 3128 transparent

Then I started squid:

sudo service squid start

I also wanted to make sure squid starts when the system is rebooted:

sudo chkconfig --levels 2345 squid on

Next up was network configuration.

I needed to setup iptables with some NAT rules to force requests through the proxy server. The first command clears out any existing rules. If you already have a custom kernel network config, use this with caution:

sudo iptables iptables -t nat -F

The next rule is for a typical transparent proxy setup. In the setup that I was working with I did not need this rule, something I discovered by disabling the existing web sites with this command. So if you have a web server DO NOT do this:


sudo iptables -t nat -A PREROUTING -p tcp -i eth0 --dport 80 -j REDIRECT --to-port 3128


Here is the start of the iptables configuration we implemented.

Apply the rules to force local HTTP traffic through the transparent proxy:


gid=`id -g squid`
sudo iptables -t nat -A OUTPUT -p tcp --dport 80 -m owner --gid-owner $gid -j ACCEPT
sudo iptables -t nat -A OUTPUT -p tcp --dport 80 -j DNAT --to-destination HOSTIP:3128


Replace the string “HOSTIP” with the IP address of the host you’re configuring.

At this point I needed to test the setup so I tailed the access log. Or at least I tried to. The default directory permissions on the /var/log/squid directory prevented me from viewing its’ contents. I fixed that with this:

sudo chmod 0775 /var/log/squid

Then I was able to tail the /var/log/squid/access.log. So I created a request to see if it was logged:

wget http://www.google.com

I saw the request logged in the squid access log so I was satisfied that it and the networking were functional. However the log format wasn’t what we needed to feed to awstats, which is what I going to use to process the log.

Since we already use squid and process its’ logs I grabbed the configuration from our production configuration file:


logformat combined %>a %ui %un [%{%d/%b/%Y:%H:%M:%S %z}tl] "%rm %ru HTTP/%rv" %Hs %h" %Ss:%Sh
access_log /var/log/squid/access.log combined


Then I restarted squid and tested again. It looked good so I tested one of our batch processes that makes HTTP requests to make sure that it did what I wanted. It did however I noticed that query strings from the URI were not being logged. A quick google told me that I needed to update the squid.conf with this:

strip_query_terms off

As it turns out squid squid strips query string after the “?” by default. This is apparently to “protect privacy” but we needed the query string to identify individual requests more accurately.

At this point I had the system setup and working. It logged all the outbound HTTP requests and the existing web services remained unaffected. All that was left to do was setup awstats to process the logs.

I’ve captured the text from my previous post and put it here. I apologize for not having the images available but will see what I can do about that. Anyway, here’s the text I first published in 2008:

UDF median on Windows

On my current project we use MySQL as part of our stack and I needed to setup MySQL on my Windows XP workstation for development. A custom feature of the database is the use of a MySQL UDF (User Defined Function), discussed in depth here, here and lots of other places.

We had a pre-compiled Windows binary DLL available that did not work. Dan Moore told me that he needed to recompile on his workstation as well so I set about figuring out how to rebuild on my workstation.

While this is somewhat of a digression, it might be useful information. The error that was returned with our pre-compiled DLL was this:

ERROR 1126 (HY000): Can't open shared library 'file.dll'

The error message is supposed to indicate that the location of the DLL is incorrect, however that was not the issue in this case. It was in the bin/ directory of the MySQL installation where the recompiled DLL was later found, loaded and made usable by the server. I did not look any further into this issue since recompiling fixed the problem.

Returning to the subject at hand, because I found that there are differences in the process to setup between Visual Studio Express Edition 2005, as described in Roland Bouman’s blog post, and Visual Studio 2008 Professional, I decided to post a write up describing my process. Most of the changes have to do with the New Project wizard and it’s ability to take care of most of the configuration of the project. However if you haven’t already, please stop and read the article on Roland Bouman’s blog before going through this as it has more detail and includes the all important steps of installing the MySQL header files and development libraries used to compile the UDF code.

If you are like me and sometimes prefer “doing” over reading or you just want a compiled binary, you can find the project files here. You will find the bonus feature of a Makefile and some other niceties for building on Linux and Unix variants too!

Note that my source file has been modified to work with MySQL 5.0.x and I’ve only tested it against 5.0.45 since that was the only requirement I had at the time. Please post a comment if you have solutions to problems with other versions.

First, you will want to make sure that you have installed MySQL version 5.0 or later with the header and other development components per the instructions in Roland Bouman’s post.

Next, install the version of VS08 that you have access to. I use VS08 Professional so there may some differences if you use the Express version. After installing VS, download the source file and put it in it’s own folder on your hard drive. This will be your project directory. Once you have the project director and the source file, udf_median.cc in my case, you can start VS08 in order to start setting up the project.

Once VS08 is running, go to the “File” menu and click “New” then “Project from Existing Code…”, as such:

Project from Existing Code…

The next screen will allow you to choose a C++ project (I also use C# so this step is required):

Choose C++

The next dialog allows you to select the folder that contains your source file. This is what it should look like once you select your project folder and give the project a name:

The next dialog allows you to define the project type. We’re building a DLL (Dynamically Linked Library) so select the appropriate item from the drop down:

In the next two dialogs, we are configuring properties for the build. There are two builds, Debug and Release. All we are going to add is the path to the MySQL header files.

Because the wizard is so helpful, you don’t have do anything to setup the Release target. Just make it the same as Debug:

Click the “Finish” button and you will be taken to your project. You can try building the DLL at this point by either pressing F6 or choosing it from the “Build” menu:

If you used the source I’ve provided, you should end up with a compiler warning that looks like this:
Command line warning D9035 : option ‘Wp64′ has been deprecated and will be removed in a future release

Since I’m a stickler for clean builds, I decided to fix this. First right-click on your project (not the “Solution” at the top level) then select “Properties”:

Once in the Properties dialog, expand the “Configuration Properties” item in the left pane, then expand the “C/C++” item. Select “General”. In the right pane, sixth row down you should see the property “Detect 64-bit Portability Issues”. Set the property to “No”:

To fix the release build, select “Release” from the “Configuration” drop down at the very top of the dialog and set the same property to “No”. Click “OK” to close this dialog.

Speaking of the Release build, once you’ve made it to this point we should try that build as well. At the top of the IDE on the tool bar there is a drop down that should be set to “Debug”. Click on this drop down and select “Release”, as such:

Press the F6 key to build the release. Again if you are using my source and following these instructions, you should get the following build warnings:

warning LNK4075: ignoring '/INCREMENTAL' due to '/OPT:ICF' specification

To remedy this, you again want to right-click on the project and select “Properties”. Make sure that the “Release” configuration is selected at the top of the dialog. This time drill down to the “Linker” item and select “General”. In the right-hand pane you will find a property labeled “Enable Incremental Linking”. Set the value to “Default” then click “OK” to to close the dialog.

Once you are out of the dialog press F6 to build and you should get a clean build with no errors or warnings. The output DLL will be in a subfolder of the project named “Release”. Copy the udf_median.dll file into the bin directory of the MySQL server instance. Start a MySQL client and connect to the database server. From a query window as the root or other user with the appropriate privileges, issue this SQL query:

CREATE AGGREGATE FUNCTION median RETURNS REAL SONAME 'udf_median.dll';

You should now be able to use the function in your SQL queries.

You can see example output in one of the web applications udf_median is used in here.

Last and certainly not least, I would like to acknowledge the work of Dan Moore and Roland Bouman without who’s excellent work I would not have been able to figure this out. Cheers!

public class GenericDAOHibernate<T, PK extends Serializable> implements GenericDAO<T, PK> {

	/** log4j Logger for class GenericDAOHibernate */
	private static Logger logger = Logger.getLogger(GenericDAOHibernate.class.getName());

    private Class<T> persistentClass;

    private HibernateTemplate hibernateTemplate;

    @Autowired(required=true)
    private SessionFactory sessionFactory;

// [...]

@Override
public Class<T> getPersistentClass() {
    return persistentClass;
}

@Override
public int countAll() {

    @SuppressWarnings({ "unchecked", "rawtypes" })
    List results = (List) hibernateTemplate.execute(new HibernateCallback() {
        public Object doInHibernate(Session session) throws HibernateException, SQLException {
            return session.createCriteria(getPersistentClass())
                .setProjection(Projections.rowCount())
                .list();
            }
        });

        // Here I use the Spring DataAccessUtils class to interpret the result set
        int result = DataAccessUtils.intResult(results)

        logger.debug("count retrieved: " + result;

        return result;
}

I also added another convenience method that uses the Example Criteria API so we can generate a count with a pre-configured Entity:

@Override
public int countByExample(final T exampleInstance)

    @SuppressWarnings({ "unchecked", "rawtypes" })
    List results = (List) hibernateTemplate.execute(new HibernateCallback() {
        public Object doInHibernate(Session session) throws HibernateException, SQLException {
            return session.createCriteria(getPersistentClass())
                .add(Example.create(exampleInstance))
                .setProjection(Projections.rowCount())
                .list();
            }
        });

        // Here I use the Spring DataAccessUtils class to interpret the result set
        int result = DataAccessUtils.intResult(results)

        logger.debug("count retrieved: " + result;

        return result;

I plan to package up some of the Generics code at some point and will post a link to download it or to a public source code repository.

An additional aggravation was that turning off the previews is not a configuration option.

Being a web developer, I opened up Firebug and started rooting around for the “problem”. After sifting through Google’s nearly inscrutable code for about 30 seconds, I asked Google directly for a solution. Google pointed me to this article on Lifehacker about how to use the AdBlock Plus browser plugin to do the job. The solution is to add these 3 rules:


google.com##.vspi
google.com##.vspib
google.com###vspb