Two days ago I released the first major version in almost 2 years for <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client">shlink-web-client</a>, a web UI for <a target="_blank" rel="noopener noreferrer" href="https://shlink.io">shlink</a>, my self-hosted URL shortener.This new version introduces several improvements to the project, and I thought it was worth writing a post to explain all of them in depth.<h3>New design</h3>The project has been using the same design almost since the beginning. It was clean, but it laked a bit of contrast and consistency in many sections.Now the main background is light-gray, with components composed in white cards with a slight box shadow, that makes them easier to spot inside the app.Also, the main area has now a max-width that prevents components from stretching too much on wide screens.<div class="row"><div class="col-md-6 "><img alt="Before" src="/assets/img/shlink-web-client-3/design-before.png" class="gallery-item"/>Before</div><div class="col-md-6 "><img alt="After" src="/assets/img/shlink-web-client-3/design-after.png" class="gallery-item"/>After</div></div><h3>Overview page</h3>Up until now, after connecting to a Shlink server, you went directly to the list of short URLs.With this new version, you now see an overview page first, which displays some general stats, a quick short URL creation form, and the latest 5 short URLs.From there, you can navigate to the full list of short URLs, with filtering capabilities, or go to the advanced short URL creation form.<div class="row"><div class="col-md-8 col-md-offset-2 "><img alt="Overview" src="/assets/img/shlink-web-client-3/overview.png" class="gallery-item"/>Overview</div></div><h3>Improved short URL creation form</h3>One of the sections with more room for improvement was the short URL creation form. It had all the inputs mixed, displaying just the &quot;long url&quot; one, with the option to un-collapsing the rest at will.The new design groups the inputs by context, which makes it more clear. It also displays the inputs all the time, since the &quot;quick form&quot; is now located in the overview page.<div class="row"><div class="col-md-6 "><img alt="Before" src="/assets/img/shlink-web-client-3/creation-form-before.png" class="gallery-item"/>Before</div><div class="col-md-6 "><img alt="After" src="/assets/img/shlink-web-client-3/creation-form-after.png" class="gallery-item"/>After</div></div><h3>Enhanced visits page</h3>The visits page had a problem, it was trying to display too much information in a single place.<ul><li>Visits over time</li><li>Visits from every platform</li><li>Visits from every location</li><li>A list of visits as a table</li></ul>The new approach splits those in subsections with their own sub-route each (<code>/by-location</code>, <code>/by-context</code>, etc). This helps to render a smaller amount of charts at once, since they are a bit CPU greedy.Also, only the visits from the last 30 days are loaded by default, making it load way faster for URLs with a lot of visits.<div class="row"><div class="col-md-6 "><img alt="Before" src="/assets/img/shlink-web-client-3/visits-before.png" class="gallery-item"/>Before</div><div class="col-md-6 "><img alt="After" src="/assets/img/shlink-web-client-3/visits-after.png" class="gallery-item"/>After</div></div><h3>Outer sections</h3>The app has some sections which are not related to a specific server, like creating/editing servers, or the settings page.These sections have also been adapted to the new style, and they also have a max-width for wide screens.<div class="row"><div class="col-md-6 "><img alt="Before" src="/assets/img/shlink-web-client-3/create-server-before.png" class="gallery-item"/>Before</div><div class="col-md-6 "><img alt="After" src="/assets/img/shlink-web-client-3/create-server-after.png" class="gallery-item"/>After</div></div><h3>Date range selector</h3>A new component allows selecting date ranges either by relative time ranges (last 30 days, last 90 days...) or by selecting absolute start and end dates.This component is used to filter both short URL lists and visits lists.<div class="row"><div class="col-md-6 col-md-offset-3"><img alt="Date range selector" src="/assets/img/shlink-web-client-3/date-range-selector.png" class=""/>Date range selector</div></div><h3>Domain selector</h3>Shlink has had multi-domain support for some versions, but changing the domain from the web client required to set the value manually, which is a bit error-prone.This version introduces a new component which allows selecting from domains already used in the past (which is what you will want in most of the cases), preventing accidental typos.It also allows setting new values in case you want to use a new domain that you never used before. This domain will then appear in the list the next time.<div class="row"><div class="col-md-6 "><img alt="Existing domains" src="/assets/img/shlink-web-client-3/domains-existing.png" class=""/>Existing domains</div><div class="col-md-6 "><img alt="New domain" src="/assets/img/shlink-web-client-3/domains-new.png" class=""/>New domain</div></div><h3>Other improvements</h3>The changes described so far were the major ones. However, v3.0.0 includes a few other minor improvements.<ul><li>Result and loading messages have been standardized: They are now more consistent and use the same set of components, which also ensures consistency in the future.</li><li>Error messages are now more descriptive: Instead of showing generic error messages when API calls fail, the actual error message is now always displayed, so that it&#x27;s easier to know what failed.</li><li>Dropped support for Shlink v1: All major versions come with some breaking changes that improve code maintainability. This one drops Shlink v1 support, which allows removing some conditional paths here and there.</li></ul>Other than the last point, Shlink v3.0.0 is mostly backwards compatible, so it&#x27;s safe to upgrade if you are already using Shlink v2.x<h3>Next steps</h3>Of course this doesn&#x27;t end here, and I have a lot of ideas to improve it even further.<ul><li>Dark theme: It&#x27;s what the cool kids do these days, and I have already done some experiments around it.</li><li>Shlink dashboard: Next gen web app for Shlink. You can read the whole reasoning in <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client/issues/338">this issue</a>.</li><li>Filtering in lists added to URL: Many sections allow filtering lists, but the state is saved in memory, which means it gets lost if the page is refreshed, and it cannot be bookmarked. The intention is to make all filtering params to become part of the URL.</li><li>Exporting visits in CSV: It&#x27;s cool to see charts full of info, but sometimes admins need to feed other services with the data, and consuming the original API is not always an option. Exporting visits to a CSV file will be supported soon by shlink-web-client.</li></ul>

Released shlink-web-client v3.0.0

Let&#x27;s not deny that <a target="_blank" rel="noopener noreferrer" href="https://github.com/features/actions">GitHub actions</a> are hitting hard in the tech community, and many projects are transitioning from other continuous integration systems like <a target="_blank" rel="noopener noreferrer" href="https://circleci.com/">Circle CI</a> or <a target="_blank" rel="noopener noreferrer" href="https://travis-ci.org/">Travis CI</a>.Personally I have been using Travis a lot during the past years, for all my OSS projects, and I have gotten very used to it.However, people seem to be &quot;abandoning&quot; travis in favor of GitHub Actions, for different reasons. &quot;It&#x27;s faster&quot;, &quot;I can run smaller tasks in parallel&quot;, etc.In my case, I have moved a few very specific tasks there, where travis was becoming a bottleneck, but I still have mixed feelings about the very-verbose yaml-based config needed to configure a few GitHub Actions, compared to the more concise travis one.In this article I&#x27;ll explain how I improved a travis build to run several smaller tasks in parallel jobs, without having to completely move away from it.<h3>Initial state</h3>This project&#x27;s travis config is relatively simple. It is used to build a JS project for the web browser, and it has to run the next tasks:<ul><li>Lint the code, to make sure it fulfils the project&#x27;s coding standards.</li><li>Run unit tests.</li><li>Run mutation tests.</li><li>Build the docker image, to make sure none of the new changes broke it.</li><li>Conditionally publish a release on GitHub, with a dist file attached to it, if the build is being run for a git tag.</li></ul><pre><pre><code class="language-yaml">dist: bionic

language: node_js

branches:
 only:
 - /.*/

cache:
 directories:
 - node_modules

services:
 - docker

node_js:
 - &#x27;12.16.3&#x27;

install: npm ci

