The way PHP handles loading extensions is absolutely fine, if you are a Linux system admin. Honestly, there was a time when most of us who managed PHP on a server were. The extension= lines in a php.ini require that you know the exact name of the extension. That name is different on Windows severs than on Linux servers. Even though the majority of PHP deployments are still on some variant of Unix, not all are.

So, to resolve this issue for the sake of the sanity of DevOps teams everywhere, PHP 7.2 will allow extensions to be loaded by name in addition to file name.

So now, all of these will be acceptable:

extension=bz2
extension=php_bz2.dll
extension=bz2.so
extension=bz2.sl

The last one being the proper file name on an HP-UX system.

This also means that there is one less difference between Windows and *nix php.ii files. Those of us who swap between the two will be greatly relieved.

The post PHP 7.2: Add Extension By Name appeared first on Zend Developer Zone.

The only constant is change.
– Heraclitus of Ephesus

PHP is a living language and as such, as some things are added, others are removed. Since PHP adheres to the best practice of Semantic Versioning, nothing will be going away in PHP 7.2, but some things will be marked as “Deprecated” so that developers can start removing them from their code and finding better ways to get the job done.

PHP 7.2 brings us a new list of things that will be eventually going away. The complete list, as well as explinations and voting can be found at “PHP RFC: Deprecations for PHP 7.2” Here’s the rundown.

• __autoload
• $php_errormsg
• create_function()
• mbstring.func_overload
• (unset) cast
• parse_str() without second argument
• gmp_random()
• each()
• assert() with string argument
• $errcontext argument of error handler

Of all the ones being voted on, only each() seems like it may not pass. The rest are all unanimous or with one or two no votes.

So it’s time to fire up your favorite IDE (or grep) and start looking for these. Again, they will not go away when PHP 7.2 is released. However, you are being put on notice that they will go away when 8 is released so you might as well identify them and start working on a fix.

The post Deprecations in PHP 7.2 appeared first on Zend Developer Zone.

Sara:

• Is a regular speaker at PHP conferences worldwide
• An active core contributor
• One of the release managers of PHP 7.2

Please join us here at Rogue Wave in saying thank you to Sara for her more than fifteen years of service to PHP and the PHP community.

Photo Credit: Sara by Rob Allen

The post June 2017 PHP Community (coffee) Cup of Service winner appeared first on Zend Developer Zone.

it is our pleasure here at Rogue Wave to present the very first “Michelangelo van Dam PHP Community (coffee) Cup of Service” to non other than the Don of the PHP Community, one of the PHP Ninja Turtles, Mr. Michelangelo van Dam himself.

For those that are not aware of the contributions that Mike makes to our community.

• He is one of the founders of the PHPbenelux PHP community. It’s not a User Group, it is an entire community of more than 30 User Groups under one umbrella. Mike regularly travels to the groups under the PHPBenelux umbrella speaking and encouraging others.
• He is one of the founders of the PHPBenelux Conference.
• He is a regular speaker at PHP conferences worldwide.
• Even when he isn’t speaking, he attends conferences on his own dime.

For all that Michelangelo does for the PHP community, we award him the “Michelangelo van Dam PHP Community (coffee) Cup of Service”.

Thank you Michelangelo for all that you do for the PHP community. Keep up the good work.

The post May 2017 PHP Community (coffee) Cup of Service winner appeared first on Zend Developer Zone.

When I get ready to dice meat or slice vegetables, I have my go-to knives for each job. I pull one from the draw carefully, rinse it, and then begin the task at hand. Most of the time, things are great, I finish and move on to the next task. There are times however, when I can tell after the first cut or so that my favorite knife is in need of a good sharpening. It’s not the knife’s fault, I know I have to maintain my equipment for it to perform for me.

It usually doesn’t take long. A couple of minutes on the steel or whetstone and we are back working to finish the meal.

Your developers are like knives. You, as the manager, have to invest in them to keep them sharp and usable. Just like I would never use a knife until it was hopelessly dull, and then throw it out; you don’t want to lose you investment in your developers by running them into the ground. You need to refresh them, renew them, inspire them.

