<p>In the last couple of days I have been playing around with the idea of combining GitHub Actions and GitHub Pages to be able to dynamically build preview environments every time a pull request is opened against a repository hosting a client-side web app.</p><p>The idea is that you can quickly preview the changes made by some contributor, without having to clone their branch and running everything locally, something specially useful for open source projects.</p><p>In this article I will explain how to set everything up, and what are some considerations and problems you may face during the process.</p><h3>Enable github pages</h3><p>The first thing you need to do is enable your project to publish pages on some branch. I recommend creating a new branch for this, let&#x27;s say <code>preview-env</code>, and then enabling publishing on it.</p><p>In order to do that go to your repository and then <strong>Settings</strong> -&gt; <strong>Pages</strong>, look for the <strong>Source</strong> section, and you should see something like this:</p><p><img src="/assets/img/preview-envs/github-pages-before-enabling.png" alt="GitHub pages before enabling"/></p><p>Click in the dropdown and select your new branch, <code>preview-env</code>. Then click <strong>Save</strong>.</p><p><img src="/assets/img/preview-envs/github-pages-after-enabling.png" alt="GitHub pages after enabling"/></p><p>After saving you will see a message at the top of this section telling you what&#x27;s the URL in which the pages are published. It always follows the same pattern. If your organization is <code>my-org</code> and your repository is <code>my-repo</code>, the url will be <code>https://my-org.github.io/my-repo/</code>.</p><h3>Configure the workflow</h3><p>Now we need to configure a workflow that will &quot;deploy&quot; the preview environment for the branch every time a new pull request is created or updated:</p><p>Let&#x27;s imagine we have a React web app that is built with node.js. The configuration could look like this.</p><pre><pre><code class="language-yml"># .github/workflows/deploy-preview.yml
name: Deploy preview

on:
  pull_request: null

jobs:
  deploy:
    runs-on: ubuntu-20.04
    continue-on-error: true
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Use node.js 14.15
        uses: actions/setup-node@v1
        with:
          node-version: 14.15
      - name: Generate slug
        id: generate_slug
        run: echo &quot;##[set-output name=slug;]$(echo ${GITHUB_HEAD_REF#refs/heads/} | sed -r &#x27;s/[~\^]+//g&#x27; | sed -r &#x27;s/[^a-zA-Z0-9]+/-/g&#x27; | sed -r &#x27;s/^-+\|-+$//g&#x27; | tr A-Z a-z)&quot;
      - name: Build
        run: npm ci &amp;&amp; npm run build
      - name: Deploy
        uses: JamesIves/github-pages-deploy-action@4.1.1
        with:
          branch: preview-env
          folder: build
          target-folder: ${{ steps.generate_slug.outputs.slug }}
      - name: Publish env
        uses: marocchino/sticky-pull-request-comment@v2
        with:
          header: Preview environment
          message: |
            ## Preview environment
            https://my-org.github.io/my-repo/${{ steps.generate_slug.outputs.slug }}/
</code></pre></pre><blockquote><p>If you are not familiar with GitHub Actions yet, take a look at the <a target="_blank" rel="noopener noreferrer" href="https://docs.github.com/en/actions">official documentation</a>.</p></blockquote><p>This workflow will follow the next steps:</p><ul><li>Checkout the code from the repository.</li><li>Set-up node.js 14.15</li><li>Based on the branch name, generate a slug that we will use to have separated deployment folders for every pull request we receive. The slug is exposed to next steps as an output.</li><li>Build the project. This step will obviously depend on the needs of your project.</li><li>Using <a target="_blank" rel="noopener noreferrer" href="https://github.com/JamesIves/github-pages-deploy-action">JamesIves/github-pages-deploy-action</a>, deploy the contents we previously built in the GitHub page, under a sub-folder matching the slug we generated a few steps above, and under the branch <code>preview-env</code> (remember we enabled GitHub pages for this branch).</li><li>Finally, using <a target="_blank" rel="noopener noreferrer" href="https://github.com/marocchino/sticky-pull-request-comment">marocchino/sticky-pull-request-comment</a>, post a comment in the pull request with a link to the preview environment, so that you can just click on it and see the deployment.</li></ul><p>The steps may change depending on your needs and how you build your project. For example, I have an extra step to update a property in the <code>package.json</code> that is then used to allow serving the app in a sub-path instead of the root of the domain.</p><p>You may also not build your site with node.js, as you could be using any of the multiple existing static site generators out there, but you get the idea.</p><p>Finally, you have probably noticed the config includes <code>continue-on-error: true</code>. This will allow the pull request to be merged even if this process fails for some reason.</p><h3>Considerations when using forks</h3><p>While the configuration above will work perfectly when creating pull requests inside the same repository, there are some limitations when the pull request comes from a fork (which is the usual in OSS projects).</p><p>For security reasons, the <code>GITHUB_TOKEN</code> injected in those cases doesn&#x27;t have write permissions, which will make the &quot;deploy&quot; step fail.</p><p>Also, you cannot define your own token with more permissions and inject it as a secret, as the secrets are not exposed to workflows running on forks.</p><p>However, with a couple small config changes, we can work around these limitations:</p><h4>Change event</h4><p>The first thing we need to do is use the <code>pull_request_target</code> event instead of the <code>pull_request</code> one.</p><pre><pre><code class="language-diff">on:
-  pull_request: null
+  pull_request_target: null
</code></pre></pre><p>According to the documentation, this is equivalent to the <code>pull_request</code> event, but it runs in the scope of the base repository.</p><p>Thanks to this, the <code>GITHUB_TOKEN</code> will come with write permissions, and we will have access to secrets if needed.</p><h4>Checkout the fork</h4><p>The second thing we are going to change is that we now need to specify the repository to checkout.</p><p>In order to do that, we need to add two inputs to the &quot;Checkout code&quot; step, like this:</p><pre><pre><code class="language-diff">    steps:
      - name: Checkout code
        uses: actions/checkout@v2
+       with:
+         repository: ${{ github.event.pull_request.head.repo.full_name }}
+         ref: ${{ github.event.pull_request.head.ref }}
</code></pre></pre><p>This will ensure we checkout from the fork repository, instead of the base one, which is the default, as it&#x27;s the one where the <code>pull_request_target</code> event is scoped to.</p><p>And that&#x27;s it. With these two changes you can now deploy preview environments for pull requests coming from forks.</p><blockquote><p><strong>IMPORTANT!</strong> The limitations of the <code>pull_request</code> event are there for a reason. People could potentially get access to your secrets or manipulate your code. Proceed at your own risk.</p></blockquote><h3>Other considerations</h3><p>Other than the limitations for forks, there are a few other minor things to take into consideration.</p><ul><li>Changes in GitHub Pages do not reflect immediately. It may take up to a couple of minutes for the deployment to be available, but considering you will usually not review a PR right after it has been created, this should not be a big issue.</li><li>As you have seen, every time a pull request is created, the deployment will generate a new folder in your GitHub Pages branch. This may result in a lot of old folders to pile-up, so you may want to set up some way to clean them up periodically or after the pull request has been merged.</li><li>Due to the fact that GitHub Pages only allows static pages to be served, this process cannot be used with apps that require some kind of back-end or server-side logic.</li><li>If your project is already using GitHub Pages for something else (serve the project&#x27;s website or docs), that may conflict with this, preventing you from having this kind of preview envs.</li></ul>

Setting-up a preview environment for your client-side apps with GitHub Actions and GitHub Pages

