Zend_Service_Twitter | Zend_Service Programmer's Reference Guide | Zend_Service_Yahoo

# Zend_Service_WindowsAzure

# Introduction

Windows Azure is the name for Microsoft's Software + Services platform, an operating system in the cloud providing services for hosting, management, scalable storage with support for simple blobs, tables, and queues, as well as a management infrastructure for provisioning and geo-distribution of cloud-based services, and a development platform for the Azure Services layer.

# Installing the Windows Azure SDK

There are two development scenario's when working with Windows Azure.

- You can develop your application using Zend_Service_WindowsAzure and the Windows Azure SDK, which provides a local developent environment of the services provided by Windows Azure's cloud infrastructure.

- You can develop your application using Zend_Service_WindowsAzure, working directly with the Windows Azure cloud infrastructure.

The first case requires you to install the » Windows Azure SDK on your development machine. It is currently only available for Windows environments; progress is being made on a Java-based version of the SDK which can run on any platform.

The latter case requires you to have an account at » Azure.com.

# API Documentation

The Zend_Service_WindowsAzure class provides the PHP wrapper to the Windows Azure REST interface. Please consult the » REST documentation for detailed description of the service. You will need to be familiar with basic concepts in order to use this service.

# Features

Zend_Service_WindowsAzure provides the following functionality:

- PHP classes for Windows Azure Blobs, Tables and Queues (for CRUD operations)

- Helper Classes for HTTP transport, AuthN, AuthZ, REST and Error Management

- Manageability, Instrumentation and Logging support

# Architecture

Zend_Service_WindowsAzure provides access to Windows Azure's storage, computation and management interfaces by abstracting the REST - XML interface Windows Azure provides into a simple PHP API.

An application built using Zend_Service_WindowsAzure can access Windows Azure's features, no matter if it is hosted on the Windows Azure platform or on an in-premise web server.

# Zend_Service_WindowsAzure_Storage_Blob

Blob Storage stores sets of binary data. Blob storage offers the following three resources: the storage account, containers, and blobs. Within your storage account, containers provide a way to organize sets of blobs within your storage account.

Blob Storage is offered by Windows Azure as a REST API which is wrapped by the Zend_Service_WindowsAzure_Storage_Blob class in order to provide a native PHP interface to the storage account.

# API Examples

This topic lists some examples of using the Zend_Service_WindowsAzure_Storage_Blob class. Other features are available in the download package, as well as a detailed API documentation of those features.

# Creating a storage container

Using the following code, a blob storage container can be created on development storage.

Example #1 Creating a storage container

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Blob();
2. $result = $storageClient->createContainer('testcontainer');
4. echo 'Container name is: ' . $result->Name;

# Deleting a storage container

Using the following code, a blob storage container can be removed from development storage.

Example #2 Deleting a storage container

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Blob();
2. $storageClient->deleteContainer('testcontainer');

# Storing a blob

Using the following code, a blob can be uploaded to a blob storage container on development storage. Note that the container has already been created before.

Example #3 Storing a blob

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Blob();
3. // upload /home/maarten/example.txt to Azure
4. $result = $storageClient->putBlob(
5. 'testcontainer', 'example.txt', '/home/maarten/example.txt'
6. );
8. echo 'Blob name is: ' . $result->Name;

# Copying a blob

Using the following code, a blob can be copied from inside the storage account. The advantage of using this method is that the copy operation occurs in the Azure cloud and does not involve downloading the blob. Note that the container has already been created before.

Example #4 Copying a blob

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Blob();
3. // copy example.txt to example2.txt
4. $result = $storageClient->copyBlob(
5. 'testcontainer', 'example.txt', 'testcontainer', 'example2.txt'
6. );
8. echo 'Copied blob name is: ' . $result->Name;

# Downloading a blob

Using the following code, a blob can be downloaded from a blob storage container on development storage. Note that the container has already been created before and a blob has been uploaded.

Example #5 Downloading a blob

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Blob();
3. // download file to /home/maarten/example.txt
4. $storageClient->getBlob(
5. 'testcontainer', 'example.txt', '/home/maarten/example.txt'
6. );

# Making a blob publicly available

By default, blob storage containers on Windows Azure are protected from public viewing. If any user on the Internet should have access to a blob container, its ACL can be set to public. Note that this applies to a complete container and not to a single blob!

Using the following code, blob storage container ACL can be set on development storage. Note that the container has already been created before.