There is no better way to reinvigorate a developer than to send them to a conference where they can sharpen their skills against the steel of other developers. They get inspired and educated through sessions presented. They reinvigorate by relaxing and sharing with friends new and old.

Sharpen the knives in your drawer. Send your developers to ZendCon 2017 and watch the difference in them when they return ready to tackle your projects with renewed vigor.

Or don’t. I’m sure their next employer will. ;)

The post Sharpen your knives appeared first on Zend Developer Zone.

You will want to check out the complete Speaker’s package for all the details and awesomeness, but here are the highlights.

• Full conference pass (conference and tutorials)
• Lunch (conference days only), receptions, and activities included in a full conference pass
• Round-trip airfare (must be arranged through Rogue Wave Software)
• 2 complimentary hotel nights (must be arranged through Rogue Wave Software)
• 2 days of hanging out with the best and brightest in the PHP community…and also me!
• VEGAS!

(Ok, I added those last two.) :)

Join us in Vegas this October and be a part of one of the largest gatherings of the PHP community. Submit your talk to ZendCon 2017 today. (Submit at least 2 more tomorrow too!)

The post ZendCon 2017 Call for Papers is OPEN! appeared first on Zend Developer Zone.

The problem then becomes: how do you get at the data you need in a pile of HTML soup? You could use regular expressions or any of the various string functions in PHP. All of these are easily subject to error, though, and often require some convoluted code to get at the data of interest.

Alternately, you could treat the HTML as XML, and use the DOM extension, which is typically built-in to PHP. Doing so, however, requires more than a passing familiarity with XPath, which is something of a black art.

If you use JavaScript libraries or write CSS fairly often, you may be familiar with CSS selectors, which allow you to target either specific nodes or groups of nodes within an HTML document. These are generally rather intuitive:

jQuery('section.slide h2').each(function (node) {
  alert(node.textContent);
});

What if you could do that with PHP?

Introducing zend-dom

zend-dom provides CSS selector capabilities for PHP, via the Zend\Dom\Query class, including:

• element types (h2, span, etc.)
• class attributes (.error, .next, etc.)
• element identifiers (#nav, #main, etc.)
• arbitrary element attributes (div[onclick="foo"]), including word matches (div[role~="navigation"]) and substring matches (div[role*="complement"])
• descendents (div .foo span)

While it does not implement the full spectrum of CSS selectors, it does provide enough to generally allow you to get at the information you need within a page.

Example: retrieving a navigation list

As an example, let’s fetch the navigation list from the Zend\Dom\Query documentation page itself:

use Zend\Dom\Query;

$html = file_get_contents('https://docs.zendframework.com/zend-dom/query/');
$query = new Query($html);
$results = $query->execute('ul.bs-sidenav li a');

printf("Received %d results:\n", count($results));
foreach ($results as $result) {
    printf("- [%s](%s)\n", $result->getAttribute('href'), $result->textContent);
}

The above queries for ul.bs-sidenav li a — in other words, all links within list items of the sidenav unordered list.

When you execute() a query, you are returned a Zend\Dom\NodeList instance, which decorates a DOMNodeList in order to provide features such as Countable, and access to the original query and document. In the example above, we count() the results, and then loop over them.

Each item in the list is a DOMNode, giving you access to any attributes, the text content, and any child elements. In our case, we access the href attribute (the link target), and report the text content (the link text).

The results are:

Received 3 results:
- [#querying-html-and-xml-documents](Querying HTML and XML Documents)
- [#theory-of-operation](Theory of Operation)
- [#methods-available](Methods Available)

Other uses

Another use case is for testing. When you have classes that return HTML, or if you want to execute requests and test the generated output, you often don’t want to test exact contents, but rather look for specific data or fragments within the document.

We provide these capabilities for zend-mvc applications via the zend-test component, which provides a number of CSS selector assertions for use in querying the content returned in your MVC responses. Having these capabilities allows testing for dynamic content as well as static content, providing a number of vectors for ensuring application quality.

Start scraping!

While this post was rather brief, we hope you can appreciate the powerful capabilities of this component! We have used this functionality in a variety of ways, from testing applications to creating feeds based on content differences in web pages, to finding and retrieving image URIs from pages.

Get more information from the zend-dom documentation.

This article originally appeared on the Zend Framework blog at https://framework.zend.com/blog/2017-02-28-zend-dom.html.

The post Scrape Screens with zend-dom appeared first on Zend Developer Zone.

At heart, though, we like to support developer needs, whatever they may be, and, as such, our zend-config component provides ways of working with a variety of configuration formats.

Installation

zend-config is installable via Composer:

$ composer require zendframework/zend-config

The component has two dependencies:

• zend-stdlib, which provides some capabilities around configuration merging.
• psr/container, to allow reader and writer plugin support for the configuration factory.

Latest version

This article covers the most recently released version of zend-config, 3.1.0, which contains a number of features such as PSR-11 support that were not previously available. If you are using Zend Framework, you should be able to safely provide the constraint ^2.6 || ^3.1, as the primary APIs remain the same.

Retrieving configuration

Once you’ve installed zend-config, you can start using it to retrieve and access configuration files. The simplest way is to use Zend\Config\Factory, which provides tools for loading configuration from a variety of formats, as well as capabilities for merging.

If you’re just pulling in a single file, use Factory::fromFile():

use Zend\Config\Factory;

$config = Factory::fromFile($path);

Far more interesting is to use multiple files, which you can do via Factory::fromFiles(). When you do, they are merged into a single configuration, in the order in which they are provided to the factory. This is particularly interesting using glob():

use Zend\Config\Factory;

$config = Factory::fromFiles(glob('config/autoload/*.*'));

What’s particularly interesting about this is that it supports a variety of formats:

• PHP files returning arrays (.php extension)
• INI files (.ini extension)
• JSON files (.json extension)
• XML files (using PHP’s XMLReader; .xml extension)
• YAML files (using ext/yaml, installable via PECL; .yaml extension)
• JavaProperties files (.javaproperties extension)

This means that you can choose the configuration format you prefer, or mix-and-match multiple formats, if you need to combine configuration from multiple libraries!

Configuration objects

By default, Zend\Config\Factory will return PHP arrays for the merged configuration. Some dependency injection containers do not support arrays as services, however; moreover, you may want to pass some sort of structured object instead of a plain array when injecting dependencies.

As such, you can pass a second, optional argument to each of fromFile() and fromFiles(), a boolean flag. When true, it will return a Zend\Config\Config instance, which implements Countable, Iterator, and ArrayAccess, allowing it to look and act like an array.

What is the benefit?

First, it provides property overloading to each configuration key:

$debug = $config->debug ?: false;

Second, it offers a convenience method, get(), which allows you to specify a default value to return if the value is not found:

$debug = $config->get('debug', false); // Return false if not found

This is largely obviated by the ?: ternary shortcut in modern PHP versions, but very useful when mocking in your tests.

Third, nested sets are also returned as Config instances, which gives you the ability to use the above get() method on a nested item:

if (isset($config->expressive)) {
    $config = $config->get('expressive'); // same API!
}

Fourth, you can mark the Config instance as immutable! By default, it acts just like array configuration, which is, of course, mutable. However, this can be problematic when you use configuration as a service, because, unlike an array, a Config instance is passed by reference, and changes to values would then propagate to any other services that depend on the configuration.

Ideally, you wouldn’t be changing any values in the instance, but Zend\Config\Config can enforce that for you:

$config->setReadOnly(); // Now immutable!

Further, calling this will mark nested Config instances as read-only as well, ensuring data integrity for the entire configuration tree.

Read-only by default!

One thing to note: by default, Config instances are read-only! The constructor accepts an optional, second argument, a flag indicating whether or not the instance allows modifications, and the value is false by default. Whenever you use the Factory to create a Config instance, it never enables that flag, meaning that if you return a Config instance, it will be read-only.

If you want a mutable instance from a Factory, use the following construct:

use Zend\Config\Config;
use Zend\Config\Factory;

$config = new Config(Factory::fromFiles($files), true);

Including other configuration

Most of the configuration reader plugins also support "includes": directives within a configuration file that will include configuration from another file. (JavaProperties is the only configuration format we support that does not have this functionality included.)

For instance:

• INI files can use the key code>@include to include another file relative to the current one; values are merged at the same level:

  webhost = 'www.example.com'
  @include = 'database.ini'

• For XML files, you can use XInclude:

  <?xml version="1.0" encoding="utf-8">
  <config xmlns:xi="http://www.w3.org/2001/XInclude">
  <webhost>www.example.com</webhost>
  <xi:include href="database.xml"/>
  </config>

• JSON files can use an code>@include key:

  {
  "webhost": "www.example.com",
  "@include": "database.json"
  }

• YAML also uses the code>@include notation:

  webhost: www.example.com
  @include: database.yaml

Out-of-the-box we support the YAML PECL extension for our YAML support. However, we have made it possible to use alternate parsers, such as Spyc or the Symfony YAML component, by passing a callback to the reader’s constructor:

use Symfony\Component\Yaml\Yaml as SymfonyYaml;
use Zend\Config\Reader\Yaml as YamlConfig;

$reader = new YamlConfig([SymfonfyYaml::class, 'parse']);
$config = $reader->fromFile('config.yaml');

Of course, if you’re going to do that, you could just use the original library, right? But what if you want to mix YAML and other configuration with the Factory class?

There aer two ways to register new plugins. One is to create an instance and register it with the factory:

use Symfony\Component\Yaml\Yaml as SymfonyYaml;
use Zend\Config\Factory;
use Zend\Config\Reader\Yaml as YamlConfig;

Factory::registerReader('yaml', new YamlConfig([SymfonyYaml::class, 'parse']));

Alternately, you can provide an alternate reader plugin manager. You can do that by extending Zend\Config\StandaloneReaderPluginManager, which is a barebones PSR-11 container for use as a plugin manager:

namespace Acme;

use Symfony\Component\Yaml\Yaml as SymfonyYaml;
use Zend\Config\Reader\Yaml as YamlConfig;
use Zend\Config\StandaloneReaderPluginManager;

class ReaderPluginManager extends StandaloneReaderPluginManager
{
    /**
     * @inheritDoc
     */
    public function has($plugin)
    {
        if (YamlConfig::class === $plugin
            || 'yaml' === strtolower($plugin)
        ) {
            return true;
        }

        return parent::has($plugin);
    }

    /**
     * @inheritDoc
     */
    public function get($plugin)
    {
        if (YamlConfig::class !== $plugin
            && 'yaml' !== strtolower($plugin)
        ) {
            return parent::get($plugin);
        }

        return new YamlConfig([SymfonyYaml::class, 'parse']);
    }
}

Then register this with the Factory:

use Acme\ReaderPluginManager;
use Zend\Config\Factory;

Factory::setReaderPluginManager(new ReaderPluginManager());

Processing configuration

zend-config also allows you to process a Zend\Config\Config instance and/or an individual value. Processors perform operations such as:

• substituting constant values within strings
• filtering configuration data
• replacing tokens within configuration
• translating configuration values

Why would you want to do any of these operations?

Consider this: deserialization of formats other than PHP cannot take into account PHP constant values or class names!

While this may work in PHP:

return [
    Acme\Component::CONFIG_KEY => [
        'host' => Acme\Component::CONFIG_HOST,
        'dependencies' => [
            'factories' => [
                Acme\Middleware\Authorization::class => Acme\Middleware\AuthorizationFactory::class,
            ],
        ],
    ],
];

The following JSON configuration would not:

{
    "Acme\\Component::CONFIG_KEY": {
        "host": "Acme\\Component::CONFIG_HOST"
        "dependencies": {
            "factories": {
                "Acme\\Middleware\\Authorization::class": "Acme\\Middleware\\AuthorizationFactory::class"
            }
        }
    }
}

Enter the Constant processor!

This processor looks for strings that match constant names, and replaces them with their values. Processors generally only work on the configuration values, but the Constant processor allows you to opt-in to processing the keys as well.

Since processing modifies the Config instance, you will need to manually create an instance, and then process it. Let’s look at that:

use Acme\Component;
use Zend\Config\Config;
use Zend\Config\Factory;
use Zend\Config\Processor;

$config = new Config(Factory::fromFile('config.json'), true);
$processor = new Processor\Constant();
$processor->enableKeyProcessing();
$processor->process($config);
$config->setReadOnly();

var_export($config->{Component::CONFIG_KEY}->dependencies->factories);
// ['Acme\Middleware\Authorization' => 'Acme\Middleware\AuthorizationFactory']

This is a really powerful feature, as it allows you to add more verifications and validations to your configuration files, regardless of the format you use.

In version 3.1.0 forward

The ability to work with class constants and process keys was added only recently in the 3.1.0 version of zend-config.

Config all the things!

This post covers the parsing features of zend-config, but does not even touch on another major capability: the ability to write configuration! We’ll leave that to another post.

In terms of configuration parsing, zend-config is simple, yet powerful. The ability to process a number of common configuration formats, utilize configuration includes, and process keys and values means you can highly customize your configuration process to suit your needs or integrate different configuration sources.

Get more information from the zend-config documentation.

This article originally appeared on the Zend Framework blog at https://framework.zend.com/blog/2017-02-22-zend-config.html.

The post zend-config For All Your Configuration Needs appeared first on Zend Developer Zone.

Microsoft announced the availability of a public preview of SQL Server for Linux on the 16th of November, 2016. This new version of SQL Server has some interesting features such as:

• transparent data encryption;
• always encrypted;
• row level security;
• in-memory tables;
• columnstore indexing;
• native JSON support;
• support for in-database analytics with R-integration.

Moreover, the performance of the new DBMS seems to be very impressive. Microsoft published a case study with 1.2 million requests per second with In-Memory OLTP on a single commodity server.

We tested the last preview of SQL Server (CTP1.2 – 14.0.200.24) using a Vagrant box with Ubuntu 16.04 and 4 GB RAM.

Install SQL Server on Linux

We followed the instructions list on the Microsoft website to install SQL Server for PHP on Ubuntu 16.04.

To ensure optimal performance of SQL Server, the Ubuntu box should have at least 4 GB of memory.

The first step is to add the GPG key for the Microsoft repositories.

$ sudo su
$ curl https://packages.microsoft.com/keys/microsoft.asc | apt-key add -
$ curl https://packages.microsoft.com/config/ubuntu/16.04/mssql-server.list > /etc/apt/sources.list.d/mssql-server.list
$ exit

Then we can update the repository list and install the mssql-server package, using the following commands:

$ sudo apt-get update
$ sudo apt-get install mssql-server

Now we can run the setup for sqlserver. We will be required to accept the EULA and choose a password for the System Administrator (SA).

sudo /opt/mssql/bin/sqlservr-setup

After the installation, we will have SQL Server running on Linux!

Install the command line utility for SQL Server

Now that we have the DBMS running, we need a tool to access it. Microsoft provides a command line tool named sqlcmd. This program is very similar to the MySQL client tool, quite familiar to PHP developers.

To install sqlcmd, we need to run the following commands:

$ sudo su
$ curl https://packages.microsoft.com/config/ubuntu/16.04/prod.list > /etc/apt/sources.list.d/mssql-tools.list
$ exit
$ sudo apt-get update
$ sudo apt-get install msodbcsql mssql-tools unixodbc-dev
$ echo 'export PATH="$PATH:/opt/mssql-tools/bin"' >> ~/.bash_profile
$ echo 'export PATH="$PATH:/opt/mssql-tools/bin"' >> ~/.bashrc
$ source ~/.bashrc

msodbcsql

Though the Microsoft documentation does not indicate it, we also installed msodbcsql; without it, we ran into dependency issues.

If the installation was successful, we can start using the command line tool. For instance, we can ask for the SQL Server vesion using the following instruction:

$ sqlcmd -S localhost -U sa -P yourpassword -Q "SELECT @@VERSION"

where yourpassword should be replaced with the SA password that you choose during the SQL Server setup.

This command will return output like the following:

----------------------------------------------------------------
Microsoft SQL Server vNext (CTP1.2) - 14.0.200.24 (X64)
    Jan 10 2017 19:15:28
    Copyright (C) 2016 Microsoft Corporation. All rights reserved.
    on Linux (Ubuntu 16.04.1 LTS)

Install the SQL Server extension for PHP

Next, we need to install the PHP extension for SQL Server. This can be done using PECL.

PECL

If you do not have PECL installed on Ubuntu, you can install it with the following command:

$ sudo apt-get install php-dev

To install the sqlsrv and pdo_sqlsrv extensions for PHP, we need to execute the following commands:

$ sudo apt-get install unixodbc-dev gcc g++ build-essential
$ sudo pecl install sqlsrv pdo_sqlsrv

Finally, we need to add the directives extension=pdo_sqlsrv.so and extension=sqlsrv.so to our PHP configuration (generally php.ini). In our case, running Ubuntu (or any other Debian-flavored distribution) we have the PHP configuration files stored in /etc/php/7.0/mods-available. We can create sqlsrv.ini and pdo_sqlsrv.ini containing the respective configurations. As a last step, we need to link these configurations to our specific PHP environments. For this, you can have two choices:

• For Ubuntu, you can use the phpenmod command.
• Alternately, you can symlink to the appropriate directory.

For our purposes, we are using PHP 7.0, from the CLI SAPI, so we can do either of the following:

# Using phpenmod:
$ sudo phpenmod -v 7.0 -s cli sqlsrv pdo_sqlsrv
# Manually symlinking:
$ sudo ln -s /etc/php/7.0/mods-available/sqlsrv.ini /etc/php/7.0/cli/conf.d/20-sqlsrv.ini
$ sudo ln -s /etc/php/7.0/mods-available/pdo_sqlsrv.ini /etc/php/7.0/cli/conf.d/20-pdo_sqlsrv.ini

Integration tests with zend-db

We used the above information to add support for SQL Server to the zendframework/zend-db vagrant configuration, used by developers to test against the various database platforms we support.

We updated the Vagrantfile, enabling integration tests for MySQL, PostgreSQL and SQL Server on Linux, to read as follows:

$install_software = <<SCRIPT
export DEBIAN_FRONTEND=noninteractive
apt-get -yq update

# INSTALL PostgreSQL
apt-get -yq install postgresql

# Allow external connections to PostgreSQL as postgres
sed -i "s/#listen_addresses = 'localhost'/listen_addresses = '*'/" /etc/postgresql/9.5/main/postgresql.conf
sed -i "s/peer/trust/" /etc/postgresql/9.5/main/pg_hba.conf
echo 'host all all 0.0.0.0/0 trust' >> /etc/postgresql/9.5/main/pg_hba.conf
service postgresql restart

# INSTALL MySQL
debconf-set-selections <<< "mysql-server mysql-server/root_password password Password123"
debconf-set-selections <<< "mysql-server mysql-server/root_password_again password Password123"
apt-get -yq install mysql-server

# Allow external connections to MySQL as root (with password Password123)
sed -i 's/127\.0\.0\.1/0\.0\.0\.0/g' /etc/mysql/mysql.conf.d/mysqld.cnf
mysql -u root -pPassword123 -e 'USE mysql; UPDATE <code>user</code> SET <code>Host</code>="%" WHERE <code>User</code>="root" AND <code>Host</code>="localhost"; DELETE FROM <code>user</code> WHERE <code>Host</code> != "%" AND <code>User</code>="root"; FLUSH PRIVILEGES;'
service mysql restart

# INSTALL SQL Server
# More info here: https://www.microsoft.com/en-us/sql-server/developer-get-started/php-ubuntu

curl -s https://packages.microsoft.com/keys/microsoft.asc | apt-key add -
curl -s https://packages.microsoft.com/config/ubuntu/16.04/mssql-server.list > /etc/apt/sources.list.d/mssql-server.list
apt-get -yq update
apt-get -yq install mssql-server
printf "YES\nPassword123\nPassword123\ny\ny" | /opt/mssql/bin/sqlservr-setup

curl -s https://packages.microsoft.com/config/ubuntu/16.04/prod.list > /etc/apt/sources.list.d/mssql-tools.list
apt-get -yq update
ACCEPT_EULA=Y apt-get -yq install msodbcsql mssql-tools unixodbc-dev
echo 'export PATH="$PATH:/opt/mssql-tools/bin"' >> /home/vagrant/.bash_profile
echo 'export PATH="$PATH:/opt/mssql-tools/bin"' >> /home/vagrant/.bashrc
source /home/vagrant/.bashrc
SCRIPT

$setup_vagrant_user_environment = <<SCRIPT
if ! grep "cd /vagrant" /home/vagrant/.profile > /dev/null; then
  echo "cd /vagrant" >> /home/vagrant/.profile
fi
SCRIPT

Vagrant.configure(2) do |config|
  config.vm.box = 'bento/ubuntu-16.04'
  config.vm.provider "virtualbox" do |v|
    v.memory = 4096
    v.cpus = 2
  end

  config.vm.network "private_network", ip: "192.168.20.20"

  config.vm.provision 'shell', inline: $install_software
  config.vm.provision 'shell', privileged: false, inline: '/vagrant/.ci/mysql_fixtures.sh'
  config.vm.provision 'shell', privileged: false, inline: '/vagrant/.ci/pgsql_fixtures.sh'
  config.vm.provision 'shell', privileged: false, inline: '/vagrant/.ci/sqlsrv_fixtures.sh'
  config.vm.provision 'shell', inline: $setup_vagrant_user_environment
end

This vagrant configuration installs Ubuntu 16.04 with 4 GB of RAM and the following databases (user and password are reported in parenthesis):

• MySQL 5.7.17 (root/Password123)
• PostgreSQL 9.5 (postgres/postgres)
• SQL Server 14.0.200.24 (sa/Password123)

We can use this virtual machine to run PHPUnit for the zend-db integration tests. If you want to test this vagrant box, you can clone the zend-db repository and run the following command:

$ vagrant up

This creates a VM running with IP 192.168.20.20.

More information

In this post, we’ve demonstrated how to install the public preview release of SQL Server on Ubuntu. Microsoft also provides support for other Linux distributions, such as Red Hat and Suse.

You can also install this new SQL Server preview on Windows, macOS, Azure or using a preconfigured Docker container.

Get more information on SQL Server for Linux from the official website. Find specific information on how to use SQL Server with PHP here.

This article originally appeared on the Zend Framework blog at https://framework.zend.com/blog/2017-02-14-php-sql-server-linux.html and was written by Enrico Zimuel.

The post PHP and SQL Server for Linux appeared first on Zend Developer Zone.

As of February 13th, 2017, the new Zend Certified Engineer test is available. As with many things in life, it took a lot of effort to get the test updated but we are sure you will find it worth the wait.

The new test now tests developers knowledge of PHP and programming concepts through PHP 7.1.

We would like to thank all the community members that helped up update the test. Without your efforts, this update would not exist. We would like the names of those that helped but we are afraid that they would be inundated with questions about the test. Questions that they aren’t allowed to answer anyhow. Instead, we will just say thanks. You know who you are.

For more information, and to purchase your voucher, visit the Zend Certified Engineer web page.

NOTE: If you have already purchased a voucher to take the ZCE and wish to take the old test, you have until March 31st to schedule and take at. After that point, the old test will no longer be available.

The post Zend Certified Engineer 2017-PHP appeared first on Zend Developer Zone.