LampJunkie.com - Everything related to Linux, PHP, MySQL, Apache, AJAX, Symfony and more

Using symfony sfForms in a Zend Application

marc — Sat, 05 Jun 2010 22:39:01 +0000

Recently I have been experimenting with the Zend Framework to look into it’s potential to be used in my future applications. Having been a symfony junkie for the last couple of years I was reluctant to try and use it, but I see that it has come a long way since last using it. I’m glad to see that there is finally the addition of the “zf” command line utility to help scaffold projects. While overall it’s a pretty solid framework, there are many things that I think are left to be desired when compared to symfony. The main thing I feel that is lacking is the form system within Zend.

I have grown to love symfony’s sfForm along with it’s sfWidget and sfValidator systems. I have been making heavy use of extending the sfFormObject class to easily create forms that update and return or create new model objects. Personally, I like to deal with domain objects as much as possible and not have to deal with passing around arrays in my action code.

So, I decided to see how easy it would be to use symfony’s sfForms within a Zend Application. I turns out that it’s really easy to get this working and have the best of both worlds!

For my example, I am going to base it on the Zend Framework Quickstart Documentation. I am going to assume that you have gone through the first couple of steps of creating the project, etc… What follows below is essentially a replacement for the Create a Form step.

Step 1. - Add symfony to your Zend Project

The first thing that you need to do is put the entire symfony core into your library so that you have access to the sfForm, sfWidget, and sfValidator classes, etc… So you simply grab symfony 1.4 from the installation page here.

Once you have the symfony core downloaded, you are going to copy the symfony lib directory to a new symfony directory in your project’s library folder.

At this point you’ll also want to create a Form directory to hold the forms class that you are going to create later on.

So you will have a structure like this:

myproject
|– application
|– library
| |– Form
| |– symfony
| |– lib
| |– action
| |– addon
| |– etc…
| |– Zend

Step 2. - Register some Autoloading

Now we need to make sure that Zend will be able to autoload any of the core symfony classes that we are going to use. So we do this by modifying the application Bootstrap class so that it looks like this:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
protected function _initSymfonyAutoload()
{
require_once 'symfony/lib/autoload/sfCoreAutoload.class.php';
sfCoreAutoload::register();
}
}

Now at this point we are ready to use sfForms to our hearts content!

Step 3. - Create a Form

Create a “application/forms” directory if it doesn’t exist and add the following Guestbook.php class:

class Application_Form_Guestbook extends sfForm
{
public function configure()
{
$this->setWidgets(array(
'email' => new sfWidgetFormInput(array('label' => 'Your email address:')),
'comment' => new sfWidgetFormTextarea(array('label' => 'Please Comment:'))
));
$this->setValidators(array(
'email' => new sfValidatorEmail(array('max_length' => 255, 'required' => true)),
'comment' => new sfValidatorString(array('max_length' => 255, 'required' => true))
));
}
}

Step 4. - Add Form to Controller

Now we add the form instantiation and processing code to the controller action. As you can see this is very similar as using the native Zend forms.

class GuestbookController extends Zend_Controller_Action
{
public function signAction()
{
// action body
$form = new Application_Form_Guestbook();
if($this->getRequest()->isPost()){
$form->bind($this->getRequest()->getPost());
if($form->isValid()){
// get cleaned, valid form values
$values = $form->getValues();
// map to model, etc…
return $this->_helper->redirector('index');
}
}
$this->view->form = $form;
}
}

Step 5. - Add Form to View

Finally, we add the form rendering to the sign.phtml file:

<form action="url(); ?>" method="post">
<table>
echo $this->form; ?>
table>
<input type="submit" value="Save" />
form>

As you can see, getting sfForms to work in Zend is pretty easy once everything is set up. Now you can take advantage of the many neat things you can do with symfony forms.

Wishing that PHP had something like JAXB

marc — Sun, 09 May 2010 09:48:56 +0000

Lately I have been doing alot of Java development especially in regards to web service development and consumption. One of the tools that I have relied on heavily is the JAXB project to consume and create XML feeds. This has been a godsend and made my life easy when parsing and creating XML. By just using a small amount of code and annotations parsing XML is a breeze.

After using JAXB for awhile, it got me thinking….why doesn’t PHP have something like this…how hard would it be to create? On the PHP side of things I have been in love with SimpleXML since I first started using it a number of years ago. Just like the name implies, it is relatively simple. But, could something be developed that would be even simpler like JAXB?

The thing that really makes parsing XML with JAXB easy is the ability to use annotations to map classes and properties to XML nodes. Of course PHP doesn’t have built-in support for annotations, but this can be achieved by using the Extended Reflection API or using a project built on top of that such as addendum. It would also be possible to create a PHP extension to handle this in a much more efficient manner.