before_script:
 - echo &quot;Building commit range ${TRAVIS_COMMIT_RANGE}&quot;
 - export MUTATION_FILES=$(git diff ${TRAVIS_COMMIT_RANGE:-origin/main} --name-only | grep -E &#x27;src\/(.*).(ts|tsx)$&#x27; | paste -sd &quot;,&quot;)

script:
 - npm run lint
 - npm run test:ci
 - npm run mutate:ci
 - docker build -t project:test .

after_success:
 - node_modules/.bin/ocular coverage/clover.xml

before_deploy: npm run build ${TRAVIS_TAG#?}

deploy:
 - provider: releases
 api_key:
 secure: &lt;key&gt;
 file: &quot;./dist/project_${TRAVIS_TAG#?}_dist.zip&quot;
 skip_cleanup: true
 on:
 tags: true
</code></pre></pre><h3>Problems with this approach</h3>This is more or less ok, but the last two commands in <code>script</code> can be relatively slow and can delay the whole process.Also, specially the mutation tests one, which is currently always considered successful regardless the result, can make the build reach the maximum run time allowed by travis, making the whole build falsely fail.<blockquote>The reason for the <code>before_script</code> step is to determine which source code files changed, and run mutation tests on them only, in order to mitigate this.</blockquote>Other than this, the build config defines &quot;global&quot; customizations that are actually only used for some tasks:<ul><li>Running <code>npm ci</code> is not required for the <code>docker build</code> task.</li><li>Getting the <code>docker</code> service is not required by any of the other tasks.</li><li>Determining changed files is only used by the <code>mutation tests</code> task.</li></ul><h3>Making use of jobs</h3>One cool feature travis supports is the use of a job <a target="_blank" rel="noopener noreferrer" href="https://docs.travis-ci.com/user/build-matrix/">build matrix</a>, that lets you define multiple jobs that run in parallel as part of the same build, and make each one of them do unrelated tasks.Using this feature it is possible to improve the <code>.travis.yml</code> file, making it look like this:<pre><pre><code class="language-yaml">dist: bionic

language: node_js

branches:
 only:
 - /.*/

cache:
 directories:
 - node_modules

node_js:
 - &#x27;12.16.3&#x27;

jobs:
 fast_finish: true
 allow_failures:
 - name: &#x27;Mutation tests&#x27;
 include:

 - name: &#x27;Lint&#x27;
 install: npm ci
 script: npm run lint

 - name: &#x27;Unit tests&#x27;
 install: npm ci
 script: npm run test:ci
 after_success:
 - node_modules/.bin/ocular coverage/clover.xml

 - name: &#x27;Mutation tests&#x27;
 install: npm ci
 before_script:
 - echo &quot;Building commit range ${TRAVIS_COMMIT_RANGE}&quot;
 - export MUTATION_FILES=$(git diff ${TRAVIS_COMMIT_RANGE:-origin/main} --name-only | grep -E &#x27;src\/(.*).(ts|tsx)$&#x27; | paste -sd &quot;,&quot;)
 script: npm run mutate:ci

 - name: &#x27;Build docker image&#x27;
 services:
 - docker
 install: skip
 script: docker build -t project:test .

 - name: &#x27;Publish release&#x27;
 if: tag IS present
 install: skip
 script: skip
 before_deploy: npm run build ${TRAVIS_TAG#?}
 deploy:
 - provider: releases
 api_key:
 secure: &lt;key&gt;
 file: &quot;./dist/project_${TRAVIS_TAG#?}_dist.zip&quot;
 skip_cleanup: true
 on:
 tags: true
</code></pre></pre>This approach introduces all these benefits:<ul><li>Now linting, testing, mutation testing and building the docker image run in parallel, making the build finish earlier.</li><li>The mutation testing step is allowed to fail, and thanks to the <code>fast_finish</code> flag, travis won&#x27;t even wait for it to finish, considering the build successful once the rest have passed.</li><li>Configs that are only meaningful for certain jobs are defined in the job itself, instead of globally.</li><li>The &quot;publish release&quot; job only runs conditionally if the build is for a tag, thanks to the <code>if: tag IS present</code> condition. (More info about <a target="_blank" rel="noopener noreferrer" href="https://docs.travis-ci.com/user/conditional-builds-stages-jobs/">conditional jobs</a> in travis).</li><li>As soon as any of the jobs fails, the whole build fails and you don&#x27;t have to continue waiting. Before this, if the third task failed, you still had to wait for the previous two to finish.</li><li>Each job can have a name, making it more clear in travis UI what tasks are being run:</li></ul><img src="/assets/img/travis-multiple-jobs/travis-jobs.png" alt="Travis CI jobs"/><h3>Conclusion</h3>The main purpose of this article was to showcase that travis still has a lot to give. Github Actions are definitely cool, but there&#x27;s usually no silver bullet for everything, and a combination with other tools might be more suitable.Also, this allows people using travis to improve their builds without having to change everything. Then, once you have split your tasks, if you still want to move to Github Actions, it should be easier.<blockquote>If you are curious, this is the project in which I use this travis configuration: <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client">shlinkio/shlink-web-client</a>.</blockquote>

Running several steps of a Travis CI build in parallel

Asynchronous and non-blocking runtimes are pretty usual in many programming languages, as well as long-lived web apps that stay in memory and are capable of dispatching multiple HTTP requests without having to be fully bootstrapped every time. This has not been traditionally the case with PHP apps. However, many projects are starting to get some adoption, that bring this long-lived approach to the PHP world.The problem with this is that PHP developers are not used to this, and they tend to continue acting as they have always done. Also, libraries might have made some assumptions, making them not work as expected when used under this context.Some of these projects are <a target="_blank" rel="noopener noreferrer" href="https://www.swoole.co.uk">swoole</a>, <a target="_blank" rel="noopener noreferrer" href="https://reactphp.org/">ReactPHP</a> or <a target="_blank" rel="noopener noreferrer" href="https://amphp.org/">Amphp</a>, to give some examples.In this article, I will be focusing on the first one, and explain how to approach some of the pain points I have found after using it for a year and a half on an <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink">existing PHP project</a>.<h3>Introducing Swoole</h3>The main difference swoole has compared to other similar projects is that it&#x27;s written as a native PHP extension, and needs to be installed with <code>pecl</code>.This is obviously a bit cumbersome, but the benefit is that, since it&#x27;s written in C++, it has a better handling of memory allocation, which is very important to achieve what it tries to do.What swoole does is running a main process which bootstraps the PHP application once, and then keeps it in memory so that it can continue dispatching requests without having to load resources every time. This makes it really fast.Those HTTP requests are handled by a set of child processes called &quot;web workers&quot;. Swoole forks the contents in memory for the main process to each one of the workers, so each worker has a &quot;copy&quot; of the application in memory.Each worker is independent, but each one of them can only handle one request at a time, so you have to increase the number of workers if you expect a lot of concurrent traffic.Other than web workers, swoole also has another set of child processes called &quot;task workers&quot;, which can be used to delegate long tasks at runtime to prevent web workers from getting blocked.Here you can see a diagram of swoole&#x27;s architecture.<img src="https://www.swoole.co.uk/images/how-swoole-works.png" alt="How Swoole works"/><blockquote>More information can be found in <a target="_blank" rel="noopener noreferrer" href="https://www.swoole.co.uk/how-it-works">Swoole&#x27;s website</a>.</blockquote><h3>Problems to solve</h3>Now that we know how swoole works, let&#x27;s see some of the challanges I have faced in th past, which are usually not that ovbious when you are used to think in terms of &quot;blocking&quot; and &quot;short-lived&quot;.<h4>Database connections are kept open</h4>One of the first things you find out is that, since the application stays in memory, any database connection that has been opened by a worker (either web or task worker), will be kept open and reused in subsequent executions or HTTP requests served by the app.This, which is in theory good, has a side effect, which is not obvious during development: the opened connection will eventually expire.Since most of the popular database abstraction layers in PHP are coming from the times in which PHP was just a bootstrap-on-every-request technology, they never cared too much about expired database connections, as they would be opened again on next request.However, when using swoole and the like, you have to implement some mechanism which takes care of reconnecting or gracefully recovering when this happens.<blockquote>I wrote an article explaining how I solved this on a middleware-based app served with swoole and using doctrine: <a href="/2019/11/04/how-to-properly-handle-a-doctrine-entity-manager-on-an-expressive-application-served-with-swoole/">How to properly handle a doctrine entity manager on an expressive application served with swoole</a></blockquote>Obviously, swoole (and also others) provides some tools to work with databases (like this <a target="_blank" rel="noopener noreferrer" href="https://www.swoole.co.uk/docs/modules/swoole-async-mysql-client">MySQL client</a>), which I&#x27;m sure do not have this problem (although, I haven&#x27;t personally tried this), but they are more limited than other well adopted libraries.<h4>In-memory caches don&#x27;t behave as expected</h4>It is a frequent practice to use local in-memory caches, like APCu, to improve applications performance in production.Usually APCu is faster than other options, like redis or memcached, so it&#x27;s the choice when you only have one instance of your app running (meaning, you don&#x27;t have a cluster behind a load balancer).However, even if you are running your app on just one server with swoole, because of the web worker system explained earlier, you actually have several copies of your app in memory, and each one of them will have a separated and not shared cache when using APCu.This can lead to inconsistencies which are hard to debug, so you need to have it in mind.Also, since the information that is being loaded is kept in memory anyway, you will not notice such a big improvement by using APCu or other in-memory caches.<blockquote>Notice that this problem does not happen when using distributed/centralized caching solutions, such as redis or memcached, as in that case, the caching technology is shared by all workers.</blockquote><h4>No need to optimize file including/requiring</h4>Many projects have complex configuration systems which are spread into several files. While this make it more maintainable, it also has a performance impact when all those files need to be loaded on every request.Because of that, there are libraries like <a target="_blank" rel="noopener noreferrer" href="https://github.com/laminas/laminas-config-aggregator">laminas-config-aggregator</a> that can dynamically load config from many sources and, if some conditions are met, they can merge the result in a single bigger file that can be used in later requests.In the case of swoole, as all the files will be kept in memory once loaded for the first time, there&#x27;s no need for this kind of optimization.<h4>Class autoloading happens once</h4>This point is very related with the previous one.Composer offers a lot of optimization options so that class autoloading is faster in production. While you usually will still want to use some of those so that the first time a class is being loaded it is still reasonably fast, any subsequent hits will just use the class which is already in memory.One of the composer flags you will probably don&#x27;t want use with swoole is <code>--apcu-autoloader</code>, because of the reasons mentioned two points above this one.<h4>Services should be truly stateless</h4>This is something that you should always do anyway, but it&#x27;s specially important when a service instance is kept in memory between HTTP requests.Sometimes it&#x27;s easy to end up having some small piece of internal state on a service, where we save something as a side effect of a method call, to end up using it when another one of the public methods is invoked.While this could seem harmless when the whole app is bootstrapped on every request, it can have very dangerous side effects when the app is served with swoole, because the instance will persist until another request is dispatched by the same web worker.Just imagine you saved some user data on a service, and it ends up being served to another user on the next request. That won&#x27;t look good.Because of this, make sure your services are truly stateless, and if for any reason that&#x27;s not possible, at least remember to have some mechanism in place that flushes the data just before finishing the request.<h4>Hot reloading for dev envs is not that good</h4>One thing we usually take for granted is that we can modify a PHP file and just by making a new request, the new code will be executed. However, when the code is kept in memory, it&#x27;s not that straightforward.When you are developing a project which is served with swoole, you will have to restart the server every time to get your changes applied.Swoole has a mechanism to do a light server reload, which is faster. You can find the docs in <a target="_blank" rel="noopener noreferrer" href="https://www.swoole.co.uk/docs/modules/swoole-server-reload">it&#x27;s website</a>.The problem with this is that you need to implement the mechanism to invoke that when a file is changed, or use some library that does it for you.Also, I have noticed that even calling that and seeing that the server is reloaded, does not always have the expected effect, and you have to still end up doing a hard reload. It&#x27;s something I don&#x27;t fully understand and I still need to investigate a bit further.<h3>Conclusion</h3>As it always happens when new technologies appear, it takes some time to get used to them, but I strongly suggest you to give a try to swoole or any other non-blocking runtime, because it makes your apps super fast.Just remember to have all of the above in mind ;-)That said, here you can find some libraries that will make your life easier when trying to serve existing projects with swoole, without having to couple with it and being able to continue using your favourite framework:<ul><li>IDE helper: <a target="_blank" rel="noopener noreferrer" href="https://github.com/swoft-cloud/swoole-ide-helper">https://github.com/swoft-cloud/swoole-ide-helper</a></li><li>Mezzio (formerly Zend Expressive): <a target="_blank" rel="noopener noreferrer" href="https://github.com/mezzio/mezzio-swoole">https://github.com/mezzio/mezzio-swoole</a></li><li>Symfony: <a target="_blank" rel="noopener noreferrer" href="https://github.com/k911/swoole-bundle">https://github.com/k911/swoole-bundle</a></li><li>Laravel: <a target="_blank" rel="noopener noreferrer" href="https://github.com/swooletw/laravel-swoole">https://github.com/swooletw/laravel-swoole</a></li></ul>Also, here you can find some more articles talking about this topic:<ul><li><a target="_blank" rel="noopener noreferrer" href="https://www.zend.com/blog/why-you-should-use-asynchronous-php">https://www.zend.com/blog/why-you-should-use-asynchronous-php</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://samsonasik.wordpress.com/2020/04/05/using-swoole-in-mezzio-application-with-sdebug/">https://samsonasik.wordpress.com/2020/04/05/using-swoole-in-mezzio-application-with-sdebug/</a></li></ul>

Considerations when working with async PHP runtimes like swoole

Some of you probably know that I have a pet project in which I like to work from time to time. This project is a self-hosted URL shortener called <a target="_blank" rel="noopener noreferrer" href="https://shlink.io">Shlink</a>.Shlink is built using expressive as the base framework for the HTTP-dispatching task. A while ago, an expressive module was released to officially support serving expressive apps with <a target="_blank" rel="noopener noreferrer" href="https://www.swoole.co.uk/">swoole</a>, and I decided to include it on Shlink.<h3>How does swoole work?</h3>Swoole is an asynchronous non-blocking I/O framework which works in a similar way as node.js, but for PHP apps.It has been conceived in a way that the app stays in memory between requests, removing the bootstrapping step and making apps to be served much faster.Swoole can serve as many simultaneous requests as you tell it to. For this it makes use of workers. Each worker can serve one request at a time, and every worker has a separate instance of the app loaded in memory (this is something I <a target="_blank" rel="noopener noreferrer" href="https://twitter.com/dominikzogg/status/1189403552399134720">learned recently</a>).Because of this, you have to sometimes change a bit the way you design your code. For example, if a service needs to be stateful (it shouldn&#x27;t, but shit happens), you will have to remember that the state will persist between requests, and you will want to somehow reset it to avoid unexpected side effects.<h3>How does this affect the EntityManager?</h3>One of the main services that keeps this internal state in Shlink is the doctrine <a target="_blank" rel="noopener noreferrer" href="https://www.doctrine-project.org/projects/doctrine-orm/en/current/tutorials/getting-started.html#obtaining-the-entitymanager">EntityManager</a>.Due to the fact that it was originally designed to be used on a classical web server + CGI context, assuming it would be recreated on every request, there are a few considerations to take into account:<ul><li>It implements the unit of work pattern. It internally keeps track of all the entities that have been created/changed until you decide to flush it.</li><li>If something fails, the <code>EntityManager</code> can get closed, which makes it unusable after that moment.</li><li>If the database connection expires, the <code>EntityManager</code> will not gracefully recover. Instead, it will fail, since it&#x27;s not aware of the connection not being usable, getting yourself in previous point.</li></ul><h3>How to workaround it</h3>I learned about these issues by try and error, by using it on the app and getting the failures. Now, I want to share how I workaround those issues.The first one I faced was the one making the app unusable after the <code>EntityManager</code> was closed. In order to solve this I created a decorated instance (naming, an object implementing <code>EntityManagerInterface</code> which in turn was wrapping an actual <code>EntityManager</code>), which was making sure the wrapped instance was transparently recreated if at some point it was closed.However, this caused some side effects, and I finally realized that it was better to make the <code>EntityManager</code> to have to be reopened from the outside, and only once per request (this is closer to how it would behave on a classical set-up).That&#x27;s how I came up with the <code>ReopeningEntityManager</code> Shlink is currently using (as of v1.20.0):<pre><pre><code class="language-php">&lt;?php

declare(strict_types=1);

namespace Shlinkio\Shlink\Common\Doctrine;

use Doctrine\ORM\Decorator\EntityManagerDecorator;

class ReopeningEntityManager extends EntityManagerDecorator
{
 /** @var callable */
 private $createEm;

 public function __construct(callable $createEm)
 {
 parent::__construct($createEm());
 $this-&gt;createEm = $createEm;
 }

 public function open(): void
 {
 if (! $this-&gt;wrapped-&gt;isOpen()) {
 $this-&gt;wrapped = ($this-&gt;createEm)();
 }
 }
}
</code></pre></pre><blockquote>You can find the actual code in <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-common/blob/master/src/Doctrine/ReopeningEntityManager.php">shlink-common</a>.</blockquote>It just expects a factory that creates the actual <code>EntityManager</code>, and exposes an <code>open</code> public method which re-creates the wrapped instance if closed.This method is called from a <a target="_blank" rel="noopener noreferrer" href="https://www.php-fig.org/psr/psr-15/">PSR-15</a> middleware which needs to be registered early in the middleware pipeline. It makes sure the method is called before the next middleware on the stack is invoked:<pre><pre><code class="language-php">&lt;?php

declare(strict_types=1);

namespace Shlinkio\Shlink\Common\Middleware;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Shlinkio\Shlink\Common\Doctrine\ReopeningEntityManager;

class CloseDbConnectionMiddleware implements MiddlewareInterface
{
 /** @var ReopeningEntityManager */
 private $em;

 public function __construct(ReopeningEntityManager $em)
 {
 $this-&gt;em = $em;
 }

 public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
 {
 $this-&gt;em-&gt;open();

 try {
 return $handler-&gt;handle($request);
 } finally {
 $this-&gt;em-&gt;getConnection()-&gt;close();
 $this-&gt;em-&gt;clear();
 }
 }
}
</code></pre></pre><blockquote>Again, the code can be found in <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-common/blob/master/src/Middleware/CloseDbConnectionMiddleware.php">shlink-common</a></blockquote>This middleware also does two more things (this time, after calling the next middleware on the stack, and making sure it does it even if an exception is thrown).<ul><li>It first closes the database connection. By doing it so, we make sure the <code>EntityManager</code> will reconnect the next time it needs to interact with the database, and therefore, we avoid the &quot;expired connection&quot; issue.</li><li>Then it clears the <code>EntityManager</code> itself. This avoids memory leaks, and also prevents that any orphan/non-flushed entity &quot;transcends&quot; to the next request, solving the first problem.</li></ul><h3>Further considerations</h3>This approach has been working well so far, but it&#x27;s important to assume that the <code>EntityManager</code> was not really designed for this non-blocking kind of context.You need to know that the worker making use of it will not be able to serve any request until the <code>EntityManager</code> finishes its job. Because of this you might want to increase the number of swoole workers.Also, closing the DB connection on every request is not the most optimal approach. It would be perfect to have a connection pool that was able to recreate connections when expired, and to keep them open as long as possible for faster operations. However, the <code>EntityManager</code> was not designed for that, so it&#x27;s better to close it.You also need a <code>callable</code> to pass to the <code>ReopeningEntityManager</code>. The way you solve this depends on your implementation and the dependencies you use.In my case, in Shlink I make use of the <code>ServiceManager</code>, so I have a delegator factory which takes the actual factory and passes it to the <code>ReopeningEntityManager</code>:<pre><pre><code class="language-php">&lt;?php

declare(strict_types=1);

namespace Shlinkio\Shlink\Common\Doctrine;

use Psr\Container\ContainerInterface;

class ReopeningEntityManagerDelegator
{
 public function __invoke(ContainerInterface $container, string $name, callable $createEm): ReopeningEntityManager
 {
 return new ReopeningEntityManager($createEm);
 }
}
</code></pre></pre><blockquote>You can find the actual code in <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-common/blob/master/src/Doctrine/ReopeningEntityManagerDelegator.php">shlink-common</a>.</blockquote><h3>Conclusion</h3>I wanted to write this article as a recap for myself too, since I had to ask and investigate many times, and I couldn&#x27;t find a single source of truth explaining everything.I hope that, if you ended up here, this article served you well.

How to properly handle a doctrine entity manager on an expressive application served with swoole

For a long time, I have been trying to include tests in every project in which I&#x27;ve worked on.There are several types of automated tests (or what should actually be called <a target="_blank" rel="noopener noreferrer" href="https://abstracta.us/insights/guide-continuous-testing/automated-checks">automated checks</a>). From unit tests, integration and functional tests, to end-to-end tests.Each one of them differs from the rest by the scope they try to cover. From small units of code which are tested completely detached from external dependencies, to a whole app which is tested as a black box like if an end consumer was using it.I&#x27;m not going to deeply discuss the semantics behind this, or where an integration test ends and an end-to-end test starts, because it&#x27;s quite frequently a blurry line.I want to focus on unit tests, and a frequently used practice (even in my own tests), which I have read (and felt) several times, it might not be the best approach.<blockquote>This article is not focused on any particular technology, since I have found this in a lot of different projects.</blockquote><h3>What&#x27;s a unit test</h3>According to <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Unit_testing">Wikipedia</a>, unit testing is a &quot;method by which individual units of source code [...] are tested to determine whether they are fit for use&quot;.While this might look like a clear definition, it&#x27;s actually quite open because, what&#x27;s a &quot;unit&quot; in the context of unit testing?Very often, in object oriented programming projects, people take a class as a unit to test, and create a unit test for every class. In other paradigms, like functional programming, you might consider a function as the unit to be tested, or a set of functions which you have decided to put together in a module.This is not really important for the purpose of this article. What&#x27;s really important is to take into account that, in order to properly &quot;unit test&quot; a &quot;unit of source code&quot;, you have to do it by isolating it from any dependency of that unit.One of the better ways to achieve this is by following the <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Dependency_inversion_principle">Dependency Injection Principle</a>. Without it you will probably end up trying to hack yourself in order to detach a &quot;unit&quot; from its dependencies.<blockquote>You can find other articles about <a href="/tag/dependency-injection/">Dependency Injection</a> in my blog.</blockquote><h3>Replacing dependencies</h3>A very frequent practice when unit testing a unit of source code is to replace its dependencies with <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Test_double">test doubles</a>, in order to properly isolate every unit when testing it.Test doubles are basically objects compatible with the dependencies of the subject under test, that are created just for the purpose of the test and have some useful capabilities, like capturing how they have been called, or what should they return when called.When you use one of those test doubles to assert how they were called as part of the test itself, you are using them as &quot;spies&quot;.<h3>Over-trusting spies</h3>All this introduction and contextualization had a single purpose.I find myself (and others) in the situation in which you prepare a test double to behave in a certain way, then you call your subject under test, and then assert that your expectations on how the test double was called are correct, by spying on it.This sometimes feels wrong, since it seems you are testing the test double/s instead of the subject under test.I have read many times that, in a unit test, we should not actually know the internal implementation of the subject under test, but only test that, based on certain input, the expected output is returned (so, trust its public API).However, there are cases in which some function/method does not really have any output, and we can only verify everything is going right by spying on the test doubles.So, at the end of the day, I have mixed feelings about this practice.<h3>Conclusion</h3>Sadly, I cannot state a clear conclusion. This is actually an open article, and I would love to get your point of view in the form of a <a href="#comments-box">comment</a>.It would be great to see how others face this, if you use other kinds of test doubles instead of spies, or if you are just ok with the implications.

Is spying on mocks a bad practice for unit tests?

Some time ago I wrote the most successful article of this blog, <a href="/2014/10/09/advanced-usage-of-service-manager-in-zend-framework-2/">Advanced usage of ServiceManager in Zend Framework 2</a>, explaining all the ways a service can be created by making use of <code>Zend\ServiceManager</code>, the service container component in Zend Framework 2.On this article I&#x27;m going to show a real example where objects and services are all managed and created with a <code>ServiceManager</code> instance, which makes decoupling components and dependency injection very easy.It is not a Zend Framework 2 application, because the <code>ServiceManager</code> is so integrated there that its power could go unnoticed. Instead, I&#x27;m using a <a target="_blank" rel="noopener noreferrer" href="http://www.slimframework.com/">Slim</a> framework based application, which solves some common problems that has nothing to do with this article (like routing and request dispatching) and allows us to concentrate on what&#x27;s important.The project is just a simple application to perform a <a target="_blank" rel="noopener noreferrer" href="https://es.wikipedia.org/wiki/CRUD">CRUD</a> over two fictitious entities, users and items. Very simple.<h3>Getting the application</h3>As usual, I have hosted the example application on github. Clone it from <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya-blog/service-manager-example">here</a>, install dependencies by running <code>composer install</code> and start the built-in web server by running <code>php -S 0.0.0.0:8000 -t public</code>.<blockquote>If you are not familiar with composer, take a look at this <a href="/2014/07/19/dependency-management-and-autoloading-in-php-projects-with-composer/">article</a>.</blockquote>If you are used to modern PHP applications, the project structure shouldn&#x27;t be a problem. There is a <code>src</code> folder with the source code, a <code>public</code> folder which is the document root of the application, a <code>config</code> folder with some configuration files and a <code>tests</code> folder with the unit tests.<h3>Dependency injection</h3>Let&#x27;s start with some thoughts about dependency injection.In the past, when I had to learn dependency injection, I found out that many tutorials just explain that it is important to decouple componentes from the application, and pass elements to objects instead of letting them to create those elements inside themselves.That&#x27;s a good theory, but introduces another problem. Without dependency injection, creating an object is as easy as <code>new FooBar()</code>, and all dependencies will be automatically created on the inside, but with dependency injection I could end with something like this.<pre><pre><code class="language-php">$logger = new Logger(&#x27;/var/log/mylogs.log&#x27;);
$serviceOne = new ServiceOne(&#x27;foo&#x27;, &#x27;bar&#x27;);

$config = include __DIR__ . &#x27;/config/config_file.php&#x27;);
$serviceTwo = new ServiceTwo($serviceOne, $config[&#x27;param&#x27;], $config[&#x27;another_param&#x27;]);

$fooBar = new FooBar($serviceTwo, $logger);
</code></pre></pre>Now I have to pass two dependencies to my <code>FooBar</code> object. One of them also dependes on another object and a raw configuration. And this process could even be more complex.When I try to explain dependency injection, people usually tries to mentally adapt their old code and substitute the <code>new FooBar()</code> with the previous code snippet, and their reaction is usually &quot;Dependency injection is hard! I will need to duplicate a lot of code!&quot;.What those tutorials don&#x27;t explain is how to solve this new problem, and that we now should define the way the objects are created just in one place, and have some mechanism to access to that objects anywhere else once created.That task is usually performed by an object, the &quot;inversion of control&quot; container, in plenty of forms, a service locator, service container, dependency injection container...The <code>ServiceManager</code> is going to act as the &quot;inversion of control&quot; container of this project. Let&#x27;s see how.<h3>Solving the problem</h3>Now that we have identified the problem, let&#x27;s take a look at the example, and how the <code>ServiceManager</code> is capable of managing the whole application, making the task of creating objects much easier and without code duplication.<h4>Bootstrapping</h4>The project&#x27;s front controller is the <code>public/index.php</code> file, which only includes the <code>src/bootstrap.php</code> file. The first thing we do is create the <code>ServiceManager</code> instance (there is no need for more than one in the whole project) by consuming the configuration in <code>config/services.php</code>.<pre><pre><code class="language-php">$sm = new ServiceManager(new Config(include __DIR__ . &#x27;/../config/services.php&#x27;));

// ...
</code></pre></pre>After that, we use the <code>ServiceManager</code> to get the app instance, the main object in Slim framework.<pre><pre><code class="language-php">// ...

/** @var Slim $app */
$app = $sm-&gt;get(&#x27;app&#x27;);

// ...
</code></pre></pre>Thanks to the <code>ServiceManager</code>, we have obtained the app object with just one instruction, <code>$sm-&gt;get(&#x27;app&#x27;)</code>, as easy as doing <code>new \Slim\Slim()</code>, but the <code>ServiceManager</code> has customized and cached our object, we just had to previously tell it how to do it.If we go to the <code>config/services.php</code> file, we&#x27;ll see that there is an &#x27;app&#x27; service defined as an alias of the <code>Slim::class</code> service, which in turn is an invokable, which means that it will be constructed by the <code>ServiceManager</code> just by instantiating the object with no arguments in the constructor.But we said that the object has been customized. Where did that happen?If we go to the delegators block, we&#x27;ll see that there is defined one delegator for the <code>Slim::class</code> service. Delegators are called by the <code>ServiceManager</code>, allowing us to customize certain service when it is going to be created.Our SlimDelegator sets some configuration options in the Slim instance after it is created and before it is returned by the <code>ServiceManager</code>.<blockquote>The name of a service can be anything as long as it is unique. Using the fully qualified class name is just a convention when there is only one way to create the object returned.</blockquote>The final step of the bootstrap process is to use the app object to register a couple routes.<pre><pre><code class="language-php">// ...

// Homepage
$app-&gt;get(&#x27;/&#x27;, function () use ($app) {
 $app-&gt;render(&#x27;home.phtml&#x27;);
})-&gt;name(&#x27;home&#x27;);

// Users pages
$app-&gt;addControllerRoute(&#x27;/users/list&#x27;, UserController::class . &#x27;:list&#x27;)
 -&gt;name(&#x27;users-list&#x27;)
 -&gt;via(&#x27;GET&#x27;);
// ...

// Items pages
$app-&gt;addControllerRoute(&#x27;/items/list&#x27;, ItemController::class . &#x27;:list&#x27;)
 -&gt;name(&#x27;items-list&#x27;)
 -&gt;via(&#x27;GET&#x27;);
// ...
</code></pre></pre>The first route is the home page, which is only used to select between users and items.The rest of the routes are endpoints to perform each operation of both users and items CRUDs. They are resolved to a controller&#x27;s action.<h4>Controllers</h4>Since Slim does not support controllers I&#x27;ve used the <a target="_blank" rel="noopener noreferrer" href="https://github.com/fortrabbit/slimcontroller">slimcontroller</a> package which allows us to dynamically load controllers from Slim&#x27;s container.I&#x27;ve also used this useful <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/slim-container-sm">package</a> I created some days ago, which replaces Slim&#x27;s container with another object which wraps a <code>ServiceManager</code> which is similar but much more powerful. In combination with slimcontroller makes controllers to be loaded from the <code>ServiceManager</code>.That is to say, the last two routes will fetch a <code>UserController::class</code> or <code>ItemController::class</code> service from the <code>ServiceManager</code> and use it as the controller for that route.Those two controllers are defined in <code>config/services.php</code> as factories. A factory is the easiest way to perform dependency injection in a service.For example, the UserControllerFactory looks like this.<pre><pre><code class="language-php">namespace Acelaya\Controller;

use Acelaya\Service\UserService;
use Slim\Slim;
use Zend\ServiceManager\FactoryInterface;
use Zend\ServiceManager\ServiceLocatorInterface;

class UserControllerFactory implements FactoryInterface
{
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
 /** @var UserService $userService */
 $userService = $serviceLocator-&gt;get(UserService::class);
 return new UserController($userService);
 }
}
</code></pre></pre>It creates the UserController instance and returns it, but it also injects its only dependency on it.That dependency is also fetched from the <code>ServiceManager</code>, because that <code>$serviceLocator</code> is the <code>ServiceManager</code> which injects itself in factories when calling the <code>createService</code> method. That is really usefull, because we can access services easily in a recursive way.At this point we don&#x27;t need to know how the <code>UserService::class</code> service is created, and we can focus on creating the UserController. That&#x27;s a good example of <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Single_responsibility_principle">Single Responsibility Principle</a>.The ItemController is created in a very similar way. You can take a look at the class <code>src/Controller/ItemControllerFactory.php</code>.But this is not all. Controllers extending the AbstractController depend also on a <code>Slim\Http\Request</code>, a <code>Slim\Http\Response</code> and a <code>Slim\View</code> that are not injected on their respective factories.For this purpose we have defined three initializers in the <code>config/services.php</code> file, which will inject those objects on any instance implementing certain interfaces. The AbstractController implements all the interfaces, so creating a UserController or ItemController will result in all the initializers to inject those dependencies via setters.This is one of the initializers, but the rest are very similar.<pre><pre><code class="language-php">namespace Acelaya\Mvc;

use Zend\ServiceManager\InitializerInterface;
use Zend\ServiceManager\ServiceLocatorInterface;

class RequestAwareInitializer implements InitializerInterface
{
 public function initialize($instance, ServiceLocatorInterface $serviceLocator)
 {
 if ($instance instanceof RequestAwareInterface) {
 $app = $serviceLocator-&gt;get(&#x27;app&#x27;);
 $instance-&gt;setRequest($app-&gt;request);
 }
 }
}
</code></pre></pre>We are fetching the app here. Since it is already created at this point, the <code>ServiceManager</code> will return the same instance.Now we know that any route starting with /users will end with a fully configured UserController fetched from the <code>ServiceManager</code>, and any route starting with /items will do the same with an ItemController.<h4>Other services</h4>We saw that creating any controller will fetch another service from the <code>ServiceManager</code>. Those are the <code>UserService::class</code> or the <code>ItemService::class</code> respectively.If we go to the <code>config/services.php</code> file we won&#x27;t find those services defined, but the <code>ServiceManager</code> is capable of creating them. And how is that?In the abstract_factories block, we have defined a ServiceAbstractFactory. Abstract factories are used as last resort to create services that are not explicitly defined.In our case both services extend the <code>AbstractService</code> and have the same dependencies. This abstract factory checks if the service that is going to be created extends that class, and in that case creates it by injecting another two dependencies fetched from the <code>ServiceManager</code> again (recursivity is awesome!), which will run their own factories.This abstract factory is in <code>src/Service/ServiceAbstractFactory.php</code>, if you want to take a look at its implementation.<h4>Everything is running</h4>And thats all the theory. The application works now in theory. Check it.The most powerful aspect of the <code>ServiceManager</code> is that objects are recursively created in different ways. The creation implementation is defined just in one place without code duplication.We have performed dependency injection and the code wasn&#x27;t harder to handle.<h3>Unit tests</h3>The project now works, but we can&#x27;t remember to manually test everything every time we refactor the code or add new features. That&#x27;s where unit tests come.Having a good test suite is hard, but it is even harder without dependency injection. Tests end running almost the whole application, with too many objects created under the hood when the subject under test is created.With dependency injection, we can inject fake harmless objects in the subject under test, making sure we are going to test just a small piece of code. Indeed, one of the most important reasons to use dependency injection is to be able to test your code without wanting to kill yourself.For example. On this project, both UserService and ItemService depend on an instance of <code>Doctrine\ORM\EntityManager</code>. That object performs operations against a database, but we don&#x27;t want to connect to the database every time we run our tests.If you take a look at <code>tests/Service/UserServiceTest.php</code> you will see how the EntityManager is faked by using phpunit&#x27;s mocks API.<pre><pre><code class="language-php">// ...

public function setUp()
{
 $repository = $this-&gt;getMock(&#x27;Doctrine\Common\Persistence\ObjectRepository&#x27;);
 $repository-&gt;expects($this-&gt;any())
 -&gt;method(&#x27;findAll&#x27;)
 -&gt;willReturn([]);

 $objectManager = $this-&gt;getMock(&#x27;Doctrine\Common\Persistence\ObjectManager&#x27;);
 $objectManager-&gt;expects($this-&gt;any())
 -&gt;method(&#x27;getRepository&#x27;)
 -&gt;willReturn($repository);
 $objectManager-&gt;expects($this-&gt;any())
 -&gt;method(&#x27;persist&#x27;)
 -&gt;willReturn(null);
 $objectManager-&gt;expects($this-&gt;any())
 -&gt;method(&#x27;flush&#x27;)
 -&gt;willReturn(null);
 $objectManager-&gt;expects($this-&gt;any())
 -&gt;method(&#x27;find&#x27;)
 -&gt;willReturn(new User());

 $this-&gt;userService = new UserService(
 $objectManager,
 new Logger(new Filesystem(new NullAdapter()), &#x27;fake.log&#x27;)
 );
}

// ...
</code></pre></pre>If I wasn&#x27;t injecting the EntityManager, the UserService would be tightly coupled with the database. Instead, the UserService expects an object of an abstract type to be injected on it, so it is decoupled with the system that saves the data.<h3>Conclusion</h3>You have seen a real example which uses the <code>ServiceManager</code>. There is no theory, you can check it yourself. I have used each object creation strategy at least once (invokables, factories, initializers, abstract_factories and delegators) so that you can see how it works.As I mentioned earlier, I already wrote a more theoretical article on the <code>ServiceManager</code> subject a while ago. You can find it <a href="/2014/10/09/advanced-usage-of-service-manager-in-zend-framework-2/">here</a> if you need it (indeed I recommend you to read it).I hope you use dependency injection in your projects from now on. There is no excuse not to do it, you just need to change your point of view.By the way, I have not explained everything of this project. If you start digging into the code and have any comment, feel free to post it here.

Managing objects creation and dependency injection with Zend\ServiceManager

Setting up a development environment is not always easy, specially for web development. Sometimes you need to install and configure plenty of applications. A database server, a web server, server-side programming language binaries, mail server, job queue server, specific package managers, building tools, debug and profiling tools, etc.Each one of them will need to be in a concrete version, and you will need to handle their dependencies too. You could think that&#x27;s a one time task, but what happens when you work on multiple projects at the same time. You need to install that for each one of them, and also make sure there are no conflicts with different environments.There is a tool that eases this task, called <a target="_blank" rel="noopener noreferrer" href="https://www.vagrantup.com/">Vagrant</a>, that allows us to create a virtualized environments with all the tools, system packages and applications we need to use in a project. Each environment is running on its own virtual machine, so there is no conflicts between them.The configuration of each virtual machine is defined in a file, that can be pushed to the VCS server, so that any other team member can use the same exact environment as you. By using that file, Vagrant creates a machine, downloads the OS and installs it, installs the packages and starts services, so that we can start working in no time.This is a much more efficient way to work, since that configuration file (called Vagrantfile) can be reused multiple times.<h3>Installing vagrant</h3>Vagrant is a command line tool which eases the interaction with the virtual machines. Start a machine, halt a machine open a SSH connection or refresh the configuration by reading the Vagrantfile are easy tasks which only need a certain command to be executed.There are packages for every major operating system that can be downloaded from <a target="_blank" rel="noopener noreferrer" href="https://www.vagrantup.com/downloads.html">here</a>.You will also need to install <a target="_blank" rel="noopener noreferrer" href="https://www.virtualbox.org/wiki/Downloads">VirtualBox</a> to handle virtual machines. Others are supported too.<h3>Creating the Vagrantfile</h3>The Vagrantfile is the main configuration file for the virtual machine. It defines the operating system to be used, the system packages to be installed and how to do it, ports to be mapped to the host machine, folders to be shared, etc.It is usually placed in the root directory of your project, since the folder containing it will be mapped to the folder <code>/vagrant</code> inside the virtual machine. This way the complete project will be available inside the virtual machine, for example to be served by a web server. A simple example of a Vagrantfile could be this.<pre><pre><code class="language-ruby">Vagrant.configure(&quot;2&quot;) do |config|
 
 # This is the operating system to be installed. Ubuntu 12.04 in this case
 config.vm.box = &quot;hashicorp/precise32&quot;
 
 # The script &quot;bootstrap.sh&quot; will we run within the virtual machine once installed
 config.vm.provision :shell, path: &quot;bootstrap.sh&quot;
 
 # The port 8888 will be forwarded from the local machine to the virtual machine&#x27;s port 80
 config.vm.network :forwarded_port, host: 8888, guest: 80
 
end
</code></pre></pre>This is very easy to undertand. We are telling vagrant to install Ubuntu 12.04, start the machine and run the bootstrap.sh script, which could be used to define which system packages to install.Then, we forward the port 8888 in the local machine to the port 80 in the virtual machine, so that we can see the application by accessing to <code>http://localhost:8888</code>.You have an example project using this Vagrantfile <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya-blog/vagrant">here</a>. Clone it, go to the folder and run <code>vagrant up</code>. Once it finishes go to <a target="_blank" rel="noopener noreferrer" href="http://localhost:8888">http://localhost:8888</a> and you should see a nice Hello World! which is being served from the virtual machine.However, this example is too simple. In real projects we usually have more complex requirements, and configuring the complete Vagrantfile is not so easy.For this situations, we have multiple online assistants which can be used to create more complex Vagrantfiles. One of the best for PHP projects is <a target="_blank" rel="noopener noreferrer" href="https://puphpet.com">PuPHPet</a>, which is based on Puppet.<h3>Setting up the machine</h3>The first step is to go to <a target="_blank" rel="noopener noreferrer" href="https://puphpet.com">PuPHPet</a>&#x27;s webpage and follow the steps of the wizard. Select the operating system to be installed, the web server, the PHP version and such, the result depends on your needs. Once you finish this you will be able to download a complete configuration file.Extract downloaded file wherever you want, open a console and go to the extracted folder. Now run <code>vagrant up</code> and the machine will be created and configured. This process may take some time, so be patient.After a while, the virtual machine will be up an running. You can take a look at the extracted Vagrantfile and see that it is a little more complex than the first example.If you include the Vagrantfile and the puphpet folder in your project&#x27;s VCS you will be able to reproduce the same environment anywhere you go just by clonning the repository.<h3>Guest and host machine integrations</h3>SSH access: One of the more common things we&#x27;ll need to do is to open a SSH connection against the virtual machine. To accomplish that task we just need to go to the folder where the Vagrantfile lives, or one of its subfolders and run <code>vagrant ssh</code>. Now you are able to do anything on the virtual machine as if it were your host machine.Folders sync: Another thing we&#x27;ll probably need to do is to sync folders between the host machine and the guest machine. As I said earlier, the Vagrantfile parent folder is mapped by default to the <code>/vagrant</code> folder in the virtual machine, but we could change the folders in case of need.To define a folder that should be synced, just place a line like this in your Vagrantfile.<pre><pre><code class="language-ruby">config.vm.synced_folder &quot;subfolder/&quot;, &quot;/anywhere/else/in/the/virtual/machine&quot;
</code></pre></pre>Port forwarding: This was seen in the first example. We could map a port in the host machine to another port in the virtual machine so that requests to the first one are forwarded to the other. We could also access the virtual machine IP or hostname directly, that depends on our needs.<h3>Managing virtual machines</h3>After some time working with vagrant you&#x27;ll probably have more than one virtual machine created and vagrant also provides some commands to handle them. By the way, the virtual machines in vagrant are called boxes.We have seen that the <code>vagrant up</code> command creates a virtual machine, but it also turns on a previously halted box. To safely halt a virtual machine, just run <code>vagrant halt</code> and all the resources will be freed. We have also the <code>vagrant suspend</code> which, as you can guess, is used to suspend a box and <code>vagrant resume</code>, which resumes a suspended box.Sometimes we will need to update a virtual machine. Updating the Vagrantfile and running the <code>vagrant up</code> command is not enugh for already created boxes, you will need to run <code>vagrant reload</code> so that the Vagrantfile is processed again. If you also need to refresh the provisions (the bootstrap.sh script in our first example) either run <code>vagrant provision</code> or <code>vagrant reload --provision</code> which will both reload the configuration and provision the machine.Finally, when you need to delete a virtual machine, just run <code>vagrant destroy</code>.You can also manage all the boxes you have installed, without having to be in the directory of a specific machine, by using the commands under <code>vagrant box</code>. Try <code>vagrant box help</code> to see what&#x27;s available.<h3>Conclusion</h3>This is pretty much it. This will let you encapsulate a PHP project inside a virtual machine, allowing you to use different applications and services on each one of them and &quot;tracking&quot; the state of the machine itself so that any collaborator can work in the same environment as you.Of course there are other advanced usages for Vagrant, like deployment of machines to virtualization systems like Amazon Web Services, but that&#x27;s another articles subject.For a complete vagrant documentation, follow this <a target="_blank" rel="noopener noreferrer" href="https://docs.vagrantup.com/v2/getting-started/index.html">link</a>.

Setting up a PHP development environment with Vagrant

Some time ago, on January 2014, I decided to start writing a blog.Seemed like a good idea. I might be able to show my skills and learn new ones at the same time.I didn&#x27;t wanted to use a very complex tool for this purpose, or to create one of my own (why to reinvent the wheel?), so I decided that blogger or wordpress could be the right options.After weighing the pros and cons of both options I opted for wordpress, because it seemed more customizable, and having a <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Virtual_private_server">VPS</a> could ease the self-hosting task.At the begining it was a good solution, but finally proved to be hard to control. Not easy to customize the layout, very resource consuming, hard to optimize, etc.I looked for alternatives and found an interesting one without all the previous problems, <a target="_blank" rel="noopener noreferrer" href="https://sculpin.io/">Sculpin</a>.We discussed the tool in the <a target="_blank" rel="noopener noreferrer" href="https://twitter.com/symfony_zgz">Symfony Zaragoza</a> group, and I really loved it from the begining.<h3>First approach to Sculpin</h3>In the Github era, many static site generators have appeared, because Github allows us to host static sites for free. Those generators allows us to make a &quot;dynamic&quot; website which is compiled into a static site.There are many alternatives. From <a target="_blank" rel="noopener noreferrer" href="https://jekyllrb.com/">Jekyll</a>, the Github official static site generator written in ruby, to <a target="_blank" rel="noopener noreferrer" href="http://blog.getpelican.com/">Pelican</a>, another python-powered alternative.The problem is that I&#x27;m a PHP developer, and I&#x27;m not as confortable with those languages as I am with PHP, so I looked for a PHP alternative and Sculpin appeared.Sculpin uses Symfony components, and is fully integrated with composer. I like both tools so I finally decided to use it.For more information about how to use Sculpin, it has a very good [documentation](https://sculpin.io/getstarted/).<h3>Migrating from Wordpress</h3>There was a few features in wordpress that I didn&#x27;t wanted to loose and are not easy to implement in a static site, like comments, built-in search and RSS feed. I also didn&#x27;t wanted to loose the already indexed content, so I needed to keep the old URLs, at least those pointing to the articles.Luckily for me, there is a <a target="_blank" rel="noopener noreferrer" href="https://github.com/sculpin/sculpin-blog-skeleton">Sculpin Blog Skeleton</a> in github with many of the work already done. It includes an atom feed that is refreshed every time you compile your site.To get comments in my static blog, I have used <a target="_blank" rel="noopener noreferrer" href="https://disqus.com/">disqus</a>. It uses a very easy javascript api to host your comments which are associated to the article&#x27;s unique URL. Also, they allow to import comments from wordpress, so I could also keep the old comments.There are other platforms like this, but they don&#x27;t look as good as disqus.The built-in search was one of the hardest features to implement. I have used <a target="_blank" rel="noopener noreferrer" href="http://lunrjs.com/">lunr.js</a>, a javascript full text search engine, but I was not sure how to deal with it, so I finally found a Sculpin blog using it, and copy-pasted the needed code. Thanks to <a target="_blank" rel="noopener noreferrer" href="http://blog.andrewshell.com">Andrew Shell</a> for his code.After this I just needed to get the articles from wordpress.Sculpin uses <a target="_blank" rel="noopener noreferrer" href="http://twig.sensiolabs.org/">twig</a> templates and/or <a target="_blank" rel="noopener noreferrer" href="http://es.wikipedia.org/wiki/Markdown">markdown</a> to write articles, so it&#x27;s easy to copy-paste html documents on them. That&#x27;s what I did. A little customization and done.Keeping the URLs was easy, because I was using the y/m/d/foobar form in wordpress, and the Sculpin skeleton uses that format by default.Finally I was considering to host the blog in Github, but I decided to use my VPS, to use some htaccess tricks, like some rewrite rules in order to redirect old URLs to new ones and set a customized 404 page.The result is the blog you are now seeing.<h3>Conclusion</h3>My conclusion is that a dynamically generate static site is a good solution for a personal blog. It loads superfast, is very SEO friendly and is easily customizable, but it has an important problem. Only advanced users can use it.The lack of <a target="_blank" rel="noopener noreferrer" href="https://es.wikipedia.org/wiki/WYSIWYG">WYSIWYG</a> editor makes users with no experience on HTML/Markdown (at least) impossible to deal with this kind of sites.Also, the site needs to be deployed every time a new article is written.Apart from that, as I said, It&#x27;s a good solution, and Sculpin is a really good tool. If you are curious, you can see the pre-compiled version of this blog in github, <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/blog">here</a>.

Migrating from Wordpress to Sculpin

One of the common problems we have to confront when starting a new PHP project is how to handle the different dependencies we are going to have.One could think the easier solution is to download all the libraries we are going to need, put them in a <code>lib</code> directory and add them to the version control of the project, but this could be problematic. Let&#x27;s see why.The main problems of using this practice are this.<ul><li>Dependencies of dependencies: Our dependencies may have their own dependencies that we will also need to download.</li><li>Updates: What happens if we need a new feature in the last version of one dependendency? We are going to have to update it manually, and that can be a hard task. Baybe even the new version has new dependencies of its own that we will need to download.</li><li>Autoloading: How do we deal with autoloading the classes in the dependencies? Some of them may have its own autoloading system, but anyway, we are going to need to <code>include</code> all the autoloaders of each dependency.</li></ul>How do we solve all of this? The answer is <a target="_blank" rel="noopener noreferrer" href="http://getcomposer.org">Composer</a>.<h3>Starting with composer</h3>Composer has become the dependency manager in the main PHP projects. It uses its own library repository (<a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">packagist</a>) to handle dependencies, but you can setup private repositories too.It uses a small configuration file, the <code>composer.json</code>, to know which are our dependencies, and it will download their dependencies recursively without us having to do anything special.We can define an autoloading strategy in that file too, and forget about that task for our project and our dependencies.This are some examples of famous PHP project&#x27;s <code>composer.json</code> files:<ul><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zf2/blob/master/composer.json">Zend Framework</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/symfony/symfony/blob/master/composer.json">Symfony</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/doctrine/doctrine2/blob/master/composer.json">Doctrine</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/aws/aws-sdk-php/blob/master/composer.json">AWS PHP SDK</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/Seldaek/monolog/blob/master/composer.json">Monolog</a></li><li><a target="_blank" rel="noopener noreferrer" href="https://github.com/thephpleague/flysystem/blob/master/composer.json">Flysystem</a></li></ul>Now lets see a simpler composer file:<pre><pre><code class="language-json">{
 &quot;name&quot; : &quot;acelaya/zf2-acmailer&quot;,
 &quot;description&quot; : &quot;Mail sending module for Zend Framework 2&quot;,
 &quot;type&quot; : &quot;library&quot;,
 &quot;authors&quot; : [
 {
 &quot;name&quot; : &quot;Alejandro Celaya Alastrué&quot;,
 &quot;email&quot; : &quot;alejandro@alejandrocelaya.com&quot;,
 &quot;homepage&quot; : &quot;http://www.alejandrocelaya.com&quot;,
 &quot;role&quot; : &quot;Developer&quot;
 }
 ],
 &quot;keywords&quot; : [
 &quot;mail&quot;,
 &quot;zend&quot;,
 &quot;php&quot;
 ],
 &quot;homepage&quot; : &quot;https://github.com/acelaya/ZF2-AcMailer&quot;,
 &quot;license&quot; : [
 &quot;BSD&quot;
 ],
 &quot;require&quot; : {
 &quot;php&quot; : &quot;&gt;=5.3.0&quot;,
 &quot;zendframework/zendframework&quot;: &quot;&gt;=2.2.2&quot;
 },
 &quot;require-dev&quot;: {
 &quot;phpunit/phpunit&quot;: &quot;&gt;=3.7&quot;,
 &quot;squizlabs/php_codesniffer&quot;: &quot;1.*&quot;,
 &quot;phploc/phploc&quot;: &quot;*&quot;,
 &quot;pdepend/pdepend&quot; : &quot;1.1.0&quot;,
 &quot;phpmd/phpmd&quot; : &quot;1.4.*&quot;,
 &quot;sebastian/phpcpd&quot;: &quot;*&quot;,
 &quot;theseer/phpdox&quot;: &quot;0.6.5&quot;
 },
 &quot;autoload&quot; : {
 &quot;psr-0&quot; : {
 &quot;AcMailer&quot; : &quot;src/&quot;
 },
 &quot;classmap&quot; : [
 &quot;./Module.php&quot;
 ]
 }
}
</code></pre></pre>This is the composer file of my Zend Framework 2 module <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/ZF2-AcMailer">AcMailer</a>. Let&#x27;s explain it.The properties name, description, type, authors, keywords, homepage and license are just metadata to provide useful information to other users and ease finding the project in <a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">packagist</a>.The require property is the place where we define our dependencies and the version we want to install. We can define here the minimum required PHP version and even the php modules we need (like <code>php-pdo</code>, <code>php-intl</code> and such).The require-dev property allows us to define other dependencies that won&#x27;t be necessery in a production environment, like testing or documentation tools.Finally the autoload property is where we define how our own classes are loaded. It is very easy to define a <code>psr-0</code> or <code>psr-4</code> autoloading strategy, but we can even define a <code>classmap</code> with a list of paths to files.<blockquote>You don&#x27;t have to remember the <code>composer.json</code> schema. You can interactively create it by running <code>php composer.phar init</code>.</blockquote><h3>Installing dependencies</h3>Once this is defined we just need the composer binary file (usually in phar format), that can be found <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/download/">here</a>, and run <code>php composer.phar install</code>.This will create a <code>vendor</code> folder in the root of our project, download our dependencies there, the dependencies of our dependencies, and set-up an autoloader that will be able to load all our dependencies and our own classes as well.After this it&#x27;s enough with a single <code>include</code> statement to <code>vendor/autoload.php</code> to be able to access any class.If later in the project we need to update an existing dependency, add new dependencies or change the autoloading, we just need to update the information in the <code>composer.json</code> file and run <code>php composer.phar update</code> to update dependencies and autoloader.<blockquote>It is recommended to include the composer binary in the PATH to be able to run <code>composer</code> instead of <code>php composer.phar</code>.</blockquote><blockquote>If you are using a VCS like <a target="_blank" rel="noopener noreferrer" href="https://git-scm.com/">git</a> in your project you will probably want to ignore your <code>vendor</code> folder.</blockquote><h3>Advanced usages</h3>This should be enough to start working with composer, but it is a much more powerful tool with more features. It is not a bad idea to take a quick read to its <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/">documentation</a>, but let&#x27;s see the main advanced features.<ul><li>Classmap autoloader: By running <code>composer dumpautoload --optimize</code> we can generate a much faster autoloader which defines a class =&gt; file map array with all the classes handled by composer. This is the more suitable autoloader for production environments.</li><li>Production dependencies: If we include de modifier <code>--no-dev</code> while installing or updating dependencies, it will ignore (or remove) the require-dev dependencies. For example <code>composer update --no-dev</code></li><li>Private repositories: If you want to install dependencies from repositories other than <a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">packagist</a>, you can do it by using the repositories property. It supports many types of repositories, from VCS to PEAR repositories. Complete documentation <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/05-repositories.md">here</a>.</li><li>Global packages: If you want to install dependencies globally, just add the <code>global</code> keyword before the <code>install</code> or <code>update</code>. That will install the dependencies in the <code>~/.composer/vendor</code> directory instead of installing them in the local <code>vendor</code> directory. For example <code>composer global update</code>.</li></ul>And that&#x27;s all you need to know to start working with composer.Update 2015-04-25: I&#x27;ve written an article addressing advanced concepts that is a good continuation to this one. <a href="/2015/04/25/composer-advanced-concepts/">Composer advanced concepts</a>.

Dependency management and autoloading in php projects with composer

Last week I passed the <a target="_blank" rel="noopener noreferrer" href="http://www.zend.com/en/yellow-pages/ZEND021590">Zend Framework 2 Certified Architect</a> exam.I will try to explain how did I prepare it.<h3>Studying</h3>In late March I recived an email that my exam was going to be on May the seventh, so I saw that I was going to have 4-6 weeks to prepare it. I could have started earlier, but maybe I&#x27;m a little lazy.Since this was one of the first times the Zend Framework certification exam was based on version 2 (2.2), there was no documentation or examples in the internet, so I decided to just read the whole <a target="_blank" rel="noopener noreferrer" href="https://framework.zend.com/manual/2.2/en/user-guide/overview.html">documentation</a>. I was working with Zend Framework 2 in my job, so I could apply the theory in real projects.My main problem was that I needed to compatibilize the study with my work, so I started studying about an hour a day. Some days I didn&#x27;t studied, but some weekends I could spend more time on it.About two weeks after I started I saw I wasn&#x27;t going to be able to read all the documentation, so I started to read the components documentation in order of importance. This finally was proved to be a good system. I got no questions in my exam about <code>Zend\Barcode</code>, <code>Zend\Debug</code>, <code>Zend\Navigation</code> and such trivial components, but plenty of questions about <code>EventManager</code>, <code>ServiceManager</code>, <code>ModuleManager</code>, <code>Mvc</code> and <code>Forms</code>.I neither had any questions of ZendService components.<h3>Questions</h3>The <code>ServiceManager</code> was present in many questions, as well as any kind of plugin manager (<code>ControllerManager</code>, <code>ViewHelperManager</code>…)In those questions a piece of code was present where many services were registered in different ways, from a plain PHP array, from a <code>Zend\ServiceManager\Config</code> object or directly by calling methods from a <code>ServiceManager</code> instance.Then the <code>ServiceManager</code> instance was used to retrive services, and you were supposed to know which ones were the same instance, what type of object do they return or even which services return the same instance.The <code>EventManager</code> was also present in many forms. In some questions you were supposed to know the difference between the <code>EventManager</code> and the <code>SharedEventManager</code>, how to attach listeners or how to use <code>ListenerAggregates</code>.The <code>MvcEvent</code> appeared in many questions too, where you need to know about the <code>EventManager</code> and the <code>MVC</code> layer.A good bunch of questions was related with Forms, Validators and Filters.In those questions you may be asked about the <code>FormElementManager</code>, get an element where some filters were attached and know which would be the final output from a specific input, or get a form with many elements with validators and know if an input was going to make the form valid or not.These was the most important parts, but I also had questions about <code>Hydrators</code>, <code>Zend\Db</code>, the <code>ModuleManager</code> and how Modules are loaded, <code>Zend\View</code> with its events layer and the <code>PhpRenderer</code>, <code>Zend\I18n</code>, <code>Zend\Cache</code> or <code>Zend\Config</code>.<h3>Conclusions</h3>I made the exam with two other people I knew. The three of us thought that it wasn&#x27;t a very complicated exam, with no tricky questions (like <code>$foo = &quot;Bar&quot;; echo $fo;</code>), but you have to know the theory very well, how the framework works and how it is supposed to be used.It is important to know about factories, dependency injection and good practices.It would be good to work with Zend Framework 2 as long as you study, because that shows you how it behaves in real environments. Sometimes the Albums tutorial is not enough.I hope this article helps to anyone preparing the exam. I wish you luck.

How to prepare the Zend Framework 2 Certified Architect exam

Dependency management is very important in any kind of project. Any application will need to use third party libraries to avoid to reinvent the wheel.The problem is that getting each one of them from a different place takes time, and it&#x27;s not easy to be sure we get the correct version.To solve this in java projects we can use an automated dependency manager, like <a target="_blank" rel="noopener noreferrer" href="https://maven.apache.org/">Maven</a>, which is really a building system with dependcy management included. The problem with maven is that it could be hard to use, and not very intuitive.Instead of Maven, I rather prefer to use <a target="_blank" rel="noopener noreferrer" href="https://ant.apache.org/ivy/">Ivy</a>. It is a more simple and agile dependency management system, designed to be used with <a target="_blank" rel="noopener noreferrer" href="https://ant.apache.org/">Ant</a>, but it takes dependencies from Maven repositories, like <a target="_blank" rel="noopener noreferrer" href="https://mvnrepository.com/">Maven central</a>.<h3>Getting started</h3>To use Ivy we need to create an <code>ivy.xml</code> file in the project root directory. It will be used to define which dependencies are needed by our project, and will need to be downloaded at building time.This is the <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/subclient-subconnector">Subconnector</a> Ivy script.<pre><pre><code class="language-xml">&lt;ivy-module version=&quot;2.0&quot;&gt;
 &lt;info organisation=&quot;net.subclient&quot; module=&quot;subconnector&quot; /&gt;

 &lt;dependencies&gt;
 &lt;dependency org=&quot;junit&quot; name=&quot;junit&quot; rev=&quot;4.10&quot; /&gt;
 &lt;dependency org=&quot;com.google.code.gson&quot; name=&quot;gson&quot; rev=&quot;2.2.2&quot; /&gt;
 &lt;dependency org=&quot;log4j&quot; name=&quot;log4j&quot; rev=&quot;1.2.17&quot; /&gt;
 &lt;dependency org=&quot;org.apache.commons&quot; name=&quot;commons-lang3&quot; rev=&quot;3.1&quot;/&gt;
 &lt;/dependencies&gt;
&lt;/ivy-module&gt;
</code></pre></pre>As you can see, it is very simple. We just defined an info element with the basic project information, and a dependencies element with nested information of each of the dependencies of the project.For each one of them we have to know its organization, name and revision. With this we can be sure we will get the desired library and revision.But how do we know what to put in <code>org</code>, <code>name</code> and <code>rev</code> attributes? The <a target="_blank" rel="noopener noreferrer" href="https://mvnrepository.com/">maven central repository</a> webpage will help us with this.At the top search bar we can write the name of a library, for example gson. The first result corresponds to the gson artifacts in the maven central. By selecting the desired version we will get the dependency element for an Ivy script, as well as other dependency management systems, like Maven or <a target="_blank" rel="noopener noreferrer" href="https://gradle.org/">Gradle</a>.<img src="/assets/img/dependency.jpg" alt="Maven dependency example"/>We just need to copy and paste it. Nice and easy.<h3>Automate retrieving dependencies</h3>Once our Ivy script is ready, it is time to include retrieving dependencies in our building process. The easiest way to do it is to create an Ant target in our <code>build.xml</code> script, like this.<pre><pre><code class="language-xml">&lt;target name=&quot;retrieve-dependencies&quot;
 description=&quot;Retrieve dependencies with Apache IVY&quot;&gt;

 &lt;ivy:retrieve type=&quot;jar&quot; /&gt;

&lt;/target&gt;
</code></pre></pre>This will look for the ivy.xml script and download dependencies defined on it in a lib folder, but only binary jar files. If <code>type=&quot;jar&quot;</code> is removed, all docs, sources and binaries will be retrieved.Make sure to add Ivy binaries to Ant classpath to make it properly work. The <code>project</code> element in the build script will need also to look like this.<pre><pre><code class="language-xml">&lt;project basedir=&quot;.&quot; default=&quot;build&quot; name=&quot;Subconnector&quot; xmlns:ivy=&quot;antlib:org.apache.ivy.ant&quot;&gt;

 ...

&lt;/project&gt;
</code></pre></pre>Notice the <code>xmlns:ivy</code> attribute.Now we are ready to go.For an advanced Ivy configuration take a look at its <a target="_blank" rel="noopener noreferrer" href="https://ant.apache.org/ivy/history/2.3.0/index.html">official documentation</a>. It explains how to use custom repositories, how to set up a proxy server, how to change default local lib folder, etc.

Dependency management in Java projects with Ant and Ivy

<a target="_blank" rel="noopener noreferrer" href="http://nsis.sourceforge.net/Main_Page">NSIS</a> is a well known system used to create Windows installers for any type of application based on scripts.It is good system. Once we have defined our script we can automatically build it to create application installers in minutes, including creation of Windows register entries, installation folders, application shortcuts, etcThe problem is that only Windows binaries are officially provided to compile this kind of scripts. This can be a problem in a <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Continuous_integration">continuous integration</a> environment, where continuous integration servers use to be Linux based.At this article I am going to explain how to compile NSIS source code in Linux to get it working there and allow it to be invoked from automated tasks run in a continuous integration server.<h3>Download NSIS</h3>The first step is to download the windows distributable zip file and the source code. Both of them can be downloaded from their Sourceforge project: <a target="_blank" rel="noopener noreferrer" href="https://sourceforge.net/projects/nsis/files/?source=navbar">https://sourceforge.net/projects/nsis/files/?source=navbar</a>.At the moment of writing this article the last stable version is NSIS 2.46, so we will need to download nsis-2.46.zip and nsis-2.46-src.tar.bz2. We will put them in a folder were users who are going to need it are allowed to access. I am going to put it at <code>/home/alejandro/nsis</code>Now that we have downloaded both windwos distributable package and source code we are going to decompress them creating two folders, nsis-2.46 and nsis-2.46-src.<h3>System requirements</h3>NSIS official documentation says we need this tools to compile it:<ul><li>Python, version 1.6 or higher. I am using Python 2.7.3</li><li>Scons version 0.96.93 or higher. This application can be downloaded from their official website <a target="_blank" rel="noopener noreferrer" href="http://www.scons.org/download.php">http://www.scons.org/download.php</a></li><li>A C compiler, in our case <code>gcc</code> and <code>g++</code></li></ul>All of this tools can be easily installed from repository, and probably we already have some of them.The scons installer downloaded from their website comes in RPM format which could be a problem for systems not based in Ubuntu. For Debian I used the alien [<code>aptitude install alien</code>] tool, which converts RPM packages into DEB packages by running this command: <code>alien -k filename.rpm</code>Anyway, I uploaded the DEB resultant package for you to <a href="/assets/downloads/scons_2.3.0-1_all.deb_.zip">download</a> it.<h3>Compile NSIS</h3>Once all the requirements are clear we are going to compile the NSIS binary that is responsible for interpreting the scripts, the so called <code>makensis</code>.We have to be at the source code directory, in my case <code>/home/alejandro/nsis/nsis-2.46-src</code>, and we execute this command.<pre><pre><code>scons SKIPSTUBS=all SKIPPLUGINS=all SKIPUTILS=all SKIPMISC=all NSIS_CONFIG_CONST_DATA=no PREFIX=/path/where/distributable/was/extracted install-compiler
</code></pre></pre>Notice that install-compiler is an argument of the command that is placed at the end, and is not part of the distributable path.In my case, using my real path, the resulting command would be this:<pre><pre><code>scons SKIPSTUBS=all SKIPPLUGINS=all SKIPUTILS=all SKIPMISC=all NSIS_CONFIG_CONST_DATA=no PREFIX=/home/alejandro/nsis/nsis-2.46 install-compiler
</code></pre></pre>The execution of this command will compile the code, generating the <code>makensis</code> binary at the bin directory inside the distributable package folder, in my case <code>/home/alejandro/nsis/nsis-2.46/bin</code>.<h3>Test makensis and create an installer</h3>Now that we have makensis created its a good idea to make it available from anywhere, for example adding it to a bin directory, and make sure it can be executed.Using the paths from our example, running this commands will make the job.<pre><pre><code>chmod +x /home/alejandro/nsis/nsis-2.46/bin/makensis
ln -s /home/alejandro/nsis/nsis-2.46/bin/makensis /usr/local/bin/makensis
</code></pre></pre>Now it is time to test the command. Running <code>makensis</code> from anywhere should output something like this.<img src="/assets/img/nsis.png" alt="Nsis help"/>If we have an nsis script, runing the command makensis /path/to/script.nsi will compile the script, creating the installer. The syntax is the same used in windows.Atention! While running this command there could be this error.<pre><pre><code>Error: opening stub &quot;/home/alejandro/nsis/nsis-2.46/share/nsis/Stubs/zlib
Error initalizing CEXEBuild: error setting default stub
</code></pre></pre>This could happen because of a path error, but solving it is very simple, just go to the NSIS distributable folder, <code>/home/alejandro/nsis/nsis-2.46</code> in my case, and create the folder share [<code>mkdir share</code>], go to that folder an create a symbolic link running ln -s <code>/home/alejandro/nsis/nsis-2.46 nsis</code>.That should fix the problem.With this easy steps we have now a NSIS compilation system under a Linux machine ready to build and deploy Windows installers.

Alejandro Celaya | Blog

Software development, agile methodologies and open source projects.

category Archive — "tools"

— 2015 —

— 2014 —