<p>I remember many years ago, when I released my first open source project, that every time I had a new release ready, I was never sure what should be the new version number.</p><p>Versioning software is not as straightforward as it might look when you don&#x27;t have a lot of experience.</p><p>In this article I&#x27;ll try to explain the <a target="_blank" rel="noopener noreferrer" href="https://semver.org/">SemVer</a> approach to version software, and some things you might want to take into account on top of that.</p><h3>Semantic Versioning</h3><p>The first thing you need is a solid set of rules that help you decide which should your next version be.</p><p>I remember thinking <em>&quot;is this version big enough as to jump from 1.0 to 2.0?&quot;</em> or <em>&quot;I have seen projects using three numbers for the version, X.Y.Z, should I do the same?&quot;</em></p><p>Those questions are easier to answer if you stick to some standard that tells you what to do, and that will help others more easily understand your intention.</p><p>My recommendation is to use <a target="_blank" rel="noopener noreferrer" href="https://semver.org/">Semantic Versioning</a>, as it defines a solid starting point, and it&#x27;s quite adopted by the community.</p><p>Semantic Versioning states that you should use three numbers to identify versions, <code>MAJOR.MINOR.PATCH</code>, and follow these rules in order to decide which one to increase:</p><ul><li><code>PATCH</code>: the new release includes only bug fixes. People are encouraged to update to this release and no changes are needed in their code bases.</li><li><code>MINOR</code>: the new release includes new backwards-compatible features. People can update to this version without changing their code bases, and make use of the new features afterwards if they wish.</li><li><code>MAJOR</code>: the new release includes <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Backward_compatibility">backward compatibility</a> breaks. Changes in the code base will be needed when updating to this version.</li></ul><blockquote><p>These rules are easier to apply to libraries and frameworks than it is for apps and services. More about this later.</p></blockquote><h3>Try to keep backwards-compatibility</h3><p>Ok, we have some rules now. However, I have seen very frequently people mistaking what <em>can</em> be done with what <em>should</em> be done.</p><p>Yes, if you introduce a breaking change, you can update the major version and that&#x27;s it. However, if you do it too frequently, people won&#x27;t be happy, and you will end up with a fragmented user base, that stop updating to newer versions.</p><p>I remember using a library to deploy stuff that had a new major version every couple of months, changing things like &quot;The <code>host</code> function is now called <code>server</code>&quot;. Yes, ok, but why do I have to change my stuff so frequently.</p><p>It&#x27;s usually better to try to implement things in a backwards-compatible way, and keep track of the things you want to change and do it all at a time.</p><p>You can also deprecate things, and document the way you want those things to be done moving forward. That way you give people the chance to start changing their code and simplify a hypothetical upcoming major release.</p><h3>Provide clear upgrade paths</h3><p>As mentioned above, too frequent major version changes are not desirable, but sooner or later you will want to release a new major version for different reasons.</p><ul><li>Getting rid of that feature which is hard to maintain, introduces lots of bugs, and provides little value.</li><li>Supporting something new which is very hard to implement without breaking backwards compatibility.</li><li>Removing all those deprecated methods you have been dragging for months.</li><li>Fix design issues, where something was architected in the wrong way, and only spotted after some time.</li></ul><p>At the time this happens you will want your users to upgrade to the newer version, as you don&#x27;t want people to report bugs that only affect older versions, or to expect you to backport fixes to older versions because they haven&#x27;t updated to the new one.</p><p>The best way to achieve this is to provide clear and simple upgrade paths:</p><ul><li><p>Prepare your releases for the things to come: If you want to introduce new ways of doing things, do it before the major release, and deprecate the older ones. For example, you can have a new method that gets called by an older one, while you mark the old one as deprecated.</p><p>People will be more willing to update and change their code afterwards. By the time the major release is published, their code will be ready to upgrade.</p></li><li><p>Include a CHANGELOG file in your project, explaining the changes introduced in every version. A very good way to document a change log is the <a target="_blank" rel="noopener noreferrer" href="https://keepachangelog.com/">Keep a changelog</a> initiative.</p><p>You can also use some other platform to document the change log, like GitHub releases.</p></li><li><p>Include documentation on how to upgrade to a major release: This is probably the most important one. Document all the steps that need to be followed and all the required changes to update from a release to the next major one.</p><p>A good way to do this is by including an UPGRADE file in your project. You can see <a target="_blank" rel="noopener noreferrer" href="https://github.com/acmailer/acmailer/blob/main/UPGRADE.md">this example</a>.</p></li></ul><h3>Versioning libraries vs apps</h3><p>Semantic Versioning is a good standard to version software, but it plays much better with libraries and frameworks that are installed using some kind of package manager, than it does with apps and services that are not directly depended on.</p><p>For example, how do you identify a backward compatibility break on a web user interface?</p><p>With this kind of software there are more grey areas, and you will end up using your intuition.</p><p>For example, not long ago I released a <a href="/2020/12/24/released-shlink-web-client-v3-0-0/">new major version</a> for a web app I maintain, and it was completely compatible with the previous one. However, it introduced a larger amount of features than usual, and big UI changes, so I decided it was worth the bump.</p><p>Because of this there are projects that use different approaches to version apps. For example:</p><ul><li>Firefox and Chrome have 6-week cycles, and after each one of them they release a new major version no matter what.</li><li>Jetbrains publishes a few releases of their IDEs every year (I think 3) which always start with the year they were released on, like <code>2020.3.0</code>, and they increase the patch number for bugfixes.</li><li>Ubuntu releases 2 versions every year, one in April and one in October, and they are always identified by the year and month they were released on, like <code>19.04</code> or <code>20.10</code>.</li></ul><h3>Special versions</h3><p>There&#x27;s also a set of special versions that can be used to publish the so-called <strong>pre-release</strong> versions. These <a target="_blank" rel="noopener noreferrer" href="https://semver.org/#spec-item-9">are covered</a> by Semantic Versioning, but sometimes they are not so easy to understand.</p><p>It is also very likely that you never have to use these, as only relatively big projects will need this level of granularity, but it&#x27;s still good to know what&#x27;s their purpose and what do they imply.</p><h4>0.x.y</h4><p>It is possible to release a version of your software where the major number is <code>0</code>. When this happens, it means your software is still in its early stages.</p><p>It does not mean it&#x27;s necessarily unstable, but it means you are still introducing frequent changes on it, and therefore, it might be a bit more fragile than a version starting with a number greater than <code>0</code>.</p><h4>Alpha</h4><p>The intention of an alpha release is that a subset of people con test some new functionality, but you don&#x27;t want people to use it in production</p><p>Alpha versions are on their very early stages. Their public API is very likely to change, and they probably contain bugs.</p><p>Semantic Versioning states that alpha versions are identified by this pattern: <code>MAJOR.MINOR.PATCH-alpha.NUMBER</code>, for example <code>2.0.0-alpha.1</code>.</p><h4>Beta</h4><p>Similar to alpha versions, beta versions are also prone to contain bugs, but their API will in theory not change. That means that you could potentially adapt your software to start using a beta version, and when the corresponding stable release is published, you shouldn&#x27;t need that many changes.</p><p>Semantic Versioning defines a pattern similar to the one for alpha versions: <code>MAJOR.MINOR.PATCH-beta.NUMBER</code>, for example <code>2.0.0-beta.1</code>.</p><h4>Release candidate</h4><p>Release candidates (RC) are pre-release versions that you will want to publish for the general user-base to test an upcoming release. You want to publish a RC so that it&#x27;s battle tested by as many people as possible, in order to find possible bugs and edge cases.</p><p>They should not contain many bugs, but some could be found. The public API should not change anymore.</p><p>According to Semantic Versioning, the pattern to identify a RC is <code>MAJOR.MINOR.PATCH-rc.NUMBER</code>, for example <code>2.0.0-rc.1</code>.</p><h3>Conclusion</h3><p>We have seen some approaches and considerations to properly version your software.</p><p>Versioning is not so straightforward when you don&#x27;t have a lot of experience, but as you have seen, you just need to know a small set of rules and use a bit your intuition.</p><p>With those tools, you will be able to properly version your software.</p>

What to take into account when versioning software

<p>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.</p><p>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.</p><h3>New design</h3><p>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.</p><p>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.</p><p>Also, the main area has now a max-width that prevents components from stretching too much on wide screens.</p><div class="row"><div class="col-md-6  "><img alt="Before" src="/assets/img/shlink-web-client-3/design-before.png" class="gallery-item"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/design-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Overview page</h3><p>Up until now, after connecting to a Shlink server, you went directly to the list of short URLs.</p><p>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.</p><p>From there, you can navigate to the full list of short URLs, with filtering capabilities, or go to the advanced short URL creation form.</p><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"/><p class="text-center"><small>Overview</small></p></div></div><h3>Improved short URL creation form</h3><p>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.</p><p>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.</p><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"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/creation-form-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Enhanced visits page</h3><p>The visits page had a problem, it was trying to display too much information in a single place.</p><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><p>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.</p><p>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.</p><div class="row"><div class="col-md-6  "><img alt="Before" src="/assets/img/shlink-web-client-3/visits-before.png" class="gallery-item"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/visits-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Outer sections</h3><p>The app has some sections which are not related to a specific server, like creating/editing servers, or the settings page.</p><p>These sections have also been adapted to the new style, and they also have a max-width for wide screens.</p><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"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/create-server-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Date range selector</h3><p>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.</p><p>This component is used to filter both short URL lists and visits lists.</p><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=""/><p class="text-center"><small>Date range selector</small></p></div></div><h3>Domain selector</h3><p>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.</p><p>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.</p><p>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.</p><div class="row"><div class="col-md-6  "><img alt="Existing domains" src="/assets/img/shlink-web-client-3/domains-existing.png" class=""/><p class="text-center"><small>Existing domains</small></p></div><div class="col-md-6  "><img alt="New domain" src="/assets/img/shlink-web-client-3/domains-new.png" class=""/><p class="text-center"><small>New domain</small></p></div></div><h3>Other improvements</h3><p>The changes described so far were the major ones. However, v3.0.0 includes a few other minor improvements.</p><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><p>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</p><h3>Next steps</h3><p>Of course this doesn&#x27;t end here, and I have a lot of ideas to improve it even further.</p><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