This is how I envision being able to parse (unmarshal) XML to a PHP object graph:

Given the following sample XML:

>
>
url="http://ad1-url">
>My Title>
>Some Description>
>
url="http://ad2-url">
>My Title>
>Some Description>
>
>
>

Convert to an object graph like this:

/**
* @XmlRoot(name="result")
*/
class Result {
/**
* @XmlCollection(name="ads")
* @var array
*/
private $ads;
// getters/setters
}
/**
* @XmlElement(name="ad")
*/
class Ad {
/**
* @XmlAttribute(name="url")
* @var string
*/
private $url;
/**
* @XmlElement(name="title")
* @var string
*/
private $title;
/**
* @XmlElement(name="description")
* @var string
*/
private $description;
// getters/setters
}
// grab an XML feed
$xml = file_get_contents('some-xml-from-somewhere.xml');
// create our unmarshaller and tell it where to find classes to unmarshal to
$unmarhaller = new SimplerXmlUnmarshaller("/package/location");
// unmarshal to an object graph
$result = $unmarshaller->unmarshal($xml);
// loop through objects
foreach($result->getAds() as $ad){
echo $ad->getUrl() . '
' . $ad->getTitle() . '
' . $ad->getDescription() . '
';
}

Hopefully in the near future I will get time to develop a proof of concept to see if this works and take it from there…

PHP SoapClient and Polymorphic Service Objects

marc — Fri, 02 Apr 2010 18:48:15 +0000

There may be a time when you need to deal with passing polymorphic objects back and forth between PHP’s SoapClient and a SOAP web service. Things are nice and easy (work as expected) when you are retrieving these objects from a service. But, when it comes time to pass these objects back…well…it’s not as simple as one would hope.

For the following examples, we are going to assume that we are connecting to a service that has methods that return and accept an abstract type named “Animal”. Animal can be an instance of Dog or Cat.

- Animal
— Dog
— Cat

Now let’s assume that there are two methods in the service:

getAnimalById(Long id)
saveAnimal(Animal animal)

Here is a snippet of what the WSDL for these service methods and types would look like:

name="getAnimalById">
>
name="id" type="xs:long" minOccurs="0" />
>
>
name="getAnimalByIdResponse">
>
name="return" type="ns1:Animal" minOccurs="0" />
>
>
name="saveAnimal">
>
name="animal" type="ns1:Animal" minOccurs="0" />
>
>
name="saveAnimalResponse">
/>
>
name="Animal" abstract="true">
/>
>
name="Dog">
>
base="tns:Animal">
/>
>
>
>
name="Cat">
>
base="tns:Animal">
/>
>
>
>

Now, using this information we are going to write our PHP classes which map to these service types:

abstract class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

Now, we will test out calling the service to try and get one of these implementing types:

// define our service to client class mapping
$classMap = array('Animal' => 'Animal',
'Dog' => 'Dog',
'Cat' => 'Cat');
// create client with classmap
$client = new SoapClient("http://my-service-url:8080/AnimalService?wsdl", array('classmap' => $classMap));
// get an animal
$result = $client->getAnimalById(1);
// what did we get?
var_dump($result);

Assuming that id:1 is supposed to return a Dog, we will see that this works as expected when the previous code is run:

object(stdClass)[42]
public 'return' =>
object(Dog)[43]

Now, we will see how passing a Cat object to the saveAnimal() method doesn’t work as expected:

// meow!
$cat = new Cat();
// oh-oh!!!
$client->saveAnimal(array('animal' => $cat));

Chances are that the service will return some sort of SoapFault exception like “Unable to create an instance of Animal…”.

The problem here is that by default PHP’s SoapClient does not automatically take the implementing Cat object and pass it to the service as a Cat. Instead, it only sees that saveAnimal() is expecting an Animal type, so that’s what it gives it. Luckily, there is a solution to this problem with a little extra code.

The solution is to manually create a SoapVar object to wrap around the object that we are trying to pass into the service method. The important things here are that you need pass it the object, the name of the concrete class (Cat), and the namespace that the Cat type belongs to within the WSDL service definition.

Here’s what the revised code may look like:

// meow!
$cat = new Cat();
// create our SoapVar wrapper
$catSoapVar = new SoapVar($cat, // the object to wrap
SOAP_ENC_OBJECT,
get_class($cat), // the concrete class name
'http://animals.lampjunkie.com' // namespace that Animal, Dog, Cat belong to (in WSDL)
);
// purr…
$client->saveAnimal(array('animal' => $catSoapVar));

Get PHP SoapClient to speak with Java’s JAX-WS

marc — Mon, 29 Mar 2010 07:32:25 +0000