Example #6 Making a blob publicly available

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Blob();
3. // make container publicly available
4. $storageClient->setContainerAcl(
5. 'testcontainer',
6. Zend_Service_WindowsAzure_Storage_Blob::ACL_PUBLIC
7. );

# Root container

Windows Azure Blob Storage provides support to work with a "root container". This means that a blob can be stored in the root of your storage account, i.e. `http://myaccount.blob.core.windows.net/somefile.txt`.

In order to work with the root container, it should first be created using the createContainer() method, naming the container $root. All other operations on the root container should be issued with the container name set to $root.

# Blob storage stream wrapper

The Windows Azure SDK for PHP provides support for registering a blob storage client as a PHP file stream wrapper. The blob storage stream wrapper provides support for using regular file operations on Windows Azure Blob Storage. For example, one can open a file from Windows Azure Blob Storage with the fopen() function:

Example #7 Example usage of blob storage stream wrapper

1. $fileHandle = fopen('azure://mycontainer/myfile.txt', 'r');
3. // ...
5. fclose($fileHandle);

In order to do this, the Windows Azure SDK for PHP blob storage client must be registered as a stream wrapper. This can be done by calling the registerStreamWrapper() method:

Example #8 Registering the blob storage stream wrapper

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Blob();
2. // registers azure:// on this storage client
3. $storageClient->registerStreamWrapper();
6. // or:
8. // regiters blob:// on this storage client
9. $storageClient->registerStreamWrapper('blob://');

To unregister the stream wrapper, the unregisterStreamWrapper() method can be used.

# Shared Access Signature

Windows Azure Bob Storage provides a feature called "Shared Access Signatures". By default, there is only one level of authorization possible in Windows Azure Blob Storage: either a container is private or it is public. Shared Access Signatures provide a more granular method of authorization: read, write, delete and list permissions can be assigned on a container or a blob and given to a specific client using an URL-based model.

An example would be the following signature:

    http://phpstorage.blob.core.windows.net/phpazuretestshared1?st=2009-08-17T09%3A06%3A17Z&se=2009-08-17T09%3A56%3A17Z&sr=c&sp=w&sig=hscQ7Su1nqd91OfMTwTkxabhJSaspx%2BD%2Fz8UqZAgn9s%3D

The above signature gives write access to the "phpazuretestshared1" container of the "phpstorage" account.

# Generating a Shared Access Signature

When you are the owner of a Windows Azure Bob Storage account, you can create and distribute a shared access key for any type of resource in your account. To do this, the generateSharedAccessUrl() method of the Zend_Service_WindowsAzure_Storage_Blob storage client can be used.

The following example code will generate a Shared Access Signature for write access in a container named "container1", within a timeframe of 3000 seconds.

Example #9 Generating a Shared Access Signature for a container

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Blob();
2. $sharedAccessUrl = $storageClient->generateSharedAccessUrl(
3. 'container1',
4. '',
5. 'c',
6. 'w',
7. $storageClient ->isoDate(time() - 500),
8. $storageClient ->isoDate(time() + 3000)
9. );

The following example code will generate a Shared Access Signature for read access in a blob named test.txt in a container named "container1" within a time frame of 3000 seconds.

Example #10 Generating a Shared Access Signature for a blob

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Blob();
2. $sharedAccessUrl = $storageClient->generateSharedAccessUrl(
3. 'container1',
4. 'test.txt',
5. 'b',
6. 'r',
7. $storageClient ->isoDate(time() - 500),
8. $storageClient ->isoDate(time() + 3000)
9. );

# Working with Shared Access Signatures from others

When you receive a Shared Access Signature from someone else, you can use the Windows Azure SDK for PHP to work with the addressed resource. For example, the following signature can be retrieved from the owner of a storage account:

    http://phpstorage.blob.core.windows.net/phpazuretestshared1?st=2009-08-17T09%3A06%3A17Z&se=2009-08-17T09%3A56%3A17Z&sr=c&sp=w&sig=hscQ7Su1nqd91OfMTwTkxabhJSaspx%2BD%2Fz8UqZAgn9s%3D

The above signature gives write access to the "phpazuretestshared1" "container" of the phpstorage account. Since the shared key for the account is not known, the Shared Access Signature can be used to work with the authorized resource.