<p>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>.</p><p>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.</p><p>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.</p><p>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.</p><p>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.</p><h3>Initial state</h3><p>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:</p><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><p>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.</p><p>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.</p><blockquote><p>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.</p></blockquote><p>Other than this, the build config defines &quot;global&quot; customizations that are actually only used for some tasks:</p><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><p>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.</p><p>Using this feature it is possible to improve the <code>.travis.yml</code> file, making it look like this:</p><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><p>This approach introduces all these benefits:</p><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><p><img src="/assets/img/travis-multiple-jobs/travis-jobs.png" alt="Travis CI jobs"/></p><h3>Conclusion</h3><p>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.</p><p>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.</p><blockquote><p>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>.</p></blockquote>

Running several steps of a Travis CI build in parallel

<p>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. </p><p>However, many projects are starting to get some adoption, that bring this long-lived approach to the PHP world.</p><p>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.</p><p>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.</p><p>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>.</p><h3>Introducing Swoole</h3><p>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>.</p><p>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.</p><p>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.</p><p>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.</p><p>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.</p><p>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.</p><p>Here you can see a diagram of swoole&#x27;s architecture.</p><p><img src="https://www.swoole.co.uk/images/how-swoole-works.png" alt="How Swoole works"/></p><blockquote><p>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>.</p></blockquote><h3>Problems to solve</h3><p>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;.</p><h4>Database connections are kept open</h4><p>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.</p><p>This, which is in theory good, has a side effect, which is not obvious during development: <strong>the opened connection will eventually expire</strong>.</p><p>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.</p><p>However, when using swoole and the like, you have to implement some mechanism which takes care of reconnecting or gracefully recovering when this happens.</p><blockquote><p>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></p></blockquote><p>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.</p><h4>In-memory caches don&#x27;t behave as expected</h4><p>It is a frequent practice to use local in-memory caches, like APCu, to improve applications performance in production.</p><p>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).</p><p>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.</p><p>This can lead to inconsistencies which are hard to debug, so you need to have it in mind.</p><p>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.</p><blockquote><p>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.</p></blockquote><h4>No need to optimize file including/requiring</h4><p>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.</p><p>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.</p><p>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.</p><h4>Class autoloading happens once</h4><p>This point is very related with the previous one.</p><p>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.</p><p>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.</p><h4>Services should be truly stateless</h4><p>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.</p><p>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.</p><p>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.</p><p>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.</p><p>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.</p><h4>Hot reloading for dev envs is not that good</h4><p>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.</p><p>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.</p><p>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>.</p><p>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.</p><p>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.</p><h3>Conclusion</h3><p>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.</p><p>Just remember to have all of the above in mind ;-)</p><p>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:</p><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><p>Also, here you can find some more articles talking about this topic:</p><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

