Both of these tips are great advice, but they don’t address the issue of mixing up your tabs. Thankfully, I found a solution.

This banner shows up on every page within phpMyAdmin, and I didn’t even have to hack any core files to do it! In your main phpMyAdmin directory, create a file called config.header.inc.php and put the following in it to achieve the same effect:

<style>
#floating_menubar {
top: 41px!important;
}
</style>
<div style="height:40px;"></div>
<h1 style="position:fixed;top:0;left:0;width:100%;z-index:510000;background:#ffc0cb;margin:0;color:#000;line-height:40px;padding:0 10px;border-bottom: 1px solid #800000;font-weight:normal;">
Warning! You Are In Production. Proceed With Caution.
</h1>

Hopefully this will help to avoid the same mishap in the future!

My client was also interested in a web based UI. Web based UIs like GitHub, GitLab and FishEye make a lot of things easier. Non technical users can go review commits, code reviews, and the code itself among other things. Some packages bundle in issue tracking and tightly integrate it. Most bundle it mechanisms to do code review easily.

I setup two solutions for them. GitHub Enterprise, a virtual appliance provided by GitHub that mirrors their public service quite closely. However, it’s self hosted, and supports enterprise-y features like LDAP integration. GitLab is essentially a GitHub clone, but less polished and mature, with no enterprise support.

I’m a huge fan of GitHub.com, and GitHub enterprise was very familiar to me. The software is very easy to setup, if you already have a virtualization infrastructure (Which my client does). The entire package feels very polished, it’s extremely user friendly, and it’s updated frequently.

GitLab is a good alternative if you don’t have the budget for GitHub enterprise (licenses start at $5000/year) but want the same experience. It’s not quite as polished, and a few things are harder to use. However, you get most of the same experience, and it’s open source. It’s currently under active development, and I plan on making a few pull requests once I get a little more involved in Ruby.

If you’re considering checking them out, GitHub enterprise has a 45-day free trial and is distributed as an OVF virtual appliance. GitLab is a bit more difficult to setup, but it’s also worth taking a look at.

WordPress has this feature called “Must Use Plugins“, aka mu-plugins. They go in the directory /wp-content/mu-plugins/ which does not exist by default. WordPress will load every .php file in that top level directory, before regular plugins. In my efforts to write less crappy code on WordPress, this directory has proved invaluable. However, rarely do you want a bunch of .php files in that directory. Normally, you’d want a system more like the regular plugin directory where each plugin can be a file OR a directory.

I wrote up a little proxy loader script that accomplishes this. Just save as /wp-content/mu-plugins/proxy-loader.php or something, and it will load either /wp-content/mu-plugins/<plugin-name>/<plugin-name>.php OR /wp-content/mu-plugins/<plugin-name>/plugin.php if those files exist. The plugin is available via GitHub.

There wasn’t any information when I Google’d it, so I played around with syntax a bit, got it working, and decided to add it to my blog in-case I forgot about it or anyone else needs it.

The mail command itself is defined in the commands.cfg file, which for me is located at /opt/nagios/etc/objects/commands.cfg, but for you, it’s probably /etc/nagios/objects/commands.cfg.

At the top, you’ll see the two relevant command definitions, ‘notify-host-by-email’ and ‘notify-service-by-email’. Here’s my configuration:

# 'notify-host-by-email' command definition
define command{
    command_name notify-host-by-email
    command_line /usr/bin/printf "%b" "Subject: $NOTIFICATIONTYPE$ Host Alert: $HOSTNAME$ is $HOSTSTATE$\n\n***** Nagios *****\n\nNotification Type: $NOTIFICATIONTYPE$\nHost: $HOSTNAME$\nState: $HOSTSTATE$\nAddress: $HOSTADDRESS$\nInfo: $HOSTOUTPUT$\n\nDate/Time: $LONGDATETIME$\n" | /usr/sbin/sendmail -vt $CONTACTEMAIL$
    }

# 'notify-service-by-email' command definition
define command{
    command_name notify-service-by-email
    command_line /usr/bin/printf "%b" "Subject: $NOTIFICATIONTYPE$ Service Alert: $HOSTALIAS$/$SERVICEDESC$ is $SERVICESTATE$\n\n***** Nagios *****\n\nNotification Type: $NOTIFICATIONTYPE$\n\nService: $SERVICEDESC$\nHost: $HOSTALIAS$\nAddress: $HOSTADDRESS$\nState: $SERVICESTATE$\n\nDate/Time: $LONGDATETIME$\n\nAdditional Info:\n\n$SERVICEOUTPUT$\n" | /usr/sbin/sendmail -vt $CONTACTEMAIL$
    }

You’ll note that I didn’t simply swap out the sendmail binary path for the previous path. Sendmail takes it’s arguments slightly differently, so I had to move the subject line inside of the printf statement and tell sendmail to get it’s mail headers from the input.

Layouts