Example #11 Consuming a Shared Access Signature for a container

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Blob(
2. 'blob.core.windows.net', 'phpstorage', ''
3. );
4. $storageClient->setCredentials(
5. new Zend_Service_WindowsAzure_Credentials_SharedAccessSignature()
6. );
7. $storageClient->getCredentials()->setPermissionSet(array(
8. 'http://phpstorage.blob.core.windows.net/phpazuretestshared1?st=2009-08-17T09%3A06%3A17Z&se=2009-08-17T09%3A56%3A17Z&sr=c&sp=w&sig=hscQ7Su1nqd91OfMTwTkxabhJSaspx%2BD%2Fz8UqZAgn9s%3D'
9. ));
10. $storageClient->putBlob(
11. 'phpazuretestshared1', 'NewBlob.txt', 'C:\Files\dataforazure.txt'
12. );

Note that there was no explicit permission to write to a specific blob. Instead, the Windows Azure SDK for PHP determined that a permission was required to either write to that specific blob, or to write to its container. Since only a signature was available for the latter, the Windows Azure SDK for PHP chose those credentials to perform the request on Windows Azure blob storage.

# Zend_Service_WindowsAzure_Storage_Table

The Table service offers structured storage in the form of tables.

Table Storage is offered by Windows Azure as a REST API which is wrapped by the Zend_Service_WindowsAzure_Storage_Table class in order to provide a native PHP interface to the storage account.

This topic lists some examples of using the Zend_Service_WindowsAzure_Storage_Table class. Other features are available in the download package, as well as a detailed API documentation of those features.

Note that development table storage (in the Windows Azure SDK) does not support all features provided by the API. Therefore, the examples listed on this page are to be used on Windows Azure production table storage.

# Operations on tables

This topic lists some samples of operations that can be executed on tables.

# Creating a table

Using the following code, a table can be created on Windows Azure production table storage.

Example #12 Creating a table

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
2. 'table.core.windows.net', 'myaccount', 'myauthkey'
3. );
4. $result = $storageClient->createTable('testtable');
6. echo 'New table name is: ' . $result->Name;

# Listing all tables

Using the following code, a list of all tables in Windows Azure production table storage can be queried.

Example #13 Listing all tables

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
2. 'table.core.windows.net', 'myaccount', 'myauthkey'
3. );
4. $result = $storageClient->listTables();
5. foreach ($result as $table) {
6. echo 'Table name is: ' . $table->Name . "\r\n";
7. }

# Operations on entities

Tables store data as collections of entities. Entities are similar to rows. An entity has a primary key and a set of properties. A property is a named, typed-value pair, similar to a column.

The Table service does not enforce any schema for tables, so two entities in the same table may have different sets of properties. Developers may choose to enforce a schema on the client side. A table may contain any number of entities.

Zend_Service_WindowsAzure_Storage_Table provides 2 ways of working with entities:

- Enforced schema

- No enforced schema

All examples will make use of the following enforced schema class.

Example #14 Enforced schema used in samples

1. class SampleEntity extends Zend_Service_WindowsAzure_Storage_TableEntity
2. {
3. /**
4. * @azure Name
5. */
6. public $Name;
8. /**
9. * @azure Age Edm.Int64
10. */
11. public $Age;
13. /**
14. * @azure Visible Edm.Boolean
15. */
16. public $Visible = false;
17. }

Note that if no schema class is passed into table storage methods, Zend_Service_WindowsAzure_Storage_Table automatically works with Zend_Service_WindowsAzure_Storage_DynamicTableEntity.

# Enforced schema entities

To enforce a schema on the client side using the Zend_Service_WindowsAzure_Storage_Table class, you can create a class which inherits Zend_Service_WindowsAzure_Storage_TableEntity. This class provides some basic functionality for the Zend_Service_WindowsAzure_Storage_Table class to work with a client-side schema.

Base properties provided by Zend_Service_WindowsAzure_Storage_TableEntity are:

- PartitionKey (exposed through getPartitionKey() and setPartitionKey())

- RowKey (exposed through getRowKey() and setRowKey())

- Timestamp (exposed through getTimestamp() and setTimestamp())

- Etag value (exposed through getEtag() and setEtag())

Here's a sample class inheriting Zend_Service_WindowsAzure_Storage_TableEntity:

Example #15 Sample enforced schema class