<p>About a month ago I released the Zend Framework 2 module <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya/ZF2-AcMailer">ZF2-AcMailer</a> version 5.0.0. This new major version includes some important improvements, and a new configuration system that allows multiple mail services to be registered.</p><p>When this module was on its first version, I wrote <a href="/2014/03/02/send-emails-in-a-zend-framework-2-application-using-zf2-acmailer-module/">an article</a> explaining how to use it, but a lot has changed since then, so I thought it was a good idea to write a new one with updated information.</p><p>With this article I&#x27;m going to explain all the new features of the module.</p><h3>Installation</h3><p>One of the main changes is that <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">composer</a> is now the only supported installation method. The ZF2 autoloading files have been removed, and it no longer depends on the Zend\Load component, so it is not possible to use it (or at least, it is very hard) without using composer.</p><p>It is also important to know that the minimum PHP version is now PHP 5.4. I&#x27;ve dropped support for PHP 5.3 because it is no longer maintained, and it&#x27;s safer to stick with the latest versions.</p><p>This said, in a composer-based project, installing this module is as easy as running the command <code>composer require acelaya/zf2-acmailer</code>, and the last version will be installed.</p><p>Also, this module uses <a target="_blank" rel="noopener noreferrer" href="http://semver.org/">Semantic Versioning</a>, so it is safe to use the default version notation, which should be ~5.0.</p><p>Finally, enable the module in your application configuration file.</p><pre><pre><code class="language-php">return [
    &#x27;modules&#x27; =&gt; [
        &#x27;Application&#x27;,
        &#x27;AcMailer&#x27; // &lt;- Add this line
    ],
]
</code></pre></pre><h3>The new configuration structure</h3><p>This module used to allow to configure only one service that was meant to be used to send emails. The problem was that some users were asking to configure other different services, because they needed to use different transports for different purposes and such.</p><p>That was hard to achieve with earlier versions, because you had to update the configuration at runtime.</p><p>This version now allows to configure multiple services, in a similar way as the <a target="_blank" rel="noopener noreferrer" href="https://github.com/doctrine/DoctrineORMModule">DoctrineORMModule</a> creates multiple <code>EntityManagers</code>, by using composed configuration blocks consumed by abstract factories instead of concrete factories.</p><p>This made me change the configuration structure, in order to wrap each specific configuration under the service name, so that the factory was able to know which block to consume.</p><p>Since I was going to change that, I took the opportunity to make other naming changes and refactor everything, wrapping related configuration keys under common blocks, and dropping custom <code>AbstractOptions</code> objects in order to use standard ZF2 options objects.</p><p>The result was an structure like this.</p><pre><pre><code class="language-php">return [
    &#x27;acmailer_options&#x27; =&gt; [

        // Default mail service
        &#x27;default&#x27; =&gt; [
            &#x27;extends&#x27; =&gt; null,

            &#x27;mail_adapter&#x27; =&gt; &#x27;\Zend\Mail\Transport\Sendmail&#x27;,

            &#x27;smtp_options&#x27; =&gt; [
                &#x27;host&#x27; =&gt; &#x27;localhost&#x27;,
                &#x27;port&#x27; =&gt; 25,
                &#x27;connection_class&#x27; =&gt; &#x27;smtp&#x27;,
                &#x27;connection_config&#x27; =&gt; [
                    &#x27;username&#x27; =&gt; &#x27;&#x27;,
                    &#x27;password&#x27; =&gt; &#x27;&#x27;,
                    &#x27;ssl&#x27; =&gt; false,
                ],
            ],

            &#x27;file_options&#x27; =&gt; [
                &#x27;path&#x27; =&gt; &#x27;data/mail/output&#x27;,
                &#x27;callback&#x27; =&gt; null,
            ],

            &#x27;message_options&#x27; =&gt; [
                &#x27;from&#x27; =&gt; &#x27;&#x27;,
                &#x27;from_name&#x27; =&gt; &#x27;&#x27;,
                &#x27;to&#x27; =&gt; [],
                &#x27;cc&#x27; =&gt; [],
                &#x27;bcc&#x27; =&gt; [],
                &#x27;subject&#x27; =&gt; &#x27;&#x27;,
                &#x27;body&#x27; =&gt; [
                    &#x27;content&#x27; =&gt; &#x27;&#x27;,
                    &#x27;charset&#x27; =&gt; &#x27;utf-8&#x27;,
                    &#x27;use_template&#x27; =&gt; false,
                    &#x27;template&#x27; =&gt; [
                        &#x27;path&#x27;          =&gt; &#x27;ac-mailer/mail-templates/layout&#x27;,
                        &#x27;params&#x27;        =&gt; [],
                        &#x27;children&#x27;      =&gt; [
                            &#x27;content&#x27;   =&gt; [
                                &#x27;path&#x27;   =&gt; &#x27;ac-mailer/mail-templates/mail&#x27;,
                                &#x27;params&#x27; =&gt; [],
                            ]
                        ],
                        &#x27;default_layout&#x27; =&gt; [
                            &#x27;path&#x27; =&gt; null,
                            &#x27;params&#x27; =&gt; [],
                            &#x27;template_capture_to&#x27; =&gt; &#x27;content&#x27;
                        ]
                    ],
                ],

                &#x27;attachments&#x27; =&gt; [
                    &#x27;files&#x27; =&gt; [],
                    &#x27;dir&#x27; =&gt; [
                        &#x27;iterate&#x27;   =&gt; false,
                        &#x27;path&#x27;      =&gt; &#x27;data/mail/attachments&#x27;,
                        &#x27;recursive&#x27; =&gt; false,
                    ],
                ],
            ],

            &#x27;mail_listeners&#x27; =&gt; []
        ],

        // Another mail service
        &#x27;christmas&#x27; =&gt; [
            &#x27;extends&#x27; =&gt; &#x27;default&#x27;
        ]
    ]
];
</code></pre></pre><p>The first change that can be seen is that the top level configuration key is no longer <code>mail_options</code>, but <code>acmailer_options</code>. I thought it was safer to use the module name, in order to prevent naming collisions. However, the old configuration key will keep working, but it&#x27;s deprecated and will be removed in the next major version.</p><p>Then, the next level defines each individual mail service. In this case there are two services defined, the <strong>&#x27;default&#x27;</strong> service and the <strong>&#x27;christmas&#x27;</strong> service.</p><p>Each one of the services can contain any of the concrete configuration entries.</p><p>There are 5 main configuration blocks.</p><ul><li><strong>mail_adapter</strong>: The transport object to be used by the mail service. It can be either a <code>Zend\Mail\Transport\TransportInterface</code> instance, a fully qualified class name as string, or a service name as string. You can also use aliases for the standard ZF2 transports.<ul><li><em>sendmail</em>: To use a <code>Zend\Mail\Transport\Sendmail</code>.</li><li><em>smtp</em>: To use a <code>Zend\Mail\Transport\Smtp</code>. </li><li><em>file</em>: To use a <code>Zend\Mail\Transport\File</code>.</li><li><em>null</em> or <em>in_memory</em>: To use a <code>Zend\Mail\Transport\InMemory</code> (or a <code>Zend\Mail\Transport\Null</code> in ZF2.3 and earlier).</li></ul></li><li><strong>smtp_options</strong>: This block is only used when using a <code>Zend\Mail\Transport\Smtp</code> transport, and defines the SMTP connection configuration, as in the <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zend-mail/blob/master/src/Transport/SmtpOptions.php"><code>Zend\Mail\Transport\SmtpOptions</code></a> class.</li><li><strong>file_options</strong>: This block is only used when using a <code>Zend\Mail\Transport\File</code> transport, and defines the configuration, as in the <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/zend-mail/blob/master/src/Transport/FileOptions.php"><code>Zend\Mail\Transport\FileOptions</code></a> class.</li><li><strong>message_options</strong>: This block defines how the message is going to be created, from simple headers like the recipients, the sender and the subject, to the way to create the body. The body can be defined as a raw content using the <strong>&#x27;content&#x27;</strong> configuration, but it can be rendered from a template too using the <strong>&#x27;template&#x27;</strong> configuration, which is disabled by default, but will overwrite the <strong>&#x27;content&#x27;</strong> if enabled using the <strong>&#x27;use_template&#x27;</strong> configuration.<ul><li><em>template</em>: The template config wraps the information to create the body from templates that will be rendered at runtime. It can define a simple template with no children, or a layout with nested children that will be recursively rendered inside of it. Also, a <strong>&#x27;default_layout&#x27;</strong> can be difined that will be used as the parent template for all the emails sent with this service.</li><li><em>attachments</em>: Defines a list of files or a directory containing files that will be attached to the email at runtime.</li></ul></li><li><strong>mail_listeners</strong>: It is a list of mail listeners that will be attached to the mail service at creation time. They can be either <code>AcMailer\Event\MailListenerInterface</code> instances, fully qualified class names as string, or service names as string that return <code>AcMailer\Event\MailListenerInterface</code> instances.</li></ul><p>There is another new configuration block, the <strong>extends</strong>. It defines another configuration block from wich this one should extend its configuration. This way, there is no need to repeat the same configuration over and over if it is going to be the same in more than one mail service.</p><p>For example, in the example, the christmas service will have the same configuration as the default service.</p><p>Any configuration that is redefined will overwrite the extended configuration.</p><h4>Migrate from old configurations</h4><p>In order to ease the migration from older versions, it is possible to automatically generate the new configuration from the old one by using a CLI entry point.</p><p>You just have to have the old <strong>&#x27;mail_options&#x27;</strong> configuration in the global config, so that it can be read from there, and then, this tool will output the result with the new structure, in phpArray, json, ini or xml format. It can be directly dumped into a file if you prefer so.</p><p>Just run this command:</p><pre><pre><code class="language-bash">php public/index.php acmailer parse-config
</code></pre></pre><p>This will output the new configuration in phpArray format. To define another format, use the <code>format</code> value flag. like this.</p><pre><pre><code class="language-bash">php public/index.php acmailer parse-config --format=ini
</code></pre></pre><p>To directly dump the configuration into a config file, use the <code>outputFile</code> value flag.</p><pre><pre><code class="language-bash">php public/index.php acmailer parse-config --outputFile=&quot;config/autoload/new_mail.global.php&quot;
</code></pre></pre><p>Take into account that you will loose any business logic in your config files, since this consumes the generated configuration. For example, if you are reading a password from an environment variable, you will have to manually check the output of this command to fix that, because the password will be now hardcoded in your new config file.</p><p>Also, since this version supports multiple mail services, the old configuration will be wrapped into the <strong>&#x27;default&#x27;</strong> mail service.</p><h3>Fetch mail services</h3><p>As I&#x27;ve mentioned earlier in this article, it is possible to define multiple mail services now. With previous versions, there was just one mail service under the <code>AcMailer\Service\MailService</code> key.</p><p>Now, there is a simple namespaced syntax to fetch any mail service from the <code>ServiceManager</code>. Use the <code>acmailer.mailservice.</code> prefix followed by the concrete mail service name.</p><p>For example, <code>acmailer.mailservice.default</code> or <code>acmailer.mailservice.christmas</code>.</p><p>If you try to use a name that wasn&#x27;t defined in the configuration, the <code>ServiceManager</code> will throw an exception.</p><p>Additionally, the <code>AcMailer\Service\MailService</code> will keep working as an alias of the <code>acmailer.mailservice.default</code> service, to make migration easier.</p><h3>Using mail services</h3><p>Once you have fetched a mail service, any configuration automatically set at creation time can be overwritten by any dynamically generated value. Also, there is a public <code>send()</code> method that will send the final message by using the configured transport.</p><h4>Send the email</h4><p>In order to send the email, just fetch the service and call to the <code>send()</code> method. It will return a <code>AcMailer\Result\MailResult</code> instance.</p><pre><pre><code class="language-php">$mailService = $sm-&gt;get(&#x27;acmailer.mailservice.default&#x27;);
$mailService-&gt;setBody(&#x27;This is the body&#x27;);

$result = $mailService-&gt;send();
if ($result-&gt;isValid()) {
    echo &#x27;Message sent. Congratulations!&#x27;;
} else {
    if ($result-&gt;hasException()) {
        echo sprintf(
            &#x27;An error occurred. Exception: \n %s&#x27;,
            $result-&gt;getException()-&gt;getTraceAsString()
        );
    } else {
        echo sprintf(&#x27;An error occurred. Message: %s&#x27;, $result-&gt;getMessage());
    }
}
</code></pre></pre><h4>Customize the message</h4><p>It is very probable that the recipients of the message (for example) have to be dynamically set from the information of a form.</p><p>Use the <code>getMessage()</code> method to get the wrapped <code>Zend\Mail\Message</code> instance and customize it.</p><pre><pre><code class="language-php">$mailService = $sm-&gt;get(&#x27;acmailer.mailservice.default&#x27;);

$message = $mailService-&gt;getMessage();
$message-&gt;setSubject(&#x27;This is the subject&#x27;)
        -&gt;addTo(&#x27;foobar@example.com&#x27;)
        -&gt;addTo(&#x27;another@example.com&#x27;)
        -&gt;addBcc(&#x27;hidden@domain.com&#x27;);
</code></pre></pre><h4>Customize the body</h4><p>The recommended way to set the body is by using the <code>setBody()</code> or <code>setTemplate()</code> methods of the mail service, depending if you want to set a raw body or a template to be rendered.</p><p>In any case, the charset can be provided.</p><p>Raw bodies:</p><pre><pre><code class="language-php">$mailService-&gt;setBody(&#x27;Hello!!&#x27;);
$mailService-&gt;setBody(&#x27;Hello!!&#x27;, &#x27;utf-8&#x27;);
$mailService-&gt;setBody(&#x27;&lt;h1&gt;Hello!!&lt;/h1&gt;&#x27;, &#x27;utf-8&#x27;);

$part = new \Zend\Mime\Part();
$part-&gt;charset = &#x27;utf-8&#x27;;
$mailService-&gt;setBody($part);

$mailService-&gt;setBody($part, &#x27;utf-8&#x27;);
</code></pre></pre><p>Templates:</p><pre><pre><code class="language-php">$mailService-&gt;setTemplate(new Zend\View\Model\ViewModel(), [&#x27;charset&#x27; =&gt; &#x27;utf-8&#x27;]);
$mailService-&gt;setTemplate(&#x27;application/emails/my-template&#x27;, [
    &#x27;charset&#x27; =&gt; &#x27;utf-8&#x27;,
    &#x27;date&#x27; =&gt; date(&#x27;Y-m-d&#x27;),
    &#x27;foo&#x27; =&gt; &#x27;bar&#x27;,
]);
</code></pre></pre><p>Complex templates:</p><pre><pre><code class="language-php">$layout = new \Zend\View\Model\ViewModel([
    &#x27;name&#x27; =&gt; &#x27;John Doe&#x27;,
    &#x27;date&#x27; =&gt; date(&#x27;Y-m-d&#x27;)
]);
$layout-&gt;setTemplate(&#x27;application/emails/merry-christmas&#x27;);

$footer = new \Zend\View\Model\ViewModel();
$footer-&gt;setTemplate(&#x27;application/emails/footer&#x27;);

$layout-&gt;addChild($footer, &#x27;footer&#x27;);

$mailService-&gt;setTemplate($layout);
</code></pre></pre><p>There is also a <code>setSubject()</code> public method, but it is marked as deprecated in this version and will be removed in the future. Use the <code>$message-&gt;setSubject()</code> method instead.</p><h4>Set attachments</h4><p>It is possible to add attachments or clean the attachments list before sending the message, by using the setter and adder methods.</p><pre><pre><code class="language-php">$mailService-&gt;addAttachment(&#x27;data/mail/attachments/file1.pdf&#x27;);
$mailService-&gt;addAttachment(&#x27;data/mail/attachments/file2.pdf&#x27;, &#x27;different-filename.pdf&#x27;);

// Add two more attachments to the list
$mailService-&gt;addAttachments([
    &#x27;another-name.pdf&#x27; =&gt; &#x27;data/mail/attachments/file3.pdf&#x27;,
    &#x27;data/mail/attachments/file4.zip&#x27;
]);
// At this point there are 4 attachments ready to be sent with the email

// If we call this, all previous attachments will be discarded
$mailService-&gt;setAttachments([
    &#x27;data/mail/attachments/another-file1.pdf&#x27;,
    &#x27;name-to-be-displayed.png&#x27; =&gt; &#x27;data/mail/attachments/another-file2.png&#x27;
]);

// A good way to remove all attachments is to call this
$mailService-&gt;setAttachments([]);
</code></pre></pre><h3>Events layer</h3><p>This module comes with its own events layer.</p><p>The mail services wrap a list of event managers that listen to three different events in the send process. When you call the method <code>send()</code>, just after trying to use the transport to send the message, the event <code>MailEvent::EVENT_MAIL_PRE_SEND</code> is triggered.</p><p>If everything works fine and the message is dispatched, the event <code>MailEvent::EVENT_MAIL_POST_SEND</code> is triggered. In this case, the result will be valid.</p><p>Finally, if an error occurs and an exception is thrown, the event <code>MailEvent::EVENT_MAIL_SEND_ERROR</code> is triggered. In this case the result won&#x27;t be valid, and it will wrap the produced exception.</p><p>The mail listeners are attached and detached with two simple methods.</p><pre><pre><code class="language-php">$mailListener = new \Application\Event\MyMailListener();
$mailService-&gt;attachMailListener($mailListener);

if ($foo) {
    // If foo, I want to detach the listener
    $mailService-&gt;detachMailListener($mailListener);
}

$mailService-&gt;send();
</code></pre></pre><p>This module doesn&#x27;t come with any built-in mail listener, you will have to create your own listeners by extending <code>AcMailer\Event\AbstractMailListener</code> and implementing the <code>onPreSend</code>, <code>onPostSend</code> and <code>onSendError</code> methods, which receive a <code>AcMailer\Event\MailEvent</code> object as an argument, which in turn wraps the mail service itself, so that you can customize anything at any of those points.</p><h3>Others</h3><p>Other minor changes are that the license has been changed from BSD to MIT, and that the build is running under PHP7, as well as 5.4, 5.5, 5.6 and hhvm. It is currently passing, so the module should theoretically work in all of those environments.</p><p>This is not the best module in the world, but it will help you send emails from Zend Framework 2 based applications.</p>

Emails in Zend Framework 2 with ZF2-AcMailer version 5

<p><a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">Composer</a> is <strong>The Tool</strong> in any modern PHP project. Nowadays I can&#x27;t imagine to work without it.</p><p>It is much more powerful than some people think, easily solving the integration of third party components in our projects, but there are some advanced features that are less known.</p><p>I&#x27;m going to try to explain some of the best practices and mechanisms bundled with composer.</p><blockquote><p>If you are not familiar with composer, some time ago I wrote an introduction article that you should read before continuing with this one. <a href="/2014/07/19/dependency-management-and-autoloading-in-php-projects-with-composer/">Dependency management and autoloading in php projects with composer</a>.</p></blockquote><h3>Globally installing composer</h3><p>It is a good practice to have composer installed globally, instead of having a binary file per project.</p><p>After downloading the <code>composer.phar</code> file from the <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/download/">composer</a> website, you can start using it by running <code>php composer.phar [...]</code>. Instead, we are going to place it in a global location so that we can run the command <code>composer [...]</code> from this moment on.</p><p>In UNIX systems, just make the file executable and move it to a folder that&#x27;s already in the path.</p><pre><pre><code class="language-bash">sudo chmod +x composer.phar
sudo mv composer.phar /usr/local/bin/composer
</code></pre></pre><p>Under Windows systems, there is an installer that will make the work for you. Download it <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/00-intro.md#installation-windows">here</a>.</p><p>Now, go to any location and run <code>composer</code>. You should see composer&#x27;s help.</p><h3>Create the composer.json file</h3><p>The first thing you should do when starting a new PHP project is to create the composer.json file. It is the main configuration file, where metadata, dependencies and autoloading are defined.</p><p>You probably don&#x27;t remember the main parts of this file, and end up copying the file from othe projects. There is no need to do that, just run <code>composer init</code> and the Composer config generator will be executed, guiding you over the process of creating the file.</p><h3>Add dependencies to an existing composer.json file</h3><p>In the documentation of many libraries, they tell you to manually edit your composer.json file to add new dependencies. That can be problematic, because you could have a syntax error, forget to add a trailing comma, etc.</p><p>The best practice to add dependencies to your composer.json file is to run the command <code>composer require vendor-name/library-name ~3.0</code>. That will add the new dependency to your file (avoiding syntax errors) and then install it.</p><p>If you don&#x27;t include the version name, composer will try to find out what&#x27;s the best version to use, by following <a target="_blank" rel="noopener noreferrer" href="http://semver.org/">Semantic Versioning</a>. If it is not able to know which version to use, it will ask you to decide.</p><h3>Production environments</h3><p>The management of dependencies and new classes is not the same in our development environment and the production environment. In development we need new classes to be automatically autoloaded, and we want to have certain dependencies, like phpunit or php code sniffer that are not of any use in production.</p><p>In development we will usually install or update dependencies by running <code>composer install</code> or <code>composer update</code>. That will include all dependencies in <strong>require</strong> and <strong>require-dev</strong> blocks, and generate an autoloader by following different strategies. Some of those autoloading strategies imply the iteration of directories in order to find class files.</p><p>That is ok for development, but in production we need something more efficient than that, and also, we don&#x27;t want <strong>require-dev</strong> dependencies to be installed.</p><p>To get this done, in a deployment process, we should run this command instead.</p><pre><pre><code class="language-bash">composer install --no-dev --optimize-autoloader --prefer-dist --no-interaction
</code></pre></pre><p>This is what each flag makes:</p><ul><li><strong><code>--no-dev</code></strong>: prevents dependencies defined in the <strong>requre-dev</strong> block to be installed.</li><li><strong><code>--optimize-autoloader</code></strong>: generates a classmap autoloader, that will map each class with the file that contains it, preventing unnecessary directory iterations.</li><li><strong><code>--prefer-dist</code></strong>: installs distributable versions of the libraries, instead of source code, when possible.</li><li><strong><code>--no-interaction</code></strong>: will always try to make the proper decission in case any &quot;conflict&quot; is produced, so that the process is completly unatended.</li></ul><p>This is the command you should use when deploying a project, just after clonning a clean repository.</p><h3>Private repositories</h3><p>This is probably one of the most powerful features while working on many private projects that depend on each other.</p><p>By default, composer fetches dependencies from a single repository, <a target="_blank" rel="noopener noreferrer" href="https://packagist.org/">Packagist</a>, which needs to have access to a public repository (usually github). But what happens if my code is private, and I don&#x27;t want to (or can&#x27;t) open source it? May I use composer to install private dependencies? The answer is yes.</p><p>The composer.json file can include a <strong>repositories</strong> block, where we define other repositories (either public or private) where composer will try to find dependencies.</p><p>There are several repository types supported by composer, from a VCS repository to a plain local directory containing zip files.</p><pre><pre><code class="language-javascript">{
    &quot;repositories&quot;: [
        {
            &quot;type&quot;: &quot;vcs&quot;,
            &quot;url&quot;: &quot;https://my-repos.com/something-private&quot;
        },
        {
            &quot;type&quot;: &quot;pear&quot;,
            &quot;url&quot;: &quot;http://pear2.php.net&quot;
        },
        {
            &quot;type&quot;: &quot;artifact&quot;,
            &quot;url&quot;: &quot;path/to/directory/with/zips/&quot;
        }
    ]
}
</code></pre></pre><p>Composer will look for dependencies on each defined repository in order, and Packagist as a last resource.</p><p>Defining repositories is very flexible and a little bit complex in some cases, so I recommend you to read the <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/05-repositories.md">documentation</a>.</p><h3>CLI scripts</h3><p>Sometimes a library includes some command line interface scripts that the user can use to automate configuring some stuff.</p><p>If you want to include your own CLI scripts and allow any user to find them when installing your library as a dependency, you will want to define them in the <strong>bin</strong> block.</p><pre><pre><code class="language-javascript">{
    &quot;bin&quot;: [
        &quot;scripts/generate-foo&quot;,
        &quot;scripts/create-bar&quot;,
        &quot;scripts/do-something&quot;
    ]
}
</code></pre></pre><p>It is just a list of script paths that composer will &quot;copy&quot; to the <code>vendor/bin</code> directory after installation (it doesn&#x27;t really copy them, it creates symlinks in UNIX systems and generates bat files under Windows).</p><p>This makes all the CLI scripts of all dependencies to be &quot;placed&quot; in the same location, so it is easier to find them.</p><p>This makes sense only in non-root projects (those that will be installed as dependencies of other projects and are not base applications).</p><h3>Events</h3><p>Composer will trigger some events during the process of installing dependencies, generating autoloaders and such. You can define some scripts or code snippets that will be automatically executed when those events are triggered.</p><p>These event listeners are defined in the <strong>scripts</strong> block. They can be either CLI commands or static class methods.</p><pre><pre><code class="language-javascript">{
    &quot;scripts&quot;: {
        &quot;post-package-install&quot;: &quot;Acelaya\\MyClass::postPkgInstall&quot;,
        &quot;post-install-cmd&quot;: [
            &quot;Acelaya\\MyClass::postInstall&quot;,
            &quot;phpunit -c app/&quot;
        ]
    }
}
</code></pre></pre><p>The complete list of events can be found in composer&#x27;s <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/doc/articles/scripts.md#event-names">documentation</a>. Take a look at them and see if you can optimize your workflow.</p><h3>Applications installation</h3><p>At this point we all know that we can use composer to install libraries at project level, but what happens with applications, known as <strong>root projects</strong> in composer&#x27;s terms.</p><p>We can also use composer to distribute complete applications, allowing them to be easily installed by using this command.</p><pre><pre><code class="language-bash">composer create-project vendor-name/app-name
</code></pre></pre><p>This will download the application (as if we would have cloned the repository) and then install its dependencies. We could even take advantage of composer&#x27;s events, and initialize a database or create some non-tracked directories.</p><h3>Conclusion</h3><p>And that&#x27;s pretty much all.</p><p>Use composer, it will improve your PHP projects.</p>

Composer advanced concepts

<p>Some time ago I published an <a href="/2014/04/18/configure-multiple-database-connections-in-doctrine-with-zend-framework-2-2/">article</a> talking about different Doctrine configurations when using the <code>DoctrineORMModule</code> in Zend Framework 2 applications, so that you can create multiple database connections, either by using one entity manager or more than one.</p><p>Since then, many people have asked me how to configure the entity manager when the database connection configuration has to be generated dynamically, for example because you have more than one database and you need to choose one of them based on some external element.</p><p>I&#x27;m going to explain one possible approach to this problem.</p><h3>Introduction</h3><p>Let&#x27;s assume we have one default database with a couple tables, one <em>users</em> table which we will use to perform authentication, and another <em>groups</em> table that contains the name of the database for each one of those groups.</p><p>To access this database we are going to use the default <code>EntityManager</code>, with a configuration like this.</p><pre><pre><code class="language-php">return [
    
    &#x27;doctrine&#x27; =&gt; [
        &#x27;connection&#x27; =&gt; [
            &#x27;orm_default&#x27; =&gt; [
                &#x27;driverClass&#x27; =&gt;&#x27;Doctrine\DBAL\Driver\PDOMySql\Driver&#x27;,
                &#x27;params&#x27; =&gt; [
                    &#x27;host&#x27;     =&gt; &#x27;localhost&#x27;,
                    &#x27;port&#x27;     =&gt; &#x27;3306&#x27;,
                    &#x27;user&#x27;     =&gt; &#x27;root&#x27;,
                    &#x27;password&#x27; =&gt; &#x27;foobar&#x27;,
                    &#x27;dbname&#x27;   =&gt; &#x27;main_database&#x27;,
                    &#x27;driverOptions&#x27; =&gt; [
                        PDO::MYSQL_ATTR_INIT_COMMAND =&gt; &#x27;SET NAMES utf8&#x27;,
                    ],
                ],
            ],
        ],
        
        &#x27;driver&#x27; =&gt; [
            &#x27;my_module_entities&#x27; =&gt; [
                &#x27;class&#x27; =&gt;&#x27;Doctrine\ORM\Mapping\Driver\AnnotationDriver&#x27;,
                &#x27;cache&#x27; =&gt; &#x27;array&#x27;,
                &#x27;paths&#x27; =&gt; [
                    __DIR__ . &#x27;/../../module/MyModule/src/Entity&#x27;,
                ]
            ],

            &#x27;orm_default&#x27; =&gt; [
                &#x27;drivers&#x27; =&gt; [
                    &#x27;MyModule\Entity&#x27; =&gt; &#x27;my_module_entities&#x27;,
                ]
            ],

        ],
        
        &#x27;authentication&#x27; =&gt; [
            // [...]
        ],
    ],

];
</code></pre></pre><p>With this configuration it is easy to get an <code>EntityManager</code> instance, just by fetching it from the <code>ServiceManager</code> with the key <code>doctrine.entitymanager.orm_default</code>.</p><p>But how do we configure an entity manager connection when we don&#x27;t know which is going to be the dbname?</p><h3>Dynamically update configuration</h3><p>The first thig we are going to do es to define another connection configuration but leaving the dbname empty.</p><pre><pre><code class="language-php">return [
    
    &#x27;doctrine&#x27; =&gt; [
        &#x27;connection&#x27; =&gt; [
            &#x27;orm_default&#x27; =&gt; [
                // [...]
            ],
            &#x27;dynamic_orm&#x27; =&gt; [
                &#x27;driverClass&#x27; =&gt;&#x27;Doctrine\DBAL\Driver\PDOMySql\Driver&#x27;,
                &#x27;params&#x27; =&gt; [
                    &#x27;host&#x27;     =&gt; &#x27;localhost&#x27;,
                    &#x27;port&#x27;     =&gt; &#x27;3306&#x27;,
                    &#x27;user&#x27;     =&gt; &#x27;root&#x27;,
                    &#x27;password&#x27; =&gt; &#x27;foobar&#x27;,
                    &#x27;dbname&#x27;   =&gt; &#x27;&#x27;,
                    &#x27;driverOptions&#x27; =&gt; [
                        PDO::MYSQL_ATTR_INIT_COMMAND =&gt; &#x27;SET NAMES utf8&#x27;,
                    ],
                ],
            ],
        ],
        
        &#x27;driver&#x27; =&gt; [
            &#x27;my_module_entities&#x27; =&gt; [
                &#x27;class&#x27; =&gt;&#x27;Doctrine\ORM\Mapping\Driver\AnnotationDriver&#x27;,
                &#x27;cache&#x27; =&gt; &#x27;array&#x27;,
                &#x27;paths&#x27; =&gt; [
                    __DIR__ . &#x27;/../../module/MyModule/src/Entity&#x27;,
                ]
            ],

            &#x27;orm_default&#x27; =&gt; [
                &#x27;drivers&#x27; =&gt; [
                    &#x27;MyModule\Entity&#x27; =&gt; &#x27;my_module_entities&#x27;,
                ]
            ],
            
            // I&#x27;m using the same entities for this connection, but you could change this
            &#x27;dynamic_orm&#x27; =&gt; [
                &#x27;drivers&#x27; =&gt; [
                    &#x27;MyModule\Entity&#x27; =&gt; &#x27;my_module_entities&#x27;,
                ]
            ],

        ],
        
        &#x27;authentication&#x27; =&gt; [
            // [...]
        ],
        
        &#x27;entitymanager&#x27; =&gt; [
            &#x27;dynamic_orm&#x27; =&gt; [
                &#x27;connection&#x27; =&gt; &#x27;dynamic_orm&#x27;,
           ],
        ],

    ],

];
</code></pre></pre><p>Now I&#x27;m going to define a custom factory that will get current user&#x27;s database name and update the configuration on the fly before creating the <code>EntityManager</code>.</p><pre><pre><code class="language-php">namespace Acelaya\Blog\Service\Factory;