When delving into the magical world of trying to get a PHP SoapClient to consume a Java JAX-WS web service, there may be a few unexpected surprises that pop up. If you have been using SoapClient to communicate with other PHP SoapServer service, things are pretty straightforward. However, things get slightly more complicated when trying to call Java based JAX-WS services. Luckily, there are some simple solutions to make it a breeze to get these two to communicate seamlessly.

The Request Problem

When you first try to consume a Java JAX-WS web service, chances are that you try to call a method on that service using something like the following:

$client = new SoapClient("http://some-service-url:8080/MyService?wsdl");
$sum = $client->add(1, 2);

As you soon discover, this throws a SoapFault error such as the following:

Fatal error: Uncaught SoapFault exception: [S:Server] java.lang.NullPointerException ….. etc…

Basically the problem is that JAX-WS is never getting the method parameters that we are trying to send over…

The Solution

Unlike calling another PHP SoapServer web service which will work flawlessly with unnamed parameters, JAX-WS is expecting just a little more. If we take a look at the WSDL for this service method, we see the following:

name="add">
name="parameters" element="tns:add"/>
>
name="add">
>
name="a" type="xs:int" minOccurs="0"/>
name="b" type="xs:int" minOccurs="0"/>
>
>

So, what we see here is basically that the add() method is expecting an "add" request object. What we need to do is wrap our parameters into a request object so that JAX-WS will know how those parameters are mapped to the parameters it is expecting. This can easily be achieved by using PHP’s handy stdClass. So now our code becomes:

$addRequest = new stdClass();
$addRequest->a = 1;
$addRequest->b = 2;
$response = $client->add($addRequest);

However, we can simplify this even more by using an associative array for the parameters. SoapClient will automatically know to translate an associative array into a complex type for the web service. So now we can do this:

$sum = $client(array('a' => 1, 'b' => 2));

Sweet! That’s much simpler, plus now it’s clear what each of the parameters are!

The Response Problem

Soon you will discover that this web service is not returning what you expected. Looking at the example, you would expect that the service simply returns an integer with the value 3. Sadly, it’s not that simple. The JAX-WS services will always pass back a response object for each method. By examining the response in the WSDL, we can see exactly what is happening:

name="addResponse">
>
name="return" type="xs:int" minOccurs="0"/>
>
>

So, the add() method is returning an addResponse object. Since we have not defined any class mapping for our SoapClient, this response simply gets returned as a stdClass object with a single property named "return". With this knowledge, we can now see that we need to access the response like this:

$addResponse = $client->add($addRequest);
$sum = $addResponse->result;

The Ultimate Response Solution

While the response example above shows a solution to getting the correct response, it isn’t necessarily the most elegant. When calling a service method and getting the result, it would be nice to automatically have the value you are expecting instead of having to add one more step of grabbing the final result from an object.

Luckily this can be easily achieved by extending the SoapClient class and tinkering it just a little bit. We are going to simply extend the class, overload the __call magic method, and do our response parsing in there.

So, here we create our new JAX-WS specific SoapClient class:

class JaxWsSoapClient extends SoapClient
{
public function __call($method, $arguments){
$response = parent::__call($method, $arguments);
return $response->return;
}
}

Now, we can do this:

$client = new JaxWsSoapClient("http://some-service-url:8080/MyService?wsdl");
$sum = $client->add(array('a' => 1, 'b' => 2));

Writing Custom PHP Extensions to Speed Up Applications

marc — Sun, 10 Jan 2010 00:20:50 +0000

Sometimes you may come across a situation where a core piece of your PHP is doing some sort of intensive algorithm or something else which is just taking way to long.

Recently I had this problem with an application which I was developing. Essentially I was redesigning an existing application that needed to be able to handle millions of requests every day. Inside of the original application was a core utility class that needed to encrypt query string parameters using a key based caesar cipher. The existing code was as optimized as it could be within PHP, but there were serious issues when we needed to encrypt 10+ links per page view. The average time was somewhere in the range of ~300ms just to run the encryption. Inside the encryption method was a loop that went through each character of a query string to convert it to it’s ASCII code and rotate those codes to perform the encryption.

This was one of those times when PHP really showed it’s weaknesses for intense “calculations”. After thinking about the problem for awhile, I decided to first convert the encryption/decryption methods to C++ and just use PHP’s exec() function to call the compiled C++ code. This worked, but just felt a little too weird…

After thinking about the problem some more, it hit me…how about I just convert the program to a custom PHP Extension! So then the journey of trying to find documentation and tutorials on how to do this began. After a few days I was able to write an extension and install it within PHP. Basically I designed the extension so that it exposed those encryption/decryption methods within a static class that can be used from any application on the server. The final results were that it took less than 1ms to encrypt all the querystrings in one shot. Much better!

Using this new found knowledge I was able to take another core class which used PHP’s Extended Reflection API to parse annotations within the docblocks of database model classes to map them to their respective tables and columns.