1. class SampleEntity extends Zend_Service_WindowsAzure_Storage_TableEntity
2. {
3. /**
4. * @azure Name
5. */
6. public $Name;
8. /**
9. * @azure Age Edm.Int64
10. */
11. public $Age;
13. /**
14. * @azure Visible Edm.Boolean
15. */
16. public $Visible = false;
17. }

The Zend_Service_WindowsAzure_Storage_Table class will map any class inherited from Zend_Service_WindowsAzure_Storage_TableEntity to Windows Azure table storage entities with the correct data type and property name. All there is to storing a property in Windows Azure is adding a docblock comment to a public property or public getter/setter, in the following format:

Example #16 Enforced property

1. /**
2. * @azure <property name in Windows Azure> <optional property type>
3. */
4. public $<property name in PHP>;

Let's see how to define a propety "Age" as an integer on Windows Azure table storage:

Example #17 Sample enforced property

1. /**
2. * @azure Age Edm.Int64
3. */
4. public $Age;

Note that a property does not necessarily have to be named the same on Windows Azure table storage. The Windows Azure table storage property name can be defined as well as the type.

The following data types are supported:

- `Edm.Binary` - An array of bytes up to 64 KB in size.

- `Edm.Boolean` - A boolean value.

- `Edm.DateTime` - A 64-bit value expressed as Coordinated Universal Time (UTC). The supported DateTime range begins from 12:00 midnight, January 1, 1601 A.D. (C.E.), Coordinated Universal Time (UTC). The range ends at December 31st, 9999.

- `Edm.Double` - A 64-bit floating point value.

- `Edm.Guid` - A 128-bit globally unique identifier.

- `Edm.Int32` - A 32-bit integer.

- `Edm.Int64` - A 64-bit integer.

- `Edm.String` - A UTF-16-encoded value. String values may be up to 64 KB in size.

# No enforced schema entities (a.k.a. DynamicEntity)

To use the Zend_Service_WindowsAzure_Storage_Table class without defining a schema, you can make use of the Zend_Service_WindowsAzure_Storage_DynamicTableEntity class. This class inherits Zend_Service_WindowsAzure_Storage_TableEntity like an enforced schema class does, but contains additional logic to make it dynamic and not bound to a schema.

Base properties provided by Zend_Service_WindowsAzure_Storage_DynamicTableEntity are:

- PartitionKey (exposed through getPartitionKey() and setPartitionKey())

- RowKey (exposed through getRowKey() and setRowKey())

- Timestamp (exposed through getTimestamp() and setTimestamp())

- Etag value (exposed through getEtag() and setEtag())

Other properties can be added on the fly. Their Windows Azure table storage type will be determined on-the-fly:

Example #18 Dynamicaly adding properties Zend_Service_WindowsAzure_Storage_DynamicTableEntity

1. $target = new Zend_Service_WindowsAzure_Storage_DynamicTableEntity(
2. 'partition1', '000001'
3. );
4. $target->Name = 'Name'; // Will add property "Name" of type "Edm.String"
5. $target->Age = 25; // Will add property "Age" of type "Edm.Int32"

Optionally, a property type can be enforced:

Example #19 Forcing property types on Zend_Service_WindowsAzure_Storage_DynamicTableEntity

1. $target = new Zend_Service_WindowsAzure_Storage_DynamicTableEntity(
2. 'partition1', '000001'
3. );
4. $target->Name = 'Name'; // Will add property "Name" of type "Edm.String"
5. $target->Age = 25; // Will add property "Age" of type "Edm.Int32"
7. // Change type of property "Age" to "Edm.Int32":
8. $target->setAzurePropertyType('Age', 'Edm.Int64');

The Zend_Service_WindowsAzure_Storage_Table class automatically works with Zend_Service_WindowsAzure_Storage_TableEntity if no specific class is passed into Table Storage methods.

# Entities API examples

# Inserting an entity

Using the following code, an entity can be inserted into a table named "testtable". Note that the table has already been created before.

Example #20 Inserting an entity

1. $entity = new SampleEntity ('partition1', 'row1');
2. $entity->FullName = "Maarten";
3. $entity->Age = 25;
4. $entity->Visible = true;
6. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
7. 'table.core.windows.net', 'myaccount', 'myauthkey'
8. );
9. $result = $storageClient->insertEntity('testtable', $entity);
11. // Check the timestamp and etag of the newly inserted entity
12. echo 'Timestamp: ' . $result->getTimestamp() . "\n";
13. echo 'Etag: ' . $result->getEtag() . "\n";

