Matt Read, Weblog

hConsole: A Live Habari Console

2013-10-03T10:55:19-04:00

If you have ever written code before, you’ve come across a situation where you needed to debug or test something simple in your code. Doing this with a Command Line Interpreter is quite simple. Type your code, see what comes out. But when it comes to web applications, it’s a little harder. There are HTTP requests, Sessions, Cookies, and a Webserver involved. This is where hConsole comes in.

hConsole is a live Habari console, or command line, that allows you to evaluate your code directly in your Habari installation, with all the HTTP request, Sessions, etc. there. You can access the entire Habari core, even trigger plugin actions and filters, and view the live result on screen.

Once installed, you simply click on the hConsole button in the bottom right of your screen to bring up the console. In the console you can evaluate any PHP code and utilize the entire Habari base. You can also execute SQL, to query your Habari’s database directly (Tip: press ctrl+Q to run code without the mouse).

Figure 1 Using the debug area to output code.

Debugging PHP and Habari

hConsole has 2 parts; A debug section, for outputting variables and such (Utils::debug() comes in handy here), and the ability to trigger plugin hooks and affect the output of, say, post titles. There is also an option to htmlspecialchars() the output of the debugging code if you wanted to output HTML tags, for example. Let’s look at two basic examples:

$test = "this is a test";
echo $test;

Example 1 A simple Debug echo

The code in example 1 will simply echo the variable $test above the command line in hConsole; The so called “Debug Area”. We can also implement plugin hooks.

filter_post_title_out {
    function boo ($title)
    {
        return $title . ' Boo!';
    }
}

Example 2 Filtering Post Titles

The code in example 2 will register the function boo() to the post_title_out filter. Function boo() then appends " Boo!" to all post titles for the page you are looking at. We can also combine the two and have debug output along will running filters or actions.

Of course these are very simple examples of what can be done with hConsole. In the real world it becomes a very powerful tool.

Debugging With hConsole

Let’s look at an example of a real debugging situation where hConsole came in handy. When trying to debug Habari’s internal Cron system it’s hard to tell why it’s failing when PHP is set to use CURL. Recently Scott was having an issue with a local install, where crons weren’t running.

The issue comes from the fact that Habari makes an asynchronous HTTP call to itself to trigger all the Cronjobs to run. So you never actually see any errors from this, and when CURL throws an exception, nothing is in the logs. So to test why Scott’s crons where not running he used hConsole.

$cronurl = URL::get( 'cron',array( 'asyncronous' => Utils::crypt( Options::get( 'public-GUID' ) ) ) );
$request = new RemoteRequest( $cronurl, 'GET', 100 );
$request->execute();

Example 3 Making a request to the cron.

In example 3 we run the cron trigger using hConsole with a longer timeout so we can see what is happening. And Scott was able to get the error Exception: CURL Error 60: SSL certificate problem, verify that the CA .... He was then able to add his SSL certificate chain to his Apache config so CURL accepted the certificate, and crons ran smoothly.

Debugging SQL

hConsole will also let you directly run SQL statements on your database. It will even substitute proper table names when using “curly brackets”, like {posts} becomes habari__posts, or whatever you chose during install. You can run any database query by simply checking the SQL checkbox, and the results will output in a nicely formatted table.

select * from {posts} limit 3;

Example 4 SQL selecting the 3 most recent posts.

And the results from running example 4 show in a nice tabular format so we can easily see what’s in our database.

Figure 2 Results of selecting the 3 most recent posts.

You can also, of course, run other statements, such as delete, update, show tables, etc. All statements will output their results, or show an error if there are troubles.

Developer’s Best Friend

As you can see hConsole is the plugin and theme developers best friend. Whether you are debugging a core Habari issue, or simply looking at the contents of an object. You can pretty much debug and test any code you need to; PHP, SQL, and Habari.

Ephyboy, The Epiphany Tomboy Extension

2011-12-27T01:12:10-05:00

Back in the day when I used to use Firefox, I fell in love with the Tomfox extension. It allowed you to create a new Tomboy note using the currently selected text of the webpage you were browsing, using the title for the title of the note and referencing the url as the source. This was great for me to document all the code and Linux commands I’d find scattered around the net.

Eventually, though, I got tired of Firefox, especially it’s load times, and switched to Chromium. You guessed it, Chromium sucked too. So back to Epiphany I went, and with the 2.30 version it is really quite a nice little browser.

Epiphany extensions are now done with Seed, the GTK javascript bindings, making it really easy to write new extensions. Plus, it has almost a complete GTK implementation via GObject Introspection. So getting my tomboy note maker dohicky back was really not that hard —aside from the lack of documentation. And thus, Ephyboy is born. It’s really quite simple:

Download the tarball, or zip.
Install the extension.
Enable the extension (no restart required!).
Select some text to add in your note.
Hit CTRL+Shift+B; Or, add the Tomboy Note button to the toolbar and click the button.

The extension will then create your note and open your note in Tomboy for review and/or further editing.

There is one thing to note. The extension works by making a DBus call to Tomboy to create the note so you have to have Tomboy open and connected to the bus for this to work. Usually not a problem as I have Tomboy start on log in.

Javascript Prototype Behaviour in PHP

2008-09-29T00:55:09-04:00

One of the “neat” things in Javascript is you are able to dynamically add or change methods of a class and automatically update every instance of that class. Some of the things I usually find useful are adding to the String class, like so:

/g,'>');
}
String.prototype.trim = function() {
    return this.replace(/^\s+|\s+$/g, '');
}
]]>

Obviously we cannot do this in PHP, and why would we, right? However we can emulate this behaviour to a certain extent using my “neat” little Prototype class. With this Prototype class we can dynamically add properties and methods to any class, and they will be inherited by all instances of that class.

Let’s look at the following “normal” PHP code.

name, $this->gender);
    }
}

$matt = new Person;
$matt->name = 'Matt';
$matt->gender = 'male';
$matt->gender();

// Matt is male
]]>

Now, there is nothing magical or out-of-the-ordinary going on here. We just instantiate the Person class and setup some properties. Calling the gender() method outputs a nice little string for us.

However, you see that the Person class is actually a child of the Prototype class. This will allow us to do some of that “neat” Javascript stuff. Using Prototype, let us expand the Person class to add an $age property and an age() method to output a nice string. Like so:

name, $this->age, $this->gender);');

$matt->age = 28;
$matt->age();

// Matt is a 28 year old male
]]>

Now all instances of Person inherit the $age property and age() method. So we can create a new Person, Susie, and this object will now have the age stuff.

name = 'Susie';
$susie->gender = 'female';
$susie->age = 21;
$susie->age();

// Susie is a 21 year old female
]]>

One limitation of the Prototype class though, is you cannot overload a current method. So the following code, that attempts to overload the gender() method, will not work.

name, $this->age, $this->gender);');

$matt->gender();

// Matt is male
]]>

There are also many, many, many other problems with this Prototype class. Some of which are:

The ‘$this’ keyword is reserved, so it actually does a string replace and uses ‘$self’ instead.
You cannot access/add new methods or properties statically (until PHP 5.3 with __callStatic()).
It uses create_function, so every “method” is actually defined in the global namespace.
Iteration does not work, although it could possibly be done with Iterator, Countable, et al.
You cannot reference static variables/methods in your add method.
You cannot share methods between classes.
And so on and so forth…

This class was just an experiment to see if it was at all possible to implement something like Javascript’s prototype behaviour in PHP with out using the Runkit PECL extension. I had no intention of actually making this usable in production, for many reasons ;), although it was fun.

Persistent Static Variables

2008-06-12T01:44:33-04:00

Wait, What? Yeah that’s what I thought too. Still no Idea what I’m talking about? Well, let’s take a look at the following code. Let’s call it “fred”.

class foo {
    function bar( $b = 0 )
    {
        static $a = 0;
        if ( $b ) {
            $a = $b;
        }   
         echo $a;
    }
}

$faz = new foo;
$faz->bar(3);
$baz = new foo;
$baz->bar();
foo::bar();
foo:bar(1); 
$faz->bar();

The code above, named “fred”, basically creates a static variable $a inside the function foo(). When you call foo(0) it outputs the value of $a. When you call foo('x') , where x can be anything, it updates the value of $a with 'x', and outputs the new result.

Now, what would expect “fred” to output? If your like me, then you are completely wrong. “fred” will actually output the following code.

bar(3); ==> 3
$baz->bar();  ==> 3
foo::bar();      ==> 3
foo:bar(1);     ==> 1
$faz->bar();   ==> 1
 
Expected outputs:
$faz->bar(3); ==> 3
$baz->bar();  ==> 0
foo::bar();      ==> 0
foo:bar(1);     ==> 1
$faz->bar();   ==> 3
*/
]]>

Yes, that’s what I said at the start, “Persistent Static Variables Across Instances”. The static variable $a actually persists across the two instances of foo that “fred” created, and even into the static method call. This was completely unexpected, at least by me. So I’ll ask, does anyone know if this is actually the expected behaviour, and why it is or is not?

Drunken Monkey Labs

2007-04-07T09:01:22-04:00

I would like to introduce Drunken Monkey Labs. My new site to host and support all of my coding and web projects. This site will become solely my personal blog. Simplifying the orginizational aspects of the site and truly making mattread.* the personal site of Matt Read, me, as it says.

If you are looking for any of my projects, formely hosted here, check Drunken Monkey Labs and expect to see some pretty cool stuff coming out of the labs.