Once you understand how to use the Zend Engine’s internal API to build your custom extensions, the possibilities are endless. At that point it’s a trivial matter to convert your PHP code to C and compile your extension. But, figuring out where to find tutorials, etc on how to do this is the biggest hurdle to get over.

Here are some resources to get you started in the right direction:

Custom Tasks in Symfony 1.1

marc — Tue, 15 Jul 2008 19:04:44 +0000

Awhile ago I wrote a post on how to create custom tasks in symfony 1.0. A reader posted a question on how to do this in symfony 1.1. At first I figured out a solution of how to do it manually, but then I discovered this tutorial on the symfony cookbook section: http://www.symfony-project.org/cookbook/1_1/en/tasks which describes exactly how to do it!

As the tutorial describes, there is a new symfony task to help creating the skeleton classes for your own tasks! Sweet, it couldn’t be any simpler!

PuTTY with Tabs (PuTTY Connection Manager)

marc — Fri, 23 May 2008 22:52:44 +0000

Whenever I am using a Windows desktop and I need to connect to various servers via SSH, I use PuTTY. It’s lightweight and gets the job done without any problems. However, the one problem has always been that I may have 10 different instances open and it’s a pain in the ass to switch between them.

In the past I’ve tried to find other SSH clients for Windows that featured tabbing, but none of them were really quite what I was looking for. I tried Ponderosa, which was pretty good, but ran into weird issues with the rendering when scrolling in Nano.

Now, today I received a message on a PHP mailing list about the PuTTY Connection Manager which will manage multiple instances of PuTTY by giving you tabs! Yay!!!!

I encourage anyone who needs to use windows to connect to various servers to check it out:

PuTTY Connection Manager

Store Symfony Sessions in Database with Propel

marc — Fri, 23 May 2008 17:17:21 +0000

Previously, I wrote a post on how to store user sessions in a database using Doctrine. I figured that I would follow it up by writing this article to demonstrate how to do the same thing using Propel. The steps are pretty much similar, but with some slight variations.

Step1 - Create your sessions table

CREATE TABLE IF NOT EXISTS `sessions` (
`sess_id` varchar(64) NOT NULL,
`sess_data` text NOT NULL,
`sess_time` int(11) NOT NULL,
KEY `sess_id` (`sess_id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

Step 2 - Edit /config/databases.yml

You need to make sure that you have a connection set up for the session database. So edit /config/databases.yml so it has something like the following:

all:
sessions_db:
class: sfPropelDatabase
param:
dsn: mysql://my_user:my_password@localhost/my_sessions_db

Step 3 - Edit the app/config/factories.yml

You will need to let symfony know that you are going to be using the sfMySQLSessionStorage class to handle your session storage, so edit /app/config/factories.yml:

storage:
class: sfMySQLSessionStorage
param:
db_table: sessions # Name of the table storing the sessions
database: sessions_db # Name of the database connection to use

Finally, make sure to clear your cache and you should be all set!

Step 4 - Configure symfony session cleanup, etc.

Andy, from blog.t8d.de posted some additional findings and links on their blog about some settings that you will want to change within symfony and your php.ini to make sure that your application is performing the proper session cleanup.

Check out:

You know your Website is soooo Web 1.0 When…

marc — Tue, 20 May 2008 23:33:43 +0000

We all have seen them…those websites that are still caught somewhere in the year 1999 - 2002. Here’s a checklist to make sure your site isn’t stuck in Web 1.0 world

1. Your website’s pages end in any of the following: .asp, .php3, .php4

2. You have a 30 second Flash Splash Page.

3. You have an all flash site that displays in a popup window.

4. There are only 20+ tables on each page, not one div…oh and no CSS.

5. You only know how to make a two column layout with frames.

6. Your site says “Best viewed with Internet Explorer 5.0″ somewhere on it and you really mean it.

7. The closest thing to AJAX is that text in the or tags.

8. Trying to find the site in Google yields nothing since all of your pages contain a single image encompassing your layout and all content.

9. Your streaming video is that animated GIF on your home page.

10. Your idea of social networking is that guestbook CGI script.

Remove CVS or .svn Directories from the Linux Command Line

marc — Mon, 19 May 2008 03:57:16 +0000

So, you copied a bunch of directories from one source controlled project to another and you don’t want to go through and delete all those CVS or .svn directories by hand? Ok, no problem…

Below are two snippets that will show you how to recursively remove those directories from the Linux command line in one quick instant. Just be sure that if you click-paste these into your shell window, that you are already in the top directory off where you want to delete stuff. I’ve made the mistake of doing it in the wrong folder without thinking and it automatically deleted all my CVS files for an entire project!

For CVS:

find . -name CVS -prune -exec rm -rf {} \;

For SVN:

find . -name .svn -prune -exec rm -rf {} \;