# Retrieving an entity by partition key and row key

Using the following code, an entity can be retrieved by partition key and row key. Note that the table and entity have already been created before.

Example #21 Retrieving an entity by partition key and row key

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
2. 'table.core.windows.net', 'myaccount', 'myauthkey'
3. );
4. $entity= $storageClient->retrieveEntityById(
5. 'testtable', 'partition1', 'row1', 'SampleEntity'
6. );

# Updating an entity

Using the following code, an entity can be updated. Note that the table and entity have already been created before.

Example #22 Updating an entity

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
2. 'table.core.windows.net', 'myaccount', 'myauthkey'
3. );
4. $entity = $storageClient->retrieveEntityById(
5. 'testtable', 'partition1', 'row1', 'SampleEntity'
6. );
8. $entity->Name = 'New name';
9. $result = $storageClient->updateEntity('testtable', $entity);

If you want to make sure the entity has not been updated before, you can make sure the Etag of the entity is checked. If the entity already has had an update, the update will fail to make sure you do not overwrite any newer data.

Example #23 Updating an entity (with Etag check)

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
2. 'table.core.windows.net', 'myaccount', 'myauthkey'
3. );
4. $entity = $storageClient->retrieveEntityById(
5. 'testtable', 'partition1', 'row1', 'SampleEntity'
6. );
8. $entity->Name = 'New name';
10. // last parameter instructs the Etag check:
11. $result = $storageClient->updateEntity('testtable', $entity, true);

# Deleting an entity

Using the following code, an entity can be deleted. Note that the table and entity have already been created before.

Example #24 Deleting an entity

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
2. 'table.core.windows.net', 'myaccount', 'myauthkey'
3. );
4. $entity = $storageClient->retrieveEntityById(
5. 'testtable', 'partition1', 'row1', 'SampleEntity'
6. );
7. $result = $storageClient->deleteEntity('testtable', $entity);

# Performing queries

Queries in Zend_Service_WindowsAzure_Storage_Table table storage can be performed in two ways:

- By manually creating a filter condition (involving learning a new query language)

- By using the fluent interface provided by the Zend_Service_WindowsAzure_Storage_Table

Using the following code, a table can be queried using a filter condition. Note that the table and entities have already been created before.

Example #25 Performing queries using a filter condition

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
2. 'table.core.windows.net', 'myaccount', 'myauthkey'
3. );
4. $entities = $storageClient->storageClient->retrieveEntities(
5. 'testtable',
6. 'Name eq \'Maarten\' and PartitionKey eq \'partition1\'',
7. 'SampleEntity'
8. );
10. foreach ($entities as $entity) {
11. echo 'Name: ' . $entity->Name . "\n";
12. }

Using the following code, a table can be queried using a fluent interface. Note that the table and entities have already been created before.

Example #26 Performing queries using a fluent interface

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
2. 'table.core.windows.net', 'myaccount', 'myauthkey'
3. );
4. $entities = $storageClient->storageClient->retrieveEntities(
5. 'testtable',
6. $storageClient->select()
7. ->from($tableName)
8. ->where('Name eq ?', 'Maarten')
9. ->andWhere('PartitionKey eq ?', 'partition1'),
10. 'SampleEntity'
11. );
13. foreach ($entities as $entity) {
14. echo 'Name: ' . $entity->Name . "\n";
15. }

# Batch operations

This topic demonstrates how to use the table entity group transaction features provided by Windows Azure table storage. Windows Azure table storage supports batch transactions on entities that are in the same table and belong to the same partition group. A transaction can include at most 100 entities.

The following example uses a batch operation (transaction) to insert a set of entities into the "testtable" table. Note that the table has already been created before.

Example #27 Executing a batch operation

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
2. 'table.core.windows.net', 'myaccount', 'myauthkey'
3. );
5. // Start batch
6. $batch = $storageClient->startBatch();
8. // Insert entities in batch
9. $entities = generateEntities();
10. foreach ($entities as $entity) {
11. $storageClient->insertEntity($tableName, $entity);
12. }
14. // Commit
15. $batch->commit();

# Table storage session handler

When running a PHP application on the Windows Azure platform in a load-balanced mode (running 2 Web Role instances or more), it is important that PHP session data can be shared between multiple Web Role instances. The Windows Azure SDK for PHP provides the Zend_Service_WindowsAzure_SessionHandler class, which uses Windows Azure Table Storage as a session handler for PHP applications.

