One problem persists [with Zend Framework's Application.ini] although: the documentation. All the parameters for components like View, Session, Database etc. are documented either with the bootstrap resource, the component itself or both. Some of them are even completely undocumented and have to be extracted from the framework source code. Unfortunately there is no reference of all possibilities of the application.ini. To make my life – and that of other Zend Framework developers – a little bit easier, I created such a reference in form of an application.ini file with all possible options, grouped by resource and with some links and explanations.

The resulting application.ini can be found on gitup at the feibeck/application.ini. Be careful though, it is so complete and beautifully laid out, you may be tempted to print it out and frame it for office art rather than use it and start hacking it up.

As seen on phpdeveloper.org.

After working through that [Rob Allen's] tutorial, the next thing I wanted to do was figure out how to get the Doctrine 2 ORM up and running.

This article shows how to set up and use Doctrine 2 in Zend Framework 2, by extending Rob’s Getting Started tutorial to use Doctrine instead of Zend_Db.

Jame’s tutorial is long on the how but short on the why. If you are just looking for the steps to take, this is a great piece. If however, you are wondering why you take each step and what the ramifications are, well, you’ll be left a little lost.

Zend Server on OSX

This is one of the most requested features of Zend Server and now that it is available, people are talking about it.

Dr. Dobbs

Dr. Dobbs covered Zend Server on OSX in the tools section of their blog recently with an article titled “Zend Server 5.6 Now Supports Mac OS X“. In that article posted on January 22, 2012, they had this to say.

The 5.6 version release ships with a fully integrated PHP stack including the latest PHP runtime and the Zend Framework, plus monitoring and diagnostics. There are code acceleration and performance optimization technologies such as the Job Queue function, as well as full page caching and data caching to help developers improve application response times and reduce server load.

ServerWatch

Over at ServerWatch.com Vangie Beal wrote a nice post titled “New Zend Server Release Supports Mac OS X Platform Developers“. Here is what Beal had to say.

For the growing numbers of IT organizations using PHP and bringing Macs into the development environment, Zend said its 5.6 release offers important advantages for both app performance and quality, and productive collaboration on the web and in the cloud.

Both articles are short reads but interesting if you are considering introducing Zend Server on OSX into your development team.

phpcloud.com

The newest member of the Zend product lineup, phpcloud.com, got a little love as well. InfoWorld.com recently posted a nice review of it titled “First look: Zend’s PHP developer cloud“. Author Rick Grehan takes a nice, in-depth look at phpcloud.com and has this to say about it.

When you consider the cloud, you typically imagine a realm of deployed, production applications. Zend Developer Cloud (ZDC) adds a twist: ZDC creates a place in the cloud where PHP-based applications can be developed for the cloud. No more developing locally, then deploying into the cloud — ZDC pushes both into the ether.

This article is a bit longer than the other two but a great read none the less.

Ok, so you’re pretty comfortable with using the Zend Framework, specifically the use of Forms. Along with that, you have a good working knowledge of how to combine a host of standard validators such as CreditCard, EmailAddress, Db_RecordExists, and Hex, and standard filters such as Compress/Decompress, BaseName, Encrypt, and RealPath. But what do you do when a situation arises that’s outside the scope of the pre-packaged validators and filters?

Let’s say you want to guard against users uploading files that contain viruses, for example. You would have to write a custom validator that checks the uploads aren’t infected. Today I’ll show you how to do just that – how to write a new file validation filter for Zend Framework that uses ClamAV to ensure uploaded files are virus-free.

It’s not a beginner level tutorial but it is well written and a great explanation of how to built a custom validator.

Survey Highlights

Tech Investment and Developer Focus Areas for 2012

Key areas of technology investment are revealed by the types of projects that developers expect to tackle as well as their priorities for career and skills development in the new year.

Key project focus areas:

• 66 percent of developers will be engaged in mobile app development projects
• For each of these four key technology areas — APIs, cloud, social media integration, and big data/analytics — between 40-50 percent of developers said they will have projects underway in 2012

Career and skills development priorities:

• Next-generation UI development scored high both in the large enterprise and overall (75 percent)
• 67 percent of all developers surveyed are looking to hone their app development skills on mobile platforms, and 46 percent in cloud computing environments
• As one might expect, among corporate developers at companies over 100 employees, another priority is gaining expertise with Big Data/analytics (44 percent)

Cloud Opportunities on the Rise

• More than 60 percent intend to use some form of public cloud in their development projects. Inside the Zend Developer Pulse^™ Survey Report, you can find out which public clouds developers are working in now
• As far as skills are concerned, 46 percent of all developers surveyed are looking to hone their skills in cloud computing. This result is consistent with the high level of interest that Zend is seeing at phpcloud.com, where developers are actively building apps for the cloud, in the cloud, in the free Zend Developer Cloud sandbox.

State of Languages

The new norm among developers is use of multiple languages, and rising use of dynamic open source languages, and the Zend Developer Pulse^™ survey echoes this trend.

• Four languages, PHP, C, Java and Javascript dominated survey results, with a number of other languages trailing far behind
• Developers reported using 1-2 additional languages on a regular basis; as high as 33 percent of enterprise developers report using both PHP and Java
• Two-thirds of all developers surveyed spend more than 50 percent of their time with PHP, using PHP as their core language; this includes an uptake of PHP in the enterprise

Increasing Demand for PHP Skills

From an employment perspective, more than half of developers surveyed see increasing demand for PHP skills in 2011-12. Inside the report, you can find out how this aligns with the findings of leading online job search companies, what developers are saying about language use today, and what other skills they’re looking to add to their bag of tricks.

Just for Fun

It turns out that 86% of developers surveyed prefer to listen to music while coding, so Zend asked about their music preferences.  To get 2012 off to a good start, developers shared their New Year’s resolutions, also captured in the report.

Developers are invited to contribute suggestions and questions they’d like to see addressed in future Zend Developer Pulse^™ survey reports. It’s as easy as sending an email to developerpulse@zend.com.

When you log into phpcloud.com for the first time, you are presented with a screen that has a big blue button, “Start Now”. Clicking this button is the first step. WAIT! Before you click it, let’s cover a few things.

First, what you are about to create is a “Container”. Containers can contain multiple applications and all share a database. Containers can be cloned by taking a snapshot. In some cases, you will want to run a single application in a single container. Other times – as long as you are careful to avoid database table name collisions – it’s fine to run multiple applications inside a single container. If it’s easier, think of a container as a server instance. Whatever you would normally do on a single server, do that with your container.

You are going to have to name your container and the thing you need to know is that the container namespace is global. (Someone already has “test, I checked) As with everything, if you are just playing around, your container name doesn’t really matter since no one else will see it. However, if you are setting up your development environment for work, useful names are better than Loony Tunes Character names.

Once you understand what a container is and what you are going to call it, go ahead and click the big blue button. Fill out the form – don’t use password as the actual password – and click the “create Container” button. phpcloud.com will tell you if your password is weak, normal or strong but it won’t prevent you from using a weak password.

Since this is a fly-by, we’ll skip discussing how to setup an SMTP server but if your application is going to send mail using the mail() function in PHP, you will need to configure one at some point.

Now we play the waiting game. Fortunately for us, it usually takes about 30 seconds to create a new container. While you are waiting, go ahead and download your access key in the proper format. This is your only way to access the code and database in your new container. Because this is a cloud container and not a specific server, you can’t just ssh in and see your code. You can however, create ssh tunnels so you can use your favorite IDE or MySQL tool. There’s a good tunneling overview that will show you want you can and can’t do with an ssh tunnel. Of course you will also need your keys to deploy code either over sftp or git.

Containers are all well and good but they do nothing but contain things. To actually make something happen, we need to setup an application. As mentioned above in the discussion of containers, you can have as many applications in a container as you need. The only caveat is that they all share a common database.

When you created your container you automatically created the default application inside of your container. This default application is an empty PHP application ready for you to start pouring code into. If that is what you need, you can use the default application and not worry about adding applications. If your needs are different though, you can delete the default application and install a new one. phpcloud.com’s application installer lets you setup an empty PHP application, a Zend Framework (1 or 2) application, or one of five open source packages.

Once you have your application setup, you can setup git or sfpt access to start deploying code or you can create other applications inside your container.

That’s it, you are now up and running. If you installed WordPress, you can go to the admin page and log-in. If you created an empty application (Zend Framework or other) you can begin pouring code into it and making things work. There is a lot more that you can do with phpcloud.com; the point of this article was just to get you started.

If you came here to learn about elementary PHP 4 or basic PHP 5, this is for you. Enjoy!

• PHP 101 (part 1): “Down the Rabbit Hole”
  An introduction to PHP’s variables and operators.
• PHP 101 (part 2): “Calling All Operators”
  The rest of the PHP operators (there are many), and simple form processing.
• PHP 101 (part 3): Looping The Loop
  Basic control structures explained.
• PHP 101 (part 4): The Food Factor
  Arrays, PHP array functions, and what it all means.
• PHP 101 (part 5): Rank and File
  Everything you’re ever likely to need to know about dealing with external files from a PHP script.
• PHP 101 (part 6): Functionally Yours
  All about functions, arguments, passing by reference, globals and scope.
• PHP 101 (part 7): The Bear Necessities
  A gentle introduction to object oriented programming in PHP 4 and PHP 5.
• PHP 101 (part 8): Databases and Other Animals – Part 1
  All about connecting to a MySQL database from PHP, using the mysql or mysqli extensions.
• PHP 101 (part 9): SQLite My Fire! – Part 1
  Introducing another database: SQLite.
• PHP 101 (part 10): A Session In The Cookie Jar
  Sessions and cookies – how to keep track of visitors to your site.
• PHP 101 (part 11): Sinfully Simple
  An introduction to PHP’s easiest method for dealing with XML.
• PHP 101 (part 12): Bugging Out – Part 1
  Basic error handling.
• PHP 101 (part 13): The Trashman Cometh – Part 1
  A primer in basic security.
• PHP 101 (part 13): The Trashman Cometh – Part 1
  Putting the pieces together – a first Web application.
• PHP 101 (part 15): No News is Good News
  Creating a simple RSS news aggregator.

If you are sitting on something you would like to see included, or are interested in reviving a proposal to have included in 1.12 (including from the archived proposals list), please get in touch with the CR-Team (zf-crteam@zend.com), and/or move your proposal to the ‘Ready For Recommendation’ section in http://framework.zend.com/wiki/display/ZFPROP/Home

This release will be in the interests of forward compatibility, to provide an easier transition to ZF2 so if you have any ideas which could help with that, now is the time to make them heard.

In addition to any new components proposed, the Autoloader and EventManager from current ZF2 development will also be included in the release! Along with new Cloud \ Infrastructure and Rackspace components.

A page for tracking the 1.12 release has been created in the wiki for you all to keep up to date with progress:

http://framework.zend.com/wiki/display/ZFDEV/Zend+Framework+1.12

Background

“The cloud is for everyone. The cloud is a democracy.”
Marc Benioff (CEO, Salesforce.com)

The cloud business is growing very fast, cloud is everywhere and web applications are using these services more and more frequently. In order to manage cloud services, PHP developers need to use specific API provided by the vendors. That means spend time and energy to become familiar with different PHP libraries. Few years ago, Zend Technologies with the contributions of other companies like IBM, Microsoft, Rackspace, etc, started a new initiative, the Simple Cloud API to produce a general PHP component to manage different APIs, exposing a single interface. The main scope of the Simple Cloud API iniziative is to unlock application from the effect of vendor lock-in, that is make a customer dependent on a vendor for products and services. Using the Simple Cloud API, PHP developers are free to choose the cloud vendors using an unique API to access the cloud services.

Starting from 2 November 2010 the Simple Cloud API has been included in the Zend Framework 1 project, under the Zend_Cloud namespace. This component of ZF implements three generic cloud services, that are:

• Document (to manage a key/value database);
• Storage (to manage a store system);
• Queue (to manage a queue system).

The vendors supported, for these components, are reported in the following table:

Recently, cloud vendors have relased also infrastructure services and we decided to extend the Zend_Cloud component with the Zend_Cloud_Infrastructure. This new component is able to manage cloud infrastructure based on instances (servers) with specific actions: start/stop/restart an instance, monitoring an instance, run remote commands on an instance (deploy), etc.
So far the Zend_Cloud_Infrastructure supports the follwing adapters: Amazon EC2, and Rackspace. We (the Zend Framework team) are working on the Windows Azure and GoGrid adapters. Moreover, because we released the Rackspace adapter, that is based on OpenStack, we are going also to release the OpenStack infrastructure adapter very soon.

Architecture diagram of Zend_Cloud

If you are using Zend Framework 1 you can start to use the Zend_Cloud_Infrastructure by downloading the latest SVN from trunk (http://framework.zend.com/svn/framework/standard/trunk), and it will be available in a public release starting with 1.12.0, which we plan to ship in a couple months.
If you want to use the ZendCloudInfrastructure for Zend Framework 2 you can download the beta1 release (click here to download).
We provided a packaging system for ZF2, that means you can install just the ZendCloudInfrastructure package if you want. Check the packages.zendframework.com web site to discover how to do that.

Zend_Cloud_Infrastructure

In order to provide a common API for different cloud vendors the Zend_Cloud_Infrastructure abstracts a common set of basic operations for the management of instances (servers).
These operations are:

• create a new instance;
• delete a new instance;
• start/stop an instance;
• reboot an instance;
• list of the available instances;
• get the status of an instance;
• wait for a status change of an instance;
• get the public IP or DNS name of the instance;
• list all the available images for new instances;
• list all the available geographical zones for new instances;
• monitor an instance getting the systems information (CPU%, RAM%, DISK%, NETWORK% usage);
• deploy of an instance (run arbitrary shell script on an instance).

This infrastructure class uses a factory design pattern to manage different cloud vendors (adapters). That means in order to use this class you have to initialize the factory choosing a specific adapters. For instance, to work with the Amazon EC2 adapter you have to initialize the class with following parameters:

$key    = 'key';
$secret = 'secret';
$region = 'region';

$infrastructure = Zend_Cloud_Infrastructure_Factory::getAdapter(array(
    Zend_Cloud_Infrastructure_Factory::INFRASTRUCTURE_ADAPTER_KEY => 'Zend_Cloud_Infrastructure_Adapter_Ec2',
    Zend_Cloud_Infrastructure_Adapter_Ec2::AWS_ACCESS_KEY => $key,
    Zend_Cloud_Infrastructure_Adapter_Ec2::AWS_SECRET_KEY => $secret,
    Zend_Cloud_Infrastructure_Adapter_Ec2::AWS_REGION     => $region,
));

Instead, if you are using Rackspace you have to use the following parameters:

$user= 'username';
$key= 'key';

$infrastructure = Zend_Cloud_Infrastructure_Factory::getAdapter(array(
    Zend_Cloud_Infrastructure_Factory::INFRASTRUCTURE_ADAPTER_KEY => 'Zend_Cloud_Infrastructure_Adapter_Rackspace',
    Zend_Cloud_Infrastructure_Adapter_Rackspace::RACKSPACE_USER => $user,
    Zend_Cloud_Infrastructure_Adapter_Rackspace::RACKSPACE_KEY  => $key
));

After the construct of the $infrastructure object we can start to use it. For instance, if we are using Rackspace, we can create a new instance (server) using the following code:

$data = array (
    'imageId'  => '49',
    'flavorId' => '1',
    'metadata' => array (
        'foo' => 'bar'
    )
);

$instance= $infrastructure->createInstance('test_shared',$data);

if (!$instance) {
   // Error
}

printf ("Name of the instance: %sn", $instance->getName());
printf ("ID of the instance  : %sn", $instance->getId());

The $data array depends on the vendor, in the case of Rackspace we have to specify the image of the instance ($data['imageId']), typically the operating system and the flavor ($data['flavorId']), an available hardware configuration for a server. Each flavor has a unique combination of disk space and memory capacity. This parameters are specified using IDs.
We can also add some metadata information to the instance using an associative arrays of keys and values ($data['metadata']).

To get all the attributes of an instance we can use the getAttributes() method. For instance, to retrieve the admin’s password of a Rackspace’s instance we can read the attribute ‘adminPass’ after the createInstance operation.

$attributes= $instance->getAttributes();
printf ("Admin password of the instance  : %sn", $attributes['adminPass']);

// or

printf ("Admin password of the instance  : %sn", $instance->getAttribute('adminPass'));

To start, stop and reboot a server we can use the commands startInstance($id), stopInstance($id), rebootInstance($id), where $id is the id of the instance.
You can check the status of the instance using the statusInstance($id). The Zend_Cloud_Infrastructure provides a method to wait for the status change of an instance, this function is:

waitStatusInstance ($id, $status [, $timeout = 30])

where $id is the ID of the instance, $status is the status to wait for and $timeout is the optional time of waiting (in seconds). If the instance changes the status in $status, in maximum $timeout seconds, the waitStatusIstance() returns true, false otherwise. For instance, imagine to reboot an instance and wait for the READY status:

if (!$infrastructure->rebootInstance('instance-id')) {
    die ('Error in the execution of the reboot command');
}

echo 'Reboot command executed successfully';

if ($infrastructure->waitStatusInstance('instance-id', Instance::STATUS_RUNNING)) {
    echo 'The instance is ready';
} else {
    echo 'The instance is not ready yet';
}

The Zend_Cloud_Infrastructure provides also two special methods to monitoring the usage of instance’s resources and to deploy on an instance (that means execute remote commands on an instance, this feature uses the SSH2 extension of PHP and is available only for GNU/Linux operating systems).
The resources of an instances that the Infrastructure class manages are: CPU, RAM, DISK READ/WRITE, and NETWORK IN/OUT. This monitor features are strictly related to the API exposed by the cloud vendor (for instance, the Amazon AWS provides the CloudWatch services to monitor EC2 instances, and not only). Nonetheless the Zend_Cloud_Infrastructure can retrieve some basic information of the resource usage of an instance even if the cloud vendors doesn’t expose it. For instance, the Rackspace Servers API do not offer a special API to monitor an instance but the Zend_Cloud_Infrastructures does. This extra features is provided using the deploy features of the Infrastrucutre running remote shell commands to retrieve resources usage like the commands: top, df –total, etc (Note: this monitor feature is available only for GNU/Linux instances).

For instance, to get the CPU usage of an instance we can use the following code:

$cpuUsage= $infrastructure->monitorInstance($id, Zend_Cloud_Infrastructure::MONITOR_CPU);
var_dump($cpuUsage);

The $cpuUsage is an associative array with the following structure:

array (
    "series" => array (
        0 => array (
            "timestamp" => (int)
            "value" => (int)
        ),
        ...
    ),
    "average" => (int)
)

where ‘series’ is an array contains the sample of CPU usage (%), got in different timestamps, and ‘average’ is the average of these values.

To execute remote commands (deploy) on an instance we can use the deploy() method. Here, there is an example:

$params= array (
    Zend_Cloud_Infrastructure_Instance::SSH_USERNAME => 'username',
    Zend_Cloud_Infrastructure_Instance::SSH_PASSWORD => 'password'
);

$cmd= 'ls -la /var/www';

$output= $infrastructure->deployInstance($id, $params, $cmd);

echo "The files in the DocumentRoot of the instance $id are:n";
print_r ($output);

This example retrieves the list of the files stored in the default web root of an instance, using the command:

ls -la /var/www

.
The remote command is specified in the $cmd variable. If you need to execute multiple commands you can also specify an array of commands.
For instance, the following script install a LAMP stack to an Ubuntu instance and generate a PHP test script on the default document root:

$params= array (
    Zend_Cloud_Infrastructure_Instance::SSH_USERNAME => 'username',
    Zend_Cloud_Infrastructure_Instance::SSH_PASSWORD => 'password'
);

$cmd= array (
    'apt-get install apache2 php5 libapache2-mod-php5 mysql-server libapache2-mod-auth-mysql php5-mysql',
    'echo "<?php phpinfo();" > /var/www/test.php'
);

$output= $infrastructure->deployInstance($id, $params, $cmd);

$ip= $infrastructure->getPublicDnsInstance($id);
echo "To check the installation go to http://$ip/test.php".

More info about the Zend_Cloud_Infrastructure can be found in the simplecloud.org web site (click here) or in the documentation page of Zend Framework.

Conclusion

In this article we just introduced the main features of the new Infrastructure component of Zend_Cloud. Because of the nature of the cloud, this component is very open and “elastic”, that means we would like to extend it in the future according with the new API coming from the vendors and with your feedbacks, coming from the community. In order to get more feedbacks about the cloud components of the Zend Framework project we created a new mailing list, that is zf-cloud@lists.zend.com (to subscribe send an empty email to zf-cloud-subscribe@lists.zend.com). Join us to know more about PHP and cloud!

http://packages.zendframework.com/

This is the first in a series of planned beta releases. The beta release
cycle will follow the “gmail” style of betas, whereby new features will
be added in each new release, and BC will not be guaranteed; beta
releases will happen no less than every six weeks. The desire is for
developers to adopt and work with new components as they are shipped, and
provide feedback so we can polish the distribution.

Once all code in the proposed standard distribution
has reached maturity and reasonable stability, we will freeze the API and
prepare for Release Candidate status.

Featured components and functionality of 2.0.0beta1 include:

• New and refactored autoloaders:
  • Zend\Loader\StandardAutoloader
  • Zend\Loader\ClassMapAutoloader
  • Zend\Loader\AutoloaderFactory
• New plugin broker strategy
  • Zend\Loader\Broker and Zend\Loader\PluginBroker
• Reworked Exception system
  • Allow catching by specific Exception type
  • Allow catching by component Exception type
  • Allow catching by SPL Exception type
  • Allow catching by base Exception type
• Rewritten Session component
• Refactored View component
  • Split helpers into a PluginBroker
  • Split variables into a Variables container
  • Split script paths into a TemplateResolver
  • Renamed base View class “PhpRenderer”
  • Refactored helpers to utilize __invoke() when possible
• Refactored HTTP component
• New Zend\Cloud\Infrastructure component
• New EventManager component
• New Dependency Injection (Zend\Di) component
• New Code component
  • Incorporates refactored versions of former Reflection and
    CodeGenerator components.
  • Introduces Scanner component.
  • Introduces annotation system.

The above components provide a solid foundation for Zend Framework 2, and
largely make up the framework “core”. However, the cornerstone feature of beta1
is what they enable: the new MVC layer:

• Zend\Module, for developing modular application architectures.
• Zend\Mvc, a completely reworked MVC layer built on top of HTTP,
  EventManager, and Di.

We’ve built a href="http://github.com/zendframework/ZendSkeletonApplication">skeleton
application and a href="http://github.com/zendframework/ZendSkeletonModule">skeleton
module to help get you started, as well as a href="http://packages.zendframework.com/docs/latest/manual/en/zend.mvc.quick-start.html">quick start
guide to the MVC; the new MVC is truly flexible, and moreover, simple and
powerful.

Additionally, for those who haven’t clicked on the packages link above, we are
debuting our new distribution mechanisms for ZF2: the ability to use
Pyrus to install individual components and/or groups of
components.

Since mid-August, we’ve gone from a few dozen pull requests on the
ZF2 git repository to over 500,
originating from both long-time Zend Framework contributors as well as those
brand-new to the project. I’d like to thank each and every one of them, but also
call out several individuals who have made some outstanding and important
contributions during that time frame:

• Evan Coury, who prototyped and then implemented the new
  module system.
• Rob Allen, who, because he was doing a tutorial at
  PHPNW on ZF2, provided a lot of early
  feedback, ideas, and advice on the direction of the MVC.
• Ben Scholzen, who wrote a new router system, in
  spite of a massive injury from a cycling accident.
• Ralph Schindler, who has had to put up with my
  daily “devil’s advocate” and “think of the user!” rants for the past several
  months, and still managed to provide comprehensive code manipulation tools, a
  Dependency Injection framework, and major contributions to the HTTP
  component.
• Enrico Zimuel, who got tossed requirements for the
  cloud infrastructure component, and then had to rework most of it after
  rewriting the HTTP client from the ground up… and who still managed three
  back-to-back-to-back conferences as we prepared the release.
• Artur Bodera, who often has played
  devil’s advocate, and persisted pressing his opinions on the direction of the
  framework, often despite heavy opposition. We may not implement all (or many)
  of the features you want, but you’ve definitely influenced the direction of
  the MVC incredibly.
• Pádraic Brady, who
  started the runaway train rolling with a rant,
  and helped make the project much more transparent, enabling the MVC
  development to occur in the first place.

Welcome to the ZF2 beta cycle!