use Zend\ServiceManager\FactoryInterface;
use Zend\ServiceManager\ServiceLocatorInterface;

class DynamicEMFactory implements FactoryInterface
{
    public funciton createService(ServiceLocatorInterface $serviceLocator)
    {
        // Get current user
        $authService = $serviceLocator-&gt;get(&#x27;Zend\Authentication\AuthenticationService&#x27;);
        if (! $authService-&gt;hasIdentity()) {
            throw new \RuntimeException(
                &#x27;It is not possible to create a dynamic entity manager before a user has logged in&#x27;
            );
        }
        
        $user = $authService-&gt;getIdentity();
        $dbName = $user-&gt;getGroup()-&gt;getDbName();
        
        // Update connection config
        $globalConfig = $serviceLocator-&gt;get(&#x27;config&#x27;);
        $globalConfig[&#x27;doctrine&#x27;][&#x27;connection&#x27;][&#x27;dynamic_orm&#x27;][&#x27;params&#x27;][&#x27;dbname&#x27;] = $dbName;
        
        $isAllowOverride = $serviceLocator-&gt;getAllowOverride();
        $serviceLocator-&gt;setAllowOverride(true)
        $serviceLocator-&gt;setService(&#x27;config&#x27;, $globalConfig);
        $serviceLocator-&gt;setAllowOverride($isAllowOverride);
        
        // Now that the service manager configuration is up to date, we can safely fetch the service
        return $serviceLocator-&gt;get(&#x27;doctrine.entitimanager.dynamic_orm&#x27;);
    }
}
</code></pre></pre><p>Let&#x27;s see what this factory does.</p><p>The first thing we do is to make sure that a user is logged in the system. In case it is not, we throw an exception. Usually, our ACL system will prevent any endpoint that depends on this dynamic <code>EntityManager</code> to be hit before that happens, but any unexpected error will be easier to debug this way.</p><p>Then we get the global configuration service, update the database name for the dynamic_orm and overwrite the updated configuration service.</p><p>We have to make sure that we are able to override services in the <code>ServiceManager</code> before doing it, because its default behavior is to throw an exception if we try to do that. Then we reset the &#x27;allow override&#x27; state to its previous one, to prevent unexpected bugs.</p><p>Finally we use the DoctrineModule&#x27;s standard factories to create our <code>EntityManager</code> and return it. It should properly work, since the configuration is now complete.</p><p>The last thing to do would be to define a custom name for this service.</p><pre><pre><code class="language-php">return [
    &#x27;service_manager&#x27; =&gt; [
        &#x27;factories&#x27; =&gt; [
            &#x27;DynamicEntityManager&#x27; =&gt; &#x27;Acelaya\Blog\Service\Factory\DynamicEMFactory&#x27;
        ]
    ]
];
</code></pre></pre><p>And that should be it. Once you fetch this service from the <code>ServiceManager</code> (<code>$sm-&gt;get(&#x27;DynamicEntityManager&#x27;)</code>), it will dynamically update the configuration and create the entity manager.</p><h3>Conclusion</h3><p>It is not hard to get this working, but we have had to bypass some of the default behaviors of Doctrine and Zend Framework 2, so you will need to be careful not to break anything.</p><p>For example, an error could happen if you access the <code>doctrine.entitimanager.dynamic_orm</code> service directly instead of using our factory.</p><p>It could also fail if in your case you don&#x27;t rely on a logged in user, but on something harder to control.</p><p>Also, I have assumed that the only thing that is dynamic is the database name. In case credentials or hosts could dynamically change too, you will need to have a helper table with conneciton configurations, or at least a configuration file where you can locate different connection configuraitons.</p>

Dynamically create doctrine entity managers in Zend Framework 2

<p>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.</p><p>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.</p><p>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.</p><p>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, <em>users</em> and <em>items</em>. Very simple.</p><h3>Getting the application</h3><p>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>.</p><blockquote><p>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>.</p></blockquote><p>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.</p><h3>Dependency injection</h3><p>Let&#x27;s start with some thoughts about dependency injection.</p><p>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.</p><p>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.</p><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><p>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.</p><p>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;<em>Dependency injection is hard! I will need to duplicate a lot of code!</em>&quot;.</p><p>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.</p><p>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...</p><p>The <code>ServiceManager</code> is going to act as the &quot;inversion of control&quot; container of this project. Let&#x27;s see how.</p><h3>Solving the problem</h3><p>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.</p><h4>Bootstrapping</h4><p>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>.</p><pre><pre><code class="language-php">$sm = new ServiceManager(new Config(include __DIR__ . &#x27;/../config/services.php&#x27;));

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

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

// ...
</code></pre></pre><p>Thanks to the <code>ServiceManager</code>, we have obtained the <strong>app</strong> 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.</p><p>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 <strong>invokable</strong>, which means that it will be constructed by the <code>ServiceManager</code> just by instantiating the object with no arguments in the constructor.</p><p>But we said that the object has been customized. Where did that happen?</p><p>If we go to the <strong>delegators</strong> 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.</p><p>Our SlimDelegator sets some configuration options in the Slim instance after it is created and before it is returned by the <code>ServiceManager</code>.</p><blockquote><p>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.</p></blockquote><p>The final step of the bootstrap process is to use the <strong>app</strong> object to register a couple routes.</p><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><p>The first route is the home page, which is only used to select between <em>users</em> and <em>items</em>.</p><p>The rest of the routes are endpoints to perform each operation of both <em>users</em> and <em>items</em> CRUDs. They are resolved to a controller&#x27;s action.</p><h4>Controllers</h4><p>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.</p><p>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 <strong>slimcontroller</strong> makes controllers to be loaded from the <code>ServiceManager</code>.</p><p>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.</p><p>Those two controllers are defined in <code>config/services.php</code> as factories. A <strong>factory</strong> is the easiest way to perform dependency injection in a service.</p><p>For example, the UserControllerFactory looks like this.</p><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><p>It creates the UserController instance and returns it, but it also injects its only dependency on it.</p><p>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.</p><p>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>.</p><p>The ItemController is created in a very similar way. You can take a look at the class <code>src/Controller/ItemControllerFactory.php</code>.</p><p>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.</p><p>For this purpose we have defined three <strong>initializers</strong> 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.</p><p>This is one of the initializers, but the rest are very similar.</p><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><p>We are fetching the <strong>app</strong> here. Since it is already created at this point, the <code>ServiceManager</code> will return the same instance.</p><p>Now we know that any route starting with <strong>/users</strong> will end with a fully configured UserController fetched from the <code>ServiceManager</code>, and any route starting with <strong>/items</strong> will do the same with an ItemController.</p><h4>Other services</h4><p>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.</p><p>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?</p><p>In the <strong>abstract_factories</strong> block, we have defined a ServiceAbstractFactory. Abstract factories are used as last resort to create services that are not explicitly defined.</p><p>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.</p><p>This abstract factory is in <code>src/Service/ServiceAbstractFactory.php</code>, if you want to take a look at its implementation.</p><h4>Everything is running</h4><p>And thats all the theory. The application works now in theory. Check it.</p><p>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.</p><p>We have performed dependency injection and the code wasn&#x27;t harder to handle.</p><h3>Unit tests</h3><p>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.</p><p>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.</p><p>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.</p><p>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.</p><p>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.</p><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><p>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.</p><h3>Conclusion</h3><p>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.</p><p>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).</p><p>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.</p><p>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.</p>

Managing objects creation and dependency injection with Zend\ServiceManager

<p>Any medium and large project has to deal at some point with the problem of translating the application itself to other languages. There are many tools and standards to do this, but one of my favourite components is <a target="_blank" rel="noopener noreferrer" href="https://zf2.readthedocs.org/en/latest/modules/zend.i18n.translating.html">Zend\I18n</a>.</p><p>Everybody who knows me is aware that I love Zend Framework, but unfortunately it&#x27;s been a while since the last time I worked on a project based on it.</p><p>But nowadays that is not a problem. <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">Composer</a> allows you to install any component or library on any project, so I&#x27;m indeed constantly using many ZF2 components.</p><p>I&#x27;m going to explain how to use one of those components, Zend\I18n, to manage application translations, which is a component that internally uses the <code>intl</code> PHP extension, so make sure to have it installed.</p><h3>Installation</h3><p>As usual, this component is easily installable with composer by running this command.</p><pre><pre><code>composer require zendframework/zend-i18n:~2.2
</code></pre></pre><p>If you want, I&#x27;ve created an example project that I&#x27;m going to use on this article. You can find it <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya-blog/internationalization">here</a>, just clone it and run <code>composer update</code>.</p><p>Then go to the public directory, run <code>php -S 0.0.0.0:8000</code> and navigate to <a target="_blank" rel="noopener noreferrer" href="http://localhost:8000">localhost:8000</a></p><blockquote><p>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>.</p></blockquote><h3>Translation files</h3><p>The first we need to decide is the way we are going to store translations. There are many supported formats, from plain PHP arrays where we set a translation key and the text in a language, to <a target="_blank" rel="noopener noreferrer" href="https://www.gnu.org/software/gettext/">gettext</a> files that can be automatically updated with new strings to be translated, but we could also use xml or ini files.</p><p>The preferred method when using Zend\I18n is gettext (and it would be also my choice). It is easy to configure, uses super fast binary files in production and we don&#x27;t need to define translations immediately, we can leave it for then, so that it doesn&#x27;t break the development flow.</p><p>Gettext files are usually handled with an external tool, <a target="_blank" rel="noopener noreferrer" href="https://poedit.net/">poedit</a>, an open source cross-platform application that can inspect our project and find new translations, deleted translations and updated translations, syncing our translation files (usually those with <code>po</code> extension) so that we don&#x27;t need to remember where we added or updated internationalizable texts.</p><p>To do this we just need to tell the program the name of the functions we use to translate strings (usually <code>translate</code>, <code>gettext</code>, <code>_</code> and such) and the files it needs to scan for new translations.</p><p>It also compiles and generates the binary <code>.mo</code> files, which are the ones used by the application.</p><h3>The translator</h3><p>Once we have decided the format of the files that are going to store translations, we have to create the main <code>Zend\I18n\Translator\Translator</code> object that is going to be used to find translations by consuming certain configuration.</p><p>In the example, the <code>src/translator.php</code> file generates and returns a <code>Translator</code> instance. You will need to register your object in some kind of service container so that you can inject it anywhere. This example is so simple, that I just included the file in the index.php.</p><p>The <code>Translator</code> has a factory method that is able to consume a configuration to generate the instance. It looks like this.</p><pre><pre><code class="language-php">use Zend\I18n\Translator\Translator;

return Translator::factory([
    &#x27;locale&#x27; =&gt; &#x27;en&#x27;,
    &#x27;translation_file_patterns&#x27; =&gt; [
        [
            &#x27;base_dir&#x27; =&gt; __DIR__ . &#x27;/../languages&#x27;,
            &#x27;type&#x27;     =&gt; &#x27;gettext&#x27;,
            &#x27;pattern&#x27;  =&gt; &#x27;%s.mo&#x27;,
        ],
        [
            &#x27;base_dir&#x27; =&gt; __DIR__ . &#x27;/../more_languages&#x27;,
            &#x27;type&#x27;     =&gt; &#x27;phpArray&#x27;,
            &#x27;pattern&#x27;  =&gt; &#x27;%s.lang.php&#x27;,
        ],
    ],
]);
</code></pre></pre><p>In the configuration we have to define the default locale. It can be only one or an array with many of them, so that the translator can load another language if it is not able to find the first one. The locale can be changed later, but it is a good idea to have a language by default.</p><p>Then we have to define a list of places to find translation files. Each specification must include the directory which stores the files, the format of the translations in that directory (we can mix gettext with arrays and ini files if we want) and finally the pattern used to find certain translation file. The first mask will be replaced with the locale that is being used at each moment. This way, if we try to translate a message to the locale en, in the first directory, it will look for a file with the name <code>en.mo</code></p><p>I have not included it in the example, but we could also set a cache storage to be used with each translations directory under the &#x27;cache&#x27; key, but then we will need to install <code>zendframework/zend-cache</code> too.</p><h3>Translating texts</h3><p>Our translator is now ready to be used. In the example, the <code>public/index.php</code> file makes use of the translator to translate a couple strings.</p><p>The translator works this way, when you call the methods <code>translate</code> or <code>translatePlural</code> with a string, it tries to find the translation in current locale. If it does, it will return it, otherwise it will return the original string.</p><p>This way we can use the default language (usually english) for keys and avoid to generate translation files for that language.</p><p>I have configured my <code>po</code> files so that poedit looks for the usage of the <code>translate</code> method inside the public directory, and assume the first argument is the string to be translated.</p><p>At the top of the file you will see that I get a <code>lang</code> query param to use it as the current locale. If it is not defined or you define one that is invalid, the default locale <code>en</code> will be used.</p><p>Now you can test it. It has three valid locales, en, es and fr. Use them to see the texts in English, Spanish and French. You can try to use an invalid locale too and you will see the texts in english.</p><p>The last string is not included in any translation file, so you will see it always in english.</p><h3>Conclusion</h3><p>This is it. The translator is a simple component to use on any PHP project. It has more power in Zend Framework based applications, since it can be created by using the ServiceManager, and includes view helpers and integration with forms, but even so it can be used in isolation.</p><p>I would like to discuss about advanced concpets of the translator, like text domains, plural forms and even some kind of front-end integration to use the same translation files under javascript environments, but that will be done in another article.</p>

Alejandro Celaya | Blog

Software development, agile methodologies and open source projects.

Emails in Zend Framework 2 with ZF2-AcMailer version 5

Composer advanced concepts

Dynamically create doctrine entity managers in Zend Framework 2

Managing objects creation and dependency injection with Zend\ServiceManager

Translations and internationalization in PHP projects with Zend\I18n