To use the Zend_Service_WindowsAzure_SessionHandler session handler, it should be registered as the default session handler for your PHP application:

Example #28 Registering table storage session handler

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
2. 'table.core.windows.net', 'myaccount', 'myauthkey'
3. );
5. $sessionHandler = new Zend_Service_WindowsAzure_SessionHandler(
6. $storageClient , 'sessionstable'
7. );
8. $sessionHandler->register();

The above classname registers the Zend_Service_WindowsAzure_SessionHandler session handler and will store sessions in a table called "sessionstable".

After registration of the Zend_Service_WindowsAzure_SessionHandler session handler, sessions can be started and used in the same way as a normal PHP session:

Example #29 Using table storage session handler

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Table(
2. 'table.core.windows.net', 'myaccount', 'myauthkey'
3. );
5. $sessionHandler = new Zend_Service_WindowsAzure_SessionHandler(
6. $storageClient , 'sessionstable'
7. );
8. $sessionHandler->register();
10. session_start();
12. if (!isset($_SESSION['firstVisit'])) {
13. $_SESSION['firstVisit'] = time();
14. }
16. // ...

Warning

The Zend_Service_WindowsAzure_SessionHandler session handler should be registered before a call to session_start() is made!

# Zend_Service_WindowsAzure_Storage_Queue

The Queue service stores messages that may be read by any client who has access to the storage account.

A queue can contain an unlimited number of messages, each of which can be up to 8 KB in size. Messages are generally added to the end of the queue and retrieved from the front of the queue, although first in/first out (FIFO) behavior is not guaranteed. If you need to store messages larger than 8 KB, you can store message data as a queue or in a table and then store a reference to the data as a message in a queue.

Queue Storage is offered by Windows Azure as a REST API which is wrapped by the Zend_Service_WindowsAzure_Storage_Queue class in order to provide a native PHP interface to the storage account.

# API Examples

This topic lists some examples of using the Zend_Service_WindowsAzure_Storage_Queue class. Other features are available in the download package, as well as a detailed API documentation of those features.

# Creating a queue

Using the following code, a queue can be created on development storage.

Example #30 Creating a queue

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Queue();
2. $result = $storageClient->createQueue('testqueue');
4. echo 'Queue name is: ' . $result->Name;

# Deleting a queue

Using the following code, a queue can be removed from development storage.

Example #31 Deleting a queue

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Queue();
2. $storageClient->deleteQueue('testqueue');

# Adding a message to a queue

Using the following code, a message can be added to a queue on development storage. Note that the queue has already been created before.

Example #32 Adding a message to a queue

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Queue();
3. // 3600 = time-to-live of the message, if omitted defaults to 7 days
4. $storageClient->putMessage('testqueue', 'This is a test message', 3600);

# Reading a message from a queue

Using the following code, a message can be read from a queue on development storage. Note that the queue and message have already been created before.

Example #33 Reading a message from a queue

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Queue();
3. // retrieve 10 messages at once
4. $messages = $storageClient->getMessages('testqueue', 10);
6. foreach ($messages as $message) {
7. echo $message->MessageText . "\r\n";
8. }

The messages that are read using getMessages() will be invisible in the queue for 30 seconds, after which the messages will re-appear in the queue. To mark a message as processed and remove it from the queue, use the deleteMessage() method.

Example #34 Marking a message as processed

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Queue();
3. // retrieve 10 messages at once
4. $messages = $storageClient->getMessages('testqueue', 10);
6. foreach ($messages as $message) {
7. echo $message . "\r\n";
9. // Mark the message as processed
10. $storageClient->deleteMessage('testqueue', $message);
11. }

# Check if there are messages in a queue

Using the following code, a queue can be checked for new messages. Note that the queue and message have already been created before.

Example #35 Check if there are messages in a queue

1. $storageClient = new Zend_Service_WindowsAzure_Storage_Queue();
3. // retrieve 10 messages at once
4. $messages = $storageClient->peekMessages('testqueue', 10);
6. foreach ($messages as $message) {
7. echo $message->MessageText . "\r\n";
8. }

Note that messages that are read using peekMessages() will not become invisible in the queue, nor can they be marked as processed using the deleteMessage() method. To do this, use getMessages() instead.

Zend_Service_Twitter | Zend_Service Programmer's Reference Guide | Zend_Service_Yahoo