Layouts let you abstract the HTML code that is re-used on every page to a single (or several) re-usable template files. Using a layout system allows you to write cleaner, more DRY code. In Zend, layouts are located in the /application/layouts/scripts folder, and use the .phtml extension much like views. Generally, a layout will contain the HTML head/foot, and any parts of the page that may appear in every page (Top navigation for instance). Example of a Zend layout:

<!DOCTYPE html>
<html>

<head>
    <title>Some Title</title>
</head>

<body>
    <?php echo $this->layout()->content ?>
</body>

</html>

The part in the body will print out the contents of your regular view. That way, you only need to include the unique parts of a page in the view.

To select a layout in your controller, call the following code:

$this->_helper->layout->setLayout('admin');

This will use the layout file /application/layouts/scripts/admin.phtml.

Passing Variables To Your Layout

A common requirement is to pass unique variables to your layout, for example, the page title. This is easily accomplished. In your controller, use the following syntax to assign variables:

$this->_helper->layout->__set('title', 'My Page Title');

In your layout template, use the following syntax to access variables:

<?php echo Zend_Layout::getMvcInstance()->title ?>

Rendering Partial Templates

Commonly, you’ll have some code that is re-used in multiple places but is not something you can place in a layout. A great example of this would be a widget that appears on several pages but not all of them. For situations like this, you can use the render() function.

render() can be used in layouts or regular views. It will render the contents of a given .phtml template and return it. Here’s an example of its use:

<?php echo $this->render('widgets/products.phtml') ?>

The render() function loads a template relative to /application/views/scripts when used in a regular view, and /application/layouts/scripts when used in a layout.

Variables available in the current template are available in the rendered template as well.

The Partial Function

Also of note is the partial() function. It behaves almost exactly like render(), except you pass it the variables in can use instead of it using the current scope. This is good if you’re iterating over an array (like an array of products) and want to render each one as a template. Example:

<?php
foreach ($products as $product) {
    echo $this->partial('partials/product_row.phtml', $product);
}
?>

Conclusion

While the examples used here are specific to Zend Framework 1, the concepts are applicable to most modern frameworks and templating systems (Including Twig).

If you accidentally mess up those iptable rules and lock yourself out of SSH, you no longer have to call the hosting company at 2 in the morning and have them laugh at you (I swear, this never happened to me…). Instead, you open up the vSphere client and access the VM console directly (much like you would in VMWare Player, VMWare Workstation, or VirtualBox). Since it’s the same as being physically connected to the machine, it’s much harder to lock yourself out. You can even reboot into single user mode if need be – no need for a KVM switch.

You can have separate staging/prod environments easily, with no extra cost. You can create VMs just to test things and discard them when you’re done (You can do that locally of course). It makes backup & restoration far simpler.

The actual process of setting up and managing VMs couldn’t be easier either! If you’ve used VMWare workstation, the process is very similar to that (just with more cool options).

Licensing

I will say this though. While the VMWare software is great, their website is not. Licensing terms are very confusing. I’ll straighten out a few things for those who may be interested.

VMWare ESXi is a bare metal hypervisor that is installed instead of an OS on your server. It supports SSH but only with a small subset of available commands. ESXi is free, but only for servers with up to 32 gb of RAM.

VMWare vSphere is the client you use to connect to your ESXi host and manage it. It’s akin to VMWare Workstation, but for servers. The vSphere client is free but only for managing 1 server. If you want to manage more from the same host you’ll need a VMWare vSphere license. To get started, I’d recommend the VMWare vSphere essentials kit. This kit gives you the ability to centrally manage up to 3 servers, and removes the limit of 32 GB of RAM. It also unlocks a few other goodies. The essentials kit is the cheapest available license and starts at $560 USD.

One more note is that if you only have 1 server and go with the free license, you’ll get a notice about being on a 60 day trial when you first connect to your ESXi host with vSphere. You need to register on the VMWare site and get a free license, and then enter the license key in your vSphere client. Yeah, not very intuitive, I know.

If you have any questions, or if anything here is wrong or has changed, please leave a comment below.

Personally, I think most FTP servers suck. I use ProFTPD, and don’t like it very much. It’s annoying to configure, clumsy, and not easy to extend. I decided to write my own FTP server, to learn Node and gain a better understanding of the FTP protocol. So far, it’s going really well and I think Node.js was an excellent choice. You can actually check out my progress over at GitHub, although I’m still quite early in development. I have the basic functionality implemented in a way I’m fairly happy with. Next I want to add authentication and improve the command line interface.

I’m also thinking about implementing a web UI to manage the server and see real time usage information.

If you’re a web developer and haven’t checked out Node.js, I’d highly advise a quick look. It’s not that bad

The \x08 hex character code is the ASCII backspace character. If you write it to the console, it deletes a character. With PHP, I kept track of the line length, and every iteration of the loop, I would use str_repeat to send however many backspace characters I needed to erase the current line. Then I would write a new line for the current progress of the loop. This created a very smooth progress indicator.

Here’s a barebones version as a proof of concept:

<?php
$lastLineSize = 0;

for ($i = 0; $i <= 50; $i++) {
    echo str_repeat("\x08", $lastLineSize);
    echo "Iteration {$i} of 50";
    $lastLineSize = strlen("Iteration {$i} of 50");
    usleep(100000);
}

echo " - Done\n";

and the resulting console output after the script is complete looks like this:

[root@dev /home/brandon] > php test.php
Iteration 50 of 50 - Done
[root@dev /home/brandon] >

Run the script for yourself to see what it looks like. Basically, the script counts from iteration 0 to 50, all on one line. It makes for very fancy console scripts

FYI, I’m running Plesk 10.4.

Plesk allows you to add your own configuration files for each domain, vhost.conf and vhost_ssl.conf. The location of these files varies depending on if you’re using a regular domain or a subdomain. The locations are:

/var/www/vhosts/domain.tld/conf/vhost.conf
/var/www/vhosts/domain.tld/subdomains/<somesubdomain>/conf/vhost.conf

The format of these files should look something like this:

<Directory /var/www/vhosts/domain.tld/<subdomainlocation>>
  ServerAdmin  "support@domain.tld"
  <IfModule mod_php5.c>
    php_admin_value open_basedir /var/www/vhosts/domain.tld/:/tmp/:/opt/php/lib/php
  </IfModule>
  <IfModule sapi_apache2.c>
    php_admin_value open_basedir /var/www/vhosts/domain.tld/:/tmp/:/opt/php/lib/php
  </IfModule>
</Directory>

I added a few extra options as an example. If I were modifying my main domain, the config would look like this:

<Directory /var/www/vhosts/brandonwamboldt.ca/httpdocs>
  ServerAdmin  "support@brandonwamboldt.ca"
  <IfModule mod_php5.c>
    php_admin_value open_basedir /var/www/vhosts/brandonwamboldt.ca/:/tmp/:/opt/php/lib/php
  </IfModule>
  <IfModule sapi_apache2.c>
    php_admin_value open_basedir /var/www/vhosts/brandonwamboldt.ca/:/tmp/:/opt/php/lib/php
  </IfModule>
</Directory>

Next step is to modify the permissions on your new config files.

chown root:apache vhost.conf
chmod 640 vhost.conf

And finally, ask plesk to reconfigure it’s configuration to include this new config:

/usr/local/psa/admin/sbin/httpdmng --reconfigure-domain brandonwamboldt.ca

Note: Even if you’re adding a config file for a subdomain, you must reconfigure the top level domain

For the application I’ve been developing (For one of my clients over at Spark Creek), I’ve had to create an edit profile page. Using Symfony’s form builder, I created my own form class but wanted to use the current user object instead of creating a dummy model. The problem I was running into was that whenever I tried changing my email address to one already in use, it would show me an error but it would switch by user account to the user with the email address I entered.

After a bit of research, I discovered that the current user object was being re-saved to the session, and since forms bind data to the entity/model even if it’s invalid, the new email was getting saved. Not to the database, just to the session. A bit more research lead me to a simple fix, if the form validation failed, call refresh() from the Doctrine entity manager. This function restores an entity to it’s original state (From the database). Example below:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
<?php

/*
 * This file is part of the ------- application.
 *
 * (c) Brandon Wamboldt <brandon@sparkcreek.ca>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace App\UserBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RedirectResponse;
use App\UserBundle\Form\Type\EditProfileType;

/**
 * Controller for user profile pages like view profile, edit profile and change
 * password
 *
 * @author Brandon Wamboldt <brandon@sparkcreek.ca>
 */
class ProfileController extends Controller
{
    /**
     * Controller for editing the user's profile page
     *
     * @param  Request $request An HTTP foundation request object
     * @return Response An HTTP foundation response object
     *
     * @access public
     */
    public function editAction(Request $request)
    {
        $user = $this->get('security.context')->getToken()->getUser();

        // Create a new edit profile form
        $form = $this->createForm(new EditProfileType(), $user, ['user' => $user]);

        // Was the form submitted?
        if ($request->getMethod() == 'POST') {
            $form->bind($request);

            if ($form->isValid()) {

                // Save the user
                $em = $this->getDoctrine()->getManager();
                $em->persist($user);
                $em->flush();

                // Redirect the user
                $this->get('session')->setFlash('notice', 'Your profile has been updated');
                return new RedirectResponse($this->generateUrl('my_profile'));
            } else {

                // Reset to default values or else it will get saved to the session
                $em = $this->getDoctrine()->getManager();
                $em->refresh($user);
            }
        }

        return $this->render(
            'AppUserBundle:Profile:edit.html.twig',
            ['user' => $user, 'form' => $form->createView()]
        );
    }
}