Inhalt abgleichen
Drupal.org - aggregated feeds in category Planet Drupal
Aktualisiert: vor 11 Minuten 17 Sekunden

Jacob Rockowitz: Project Management + Estimation + Mentorship = Sustainability

11. Juni 2018 - 19:55

These are some of the ingredients that can make open source sustainable

The title of this blog post, "Project Management + Estimation + Mentorship = Sustainability" does not represent an exact formula for solving the challenges of open source sustainability. It establishes what I feel are the ingredients to a recipe that could significantly improve the sustainability of open source projects. To discover the right recipe for sustainability, it is key to define sustainability.

Defining open source sustainability

The above description could sound like a standard cooperative or partnership agreement except that the General Public License (GPL), attached to most open source projects, makes the product of this arrangement entirely free for anyone to use and alter. This is the challenge of open source sustainability: the result of our labor, aka the product, is absolutely free. There is no doubt that people and organizations have found incredible value in open source software. But what is the value of the labor?

Personally, I am passionate about maintaining my project the Webform module for Drupal 8, because it is my baby. The reality is that our kids grow up and we need to make sure they are independent and healthy. We put in the time and effort because we consider it worthwhile and because we care. This parent/child analogy helps clarify the simple but key notion that everyone who contributes and is involved in open source cares about their project and community. People and organizations contribute a considerable amount of time to build and maintain their open source projects. It’s time and energy that could equate to money.

Time = Value = Money

Let's accept the reality that when a developer contributes to open source, they are typically taking time away for their paying jobs (and family) to...Read More

OPTASY: What Does It Take to Develop a Mobile-First Content Strategy for Your Drupal Website?

11. Juni 2018 - 16:47
What Does It Take to Develop a Mobile-First Content Strategy for Your Drupal Website? adriana.cacoveanu Mon, 06/11/2018 - 14:47

There's definitely no way around it, not anymore: with Google's index now mobile-first, adopting a mobile-first approach when building a new Drupal site (or redesigning a legacy one) is… a must! It no longer depends on a specific project's needs or on the used technology. The need to develop a mobile-first content strategy has gone from particular to universal.

And facing the challenge of:
 

  1. (re)creating
  2. optimizing
  3. structuring
     

… content on your Drupal website means conforming to those specific patterns that mobile users have developed for reading content on their smartphones.

ComputerMinds.co.uk: Rebranding ComputerMinds - Part 6: Migration

11. Juni 2018 - 15:03

I volunteered to carry out the migration for the new ComputerMinds site as migration was one of the very few areas of Drupal that I hadn’t delved into thus far. With Drupal 8 becoming more and more popular, now was a great opportunity to learn the migration ropes. Luckily, Drupal 8’s migration has greatly improved since Drupal 7 so my life was made somewhat a little “easier”!

This article will be aimed at some of my finds and processes, rather than a “How to do a D8 migration”.

Since our new site was very different to our old one in terms of content, we had to be quite choosey in exactly what was needed. We decided that we only really needed the articles; pretty much everything else was a fresh start. We would be manually carrying over users; as that would be too little work to warrant writing a migration for.

In order for us to get our articles over from the old site, we would need to migrate the current taxonomy terms, URL aliases (this would come back to bite me hard!), files and last but not least, the article nodes themselves. Migrating just a node seemed simple enough, but you quickly forget that it is more than just a node. All the stuff attached to the node has to be carried over.

Modules like Migrate plus and Migrate tools are great additions to the migration family and I can highly recommend them; they make life so much easier! Migrate plus “basically” writes the migration for you :)

With Migrate plus doing the bulk of the work for me, the only PHP code I needed to write was to map our old User ID’s to the new ones, so original authors would be retained. Otherwise I could take all the credit for every single article ComputerMinds has ever written in the past (mwahah!). This can be easily achieved using a simple process plugin.

/** * This plugin will tie a piece of content with an existing user. * * @migrateProcessPlugin( * id = "user_id_mapper" * ) */ class UserIdMapper extends ProcessPluginBase { /** * {@inheritdoc} */ public function transform($value, MigrateExecutableInterface $migrate_executable, Row $row, $destination_property) { $mapping = [ 'oldID' => 'newID', ]; if (!empty($value)) { $value = $mapping[$value]; } return $value; } }

We had some term reference fields, and like Drupal 7, Drupal 8 will reduce your potential workload - it creates taxonomy terms for you if those terms are missing from your new site. Nice and easy.

The biggest remaining hitch was extracting the three components from a body field. These are value, summary and format. Summary and format were fairly straight forward, but attaining the value component was a real pain (the code below will show you otherwise). Straight away you’ll notice inconsistencies with the “keys”. I would have expected the format to have been body/value, body/summary and body/format, but alas this was not the case.

body: body body/summary: source: teaser body/0/format: plugin: static_map source: body/0/format map: markdown: markdown full_html: basic_html filtered_html: restricted_html

This took a few painful hours to debug and figure out, to this day I still do not know why! At least this being documented here can save others some pain and time.

With all migration finished and the site ready to be shipped out, what came apparent is that (as mentioned very briefly earlier) I had not accounted for some URL aliases (I had used a process plugin to pinch only the aliases we needed). I’d assumed, yes assumed (naughty developer), that ALL articles had the SAME URL path auto pattern. Big, big boo boo. What I didn’t know was that some articles on our old side had been migrated from an even older site and these article URLs came in all shapes and sizes; shapes and sizes that do not match our current path auto pattern. I’ve been fixing redirects and 404’s since :)

Lesson of the day

Do not ASSUME everything is the same. Do go check everything is how you expect it to be before migrating content.

John Svensson: How to dynamically create image styles derivatives - Part 1

11. Juni 2018 - 14:45

Three months ago I wrote an article on how to Create Image Styles and Effects programmatically and today we're following up on that article but introducing on how we can do that dynamically.

So, essentially what we would like to do is that we display an image, where we can adjust the way the image is outputted, given a height, width or aspect ratio etc.

Please bear in mind that all code provided in this article are experimental and does not yet cover things like access control, etc in this part.

Let's take a look at the service Unsplash.com. Its basically a free image bank with high quality images submitted by awesome freelancers and professionals that you can use for free.

Image by Eric Ward

The URL for the image above is the following:

https://images.unsplash.com/photo-1499365094259-713ae26508c5?ixlib=rb-0.3.5&ixid=eyJhcHBfaWQiOjEyMDd9&s=26d4766855746c603e3d42aaec633144&auto=format&fit=crop&w=500&q=60

The parts we're actually interested in are: &auto=format&fit=crop&w=500&q=60 we can adjust them as we like and the image is displayed differently, i.e. changing the width of the earlier image to a smaller one:

Alright, that's what we would like to do in Drupal 8. This article will be very iteratively, we'll rewrite the same code over and over until we get what we want. We'll notice issues and problems that we will deal with through out the article.

Prepare an environment to work in

We'll use a fresh Drupal 8.6.x installation.

To quickly scaffold some boilerplate code I'm going to use Drupal Console.

First let's create a custom module where we can put our code and logic in:

$ vendor/bin/drupal generate:module

I'll name the module dynamic_image_viewer

dynamic_image_viewer.info.yml

name: 'Dynamic Image Viewer' type: module description: 'View an image dynamically' core: 8.x package: 'Custom'

Next we need some images to work with, we'll use the core Media module for that. So let's enable that module:

vendor/bin/drupal module:install media

Now we can add some images. Go to Content >> Media >> Add media.

Implementing a Controller to display the image

The first step is to create a controller that will render the Media image to the browser. Again we'll use Drupal Console for a controller scaffold: vendor/bin/drupal generate:controller

We'll create a route on /image/{media} where Media will accept an media ID that due to Drupals parameter upcasting will give us a media instance in the controller method arguments. Doing this, if a invalid media ID is passed in the URL a 404 page is shown for us. Neat!

So we'll modify the generated controller slightly to this:

src/Controller/ImageController.php

<?php namespace Drupal\dynamic_image_viewer\Controller; use Drupal\Core\Controller\ControllerBase; use Drupal\media\MediaInterface; /** * Class ImageController. */ class ImageController extends ControllerBase { /** * Show an image. * * @param MediaInterface $media * * @return array */ public function show(MediaInterface $media) { return [ '#type' => 'markup', '#markup' => $media->id(), ]; } }

And the routing file looks like this: dynamic_image_viewer.routing.yml

dynamic_image_viewer.image_controller_show: path: '/image/{media}' defaults: _controller: '\Drupal\dynamic_image_viewer\Controller\ImageController::show' _title: 'show' requirements: _permission: 'access content'

If we install the module, vendor/bin/drupal module:install dynamic_image_viewer and hit the URL /image/1 we should see a page with the ID being outputted.

Render the original image

Ok. Currently nothing is rendered, so what we'll do is that we render the uploaded original image first.

To serve the file we'll use BinaryFileResponse. So let's update the ImageController::show method.

We'll also import the class in the top of the file:

use Symfony\Component\HttpFoundation\BinaryFileResponse;

/** * Show an image. * * @param MediaInterface $media * * @return BinaryFileResponse */ public function show(MediaInterface $media) { $file = $media->field_media_image->entity; $uri = $file->getFileUri(); $headers = file_get_content_headers($file); $response = new BinaryFileResponse($uri, 200, $headers); return $response; }

So what we do here is that we grab the File entity from the field_media_image field on the Media image bundle. We get the URI and, using the file_get_content_headers we get the proper headers. Finally we serve the file back with the proper headers to the viewer.

And if we hit the URL again:

Before we continue, we should note some things that we'll get back to later:

  • What if the media ID is not a Media image?
  • The user can still access the media even if its unpublished.
  • What about cache?
Let's make a hard-coded image derivative

To modify the image, we'll create a new instance of ImageStyle and add an image effect.

Let's update the ImageController::show method again:

/** * Show an image. * * @param MediaInterface $media * * @return BinaryFileResponse */ public function show(MediaInterface $media) { $file = $media->field_media_image->entity; $image_uri = $file->getFileUri(); $image_style = ImageStyle::create([ 'name' => uniqid(), // @TODO This will create a new image derivative on each request. ]); $image_style->addImageEffect([ 'id' => 'image_scale_and_crop', 'weight' => 0, 'data' => [ 'width' => 600, 'height' => 500, ], ]); $derivative_uri = $image_style->buildUri($image_uri); $success = file_exists($derivative_uri) || $image_style->createDerivative($image_uri, $derivative_uri); $response = new BinaryFileResponse($derivative_uri, 200); return $response; }

So what we do here is that we create a new ImageStyle entity, but we don't save it. We give it a unique name (but we'll change that soon) and then add we add an image effect that scale and crops the image to a width of 600 and height 500.
And then we build the derivate uri and if the file exists already, we'll serve it and if not we'll create a derivative of it.

There is one big problem here. Since we use a unique id as name of the image style we'll generate a new derivative on each request which means that the same image will be re-generated over and over. To solve it for now, we could just change the

$image_style = ImageStyle::create([ 'name' => uniqid(), // @TODO This will create a new image derivative on each request.

to a constant value, but I left it for that reason intentionally. The reason is that I want to explicitily tell us that we need to do something about that and here is how:

If we look back at the URI from Unsplash earlier &auto=format&fit=crop&w=500&q=60, these different keys are telling the code to derive the image in a certain way.

We'll use the provided keys and combine them some how in to a fitting name for the image style. For instance, we could just take the values and join them with a underscore.

Like so:

format_crop_500_60 and we'll have a unique string. If the user enters the same URL with the same parameters we'll be able to find the already existing derivative or if its another image, we'll create a derivative for it.

You'll also notice that I removed the $headers = file_get_content_headers($file); it is because those headers are not the correct ones for ur derivatives, we'll add them back soon.

Dynamic width and height values

On our second iteration of the code we'll now add the width and height parameters, and we'll also change the name of the image style to be dynamic.

Again, we'll update ImageController::show

We'll also import a class by adding use Symfony\Component\HttpFoundation\Request; in the top of the file.

/** * Show an image. * * @param Request $request * @param MediaInterface $media * * @return BinaryFileResponse */ public function show(Request $request, MediaInterface $media) { $query = $request->query; $width = (int) $query->get('width', 500); $height = (int) $query->get('height', 500); // We'll create the image style name from the provided values. $image_style_id = sprintf('%d_%d', $width, $height); $file = $media->field_media_image->entity; $image_uri = $file->getFileUri(); $image_style = ImageStyle::create([ 'name' => $image_style_id, ]); $image_style->addImageEffect([ 'id' => 'image_scale_and_crop', 'weight' => 0, 'data' => [ 'width' => $width, 'height' => $height, ], ]); // ... Rest of code

First we updated the method signature and injected the current request. Next, we'll get the width and height parameters if they exist and if not we fallback to something. We'll build an image style name of these dynamic values. With this we updated the name of the ImageStyle instance we create which makes sure that we can load the same derivative if the user hits the same URL. Finally we updated the width and height in the image effect.

Let's add the proper headers back

Here is the updated ImageController::show and current file:

src/Controller/ImageController.php

<?php namespace Drupal\dynamic_image_viewer\Controller; use Drupal\Core\Controller\ControllerBase; use Drupal\media\MediaInterface; use Symfony\Component\HttpFoundation\BinaryFileResponse; use Drupal\image\Entity\ImageStyle; use Symfony\Component\HttpFoundation\Request; use Drupal\Core\Image\ImageFactory; use Symfony\Component\DependencyInjection\ContainerInterface; /** * Class ImageController. */ class ImageController extends ControllerBase { /** * The image factory. * * @var \Drupal\Core\Image\ImageFactory */ protected $imageFactory; /** * Constructs a ImageController object. * * @param \Drupal\Core\Image\ImageFactory $image_factory * The image factory. */ public function __construct(ImageFactory $image_factory) { $this->imageFactory = $image_factory; } /** * {@inheritdoc} */ public static function create(ContainerInterface $container) { return new static( $container->get('image.factory') ); } /** * Show an image. * * @param Request $request * @param MediaInterface $media * * @return BinaryFileResponse */ public function show(Request $request, MediaInterface $media) { $query = $request->query; $width = (int) $query->get('width', 500); $height = (int) $query->get('height', 500); $image_style_id = sprintf('%d_%d', $width, $height); $file = $media->field_media_image->entity; $image_uri = $file->getFileUri(); $image_style = ImageStyle::create([ 'name' => $image_style_id, ]); $image_style->addImageEffect([ 'id' => 'image_scale_and_crop', 'weight' => 0, 'data' => [ 'width' => $width, 'height' => $height, ], ]); $derivative_uri = $image_style->buildUri($image_uri); $success = file_exists($derivative_uri) || $image_style->createDerivative($image_uri, $derivative_uri); $headers = []; $image = $this->imageFactory->get($derivative_uri); $uri = $image->getSource(); $headers += [ 'Content-Type' => $image->getMimeType(), 'Content-Length' => $image->getFileSize(), ]; $response = new BinaryFileResponse($uri, 200, $headers); return $response; } }

First we added a new dependency to our controller \Drupal\Core\Image\ImageFactory which allows us to construct an Image instance, where we can get meta data from the image, but also gives us a unified interface to apply things to our image. For instance, we could desaturate the image by doing $image->desaturate(); and then resave the file. Fow now we're only using it to retrieve the meta data. We'll take advantage of that in the next part, when we refactor some of the written code and add more flexibility to what we can dynamically output.

If we hit the url and add both the width and height parameters we'll get something like this:

In the up coming article we'll take a better look at what we have, what we miss (access control, what if a user hits the same URL at the same time), adding more effects, and exploring the use of the Image and toolkit APIs more in depth.

We'll most likely remove adding image effects through ImageStyles and only use the image style for creating derivates that we can we can later apply changes with the toolkit API.

If you want to continue on your own, take a look at ImageStyleDownloadController.php file in core which contains a lot of code that we can re-use.

OpenSense Labs: Best Drupal 8 Security Practices to Follow

11. Juni 2018 - 13:38
Best Drupal 8 Security Practices to Follow Akshita Mon, 06/11/2018 - 17:08

Even though security remains one of the major concerns for an organization, the implication of new technologies has at the same time broadened and complicated the understanding of the term. 

Security is no more about working in isolation. 

Recent events such as Drupalgeddon 2 in March and other subsequent security releases in April – marked critical – have once again brought the question ‘Is Drupal Secure?’ to the center-table. Drupal is among those few open source projects popular for their security with a dedicated team working on to improve it. However, there are still sometimes when the security of your Drupal website is under the impression of threat. 

Security is a vast area of expertise and it is quickly changing with time. No more is it about one person working in isolation or an expert who can understand all the aspects. 

While the list of do’s and don'ts is extensive and exhaustive to keep up with the threats, vulnerabilities and mitigation strategies, here are the top seven Drupal security practices to follow in order to keep up the health of your website. 

And Aristotle once said...

The aim of the wise is not to secure pleasure but, to avoid pain. Seven Drupal 8 Security Practices Securing the Server-side Hosting Environment

Before starting off with the general security hacks and tips, you need to secure your server-side hosting environment. Here are some points to keep in mind before moving to securing your core. 

  1. Protect the server: Only a limited number of users must be allowed to access your server. One of the key points is to add a basic layer by restricting the access to server login details. Once the authentication is set up, it is easier to monitor server access and restricting file access usage. This can help you detect unusual activities.
     
  2. Hide the server signature: Server Signature needs to be hidden as it reveals an important piece of information about the server and operating system. It can let a hacker know if you are using Apache or Linux - information which can be utilized as a vulnerability used to hack the server. In order to keep the server secure from possible vulnerabilities, you need to hide the server signature. 
     
  3. Enable port wise security - Since the applications use the port numbers, it is important to keep certain port numbers hidden from general access. 
Securing the Drupal Core
  • Keep your Core Updated
    A key practice, keeping the core updated will always be the first when listing healthy security practices. And this was the first lesson we learned from the Drupalgeddon2. Always look out for core updates (include the minor releases as well) unless security is not on your agenda. In all of its advisories, the Drupal Security Team asks for updating the core version of the system. 

    If you fall a long ways behind the latest update, you are opening yourself to vulnerabilities. Since history tells us that hackers target the older versions.

    Look out for core updates. Follow the Drupal security team @drupalsecurity on Twitter. Get quick updates and announcements from the team through the emails and security newsletter. You can also follow Security Group in order to contribute and stay part of the security discussions. 

    Another important point to note here is when updating the core - ALWAYS keep a backup of your site's database and codebase. We will discuss this security practice later in the article. 
     
  • Security by Design
    As a matter of fact, every stakeholder wants security to be a simple concept, sadly it isn’t. One of the biggest misconceptions here would be that investing a hefty sum post development would ensure a secure system. However, it is never the case. 

    The best practice to follow is at the architectural level when the website is being designed. 

    Security by Design ensures that designing the software up by the ground to be secured in order to minimize the impact of a vulnerability when discovered. Pacing up your security from the foundation - is the key. It implies following the best security practices at the architectural level instead after building the website. 

    When the foundation of the design remains secure regardless of a reasonable approach adopted later, you can tackle the issues easily. A uniform methodology needs to be adopted to protect the assets from the threats. 

    Once the requirements have been collected, the architecture can be laid out and other elements can be discussed later like trusted execution environment, secure boot, secure software update among others.
"The key to security is eternal vigilance"
  • Use Additional Security Module
    When covering security, there is nothing as better than equipping yourself with more and more. To keep the walls up high, you can use the additional security modules like security kit, captcha, and paranoia. Drupal Security Review can be used as a checklist to test and check for many of the easy-to-make mistakes making your site vulnerable.  

    You can also look out for a List of Must Have Security Modules to prevent you from becoming the next victim of a potential cyber attack. 
     
    • Security kit
      SecKit provides Drupal with various security-hardening options. This lets you mitigate the risks of exploitation of different web application vulnerabilities such as cross-site scripting (XSS), Cross-site request forgery, SSL, Clickjacking and other. 
       
    • Captcha
      A CAPTCHA is a reaction test put in the web structures to eliminate entry by robots. It helps in protecting your website’s contact and sign up forms asking you to prove your credibility as a human with a bizarre sequence of characters, symbols, numbers and sometimes images.

      Often they thwart you from accessing the content. Quite the irony, their purpose is contrary to what we reckon about them.

    • Paranoia 
      Paranoia helps you identify all the vulnerable issues/ places from where a potential leak is possible. It alerts the admin when an attacker tries to evaluate the PHP script via the website interface. 

      It helps in blocking the permission for the user to grant PHP visibility and creation of input formats that use PHP filter.

      It also prevents the website to grant risky permission, mostly the ones that involve leaking the script information.  

    • But Use only Security Team Approved Modules 
      Your site probably uses a number of contributed modules, although that’s not an issue. Using the stable and approved modules is where the key lies. This is especially worth noting for contrib modules which are more susceptible to vulnerability. 

      Always look out for the green batch when downloading a contrib module. Rest, as the advisory reads, Use it at your own risk! An example of security team approved module with a green batch An example of a vulnerable module
    Backing Up - In Case of a Mishappening
    • Keep Up your Backup
      Catastrophes never come invited. While all seems perfect, you might wake up to find out that your website has been taken down by some psychotic hacker. Although it is an unforeseen event, you can definitely arm up yourself.

      As an administrator, you have to be prepared for all of such uninvited events. They can be controlled and the damage minimized by strengthening security, frequent backups, installing updates in a timely manner.  

      We cannot stop disasters but we can arm ourselves with better security and backups. Hosting by Acquia cloud or Pantheon provide automated daily backups of your site’s database, files, and code plus single-click restoration if something goes wrong. 

      You can also use the Backup and Migrate Module or Demo Module because unlike life your Drupal website has the option to go back for some changes. 
    User-Side Security
    • Follow a Standard Practice with a Strong Password Policy
      Passwords are used at both admin and user level, therefore strong and secure passwords are important for your website. When I say strong password should be used I have nothing against short and easy passwords. Easy should never imply less efficient

       A string like Mypassword123 will prove acceptable but is obviously weak and can easily be brute-forced.

      The best practice? Your password should provide realistic strength in terms of measurement and complexity. A password must only be allowed as long as it proves to be of high enough entropy with a combination of characters, alphabets - uppercase and lowercase, symbols, and numbers.

      Start checking passwords on explicit rules and amount of varying character types to be used (symbols, numbers, uppercase letters, etc). 

      Password Strength - a Drupal module - classifies the expected brute-force time for the summed entropy of common underlying patterns in the password. Patterns that can be detected in passwords include words that are found in a dictionary of common words, common first and last names or common passwords. 
    Your password can make the difference between a vulnerable and a hard-to-hack Drupal site.

    While there will always be some new thing to add to the list, you can be sure that this list comprises of the core practices which need to follow. The protocol for communication needs to be clear and well documented. Properly documented procedures are important, as third-party services can often be manipulated.

    In need of a security update or services? Drop a mail at hello@opensenselabs.com and let us help you out. 

    Site builders and developers need to keep an eye open for the possible when security releases are announced and apply them quickly, to ensure the site is not compromised. It is good to be consistent and have your reasoning documented so that it is clearly understood.

    blog banner blog image Blog Type Articles Is it a good read ? On

    Valuebound: How to highlight search results in Search API Solr View in Drupal 8

    11. Juni 2018 - 11:15

    In Search API, there is a field for a search excerpt that you can use on field views to highlight search results. In this article, I’m going to show you how to enable excerpt and set it using views. Here I’m assuming that you have already set the Search API module and has a Search API Solr view.

    Follow the steps:

    Go to Manage -> Configuration -> Search and Metadata -> Search API.

    In your search API index ‘processors’ tab, enable Highlight Processor as shown below.

    Roy Scholten: Implementing IndieWeb on your personal Drupal site, part 1

    10. Juni 2018 - 23:53
    Sub title

    Laying the foundations for POSSE

    /sites/default/files/styles/large/public/20180610-indieweb.png?itok=KzjgwAsG

    This is my version of the steps you need to take to make your site part of the indie web community. Swentel helped me getting it all setup on this here Drupal site using his indieweb module. It’s all a bit complicated still, so this is mostly me trying to retroactively understand what’s going on.

    As it says on the site, the IndieWeb is a people-focused alternative to the corporate web. Its main tenets:

    1. Ownership – your content is yours, it should not belong to a corporation.
    2. Connection – starting from your own site you can share your content to all other services.
    3. Control – post what you want, in the format you prefer, using your own URLs that you keep permanent.

    While 1 and 3 are essential and relatively easy to achieve (use your own domain and post your content there), it’s number 2 that is the most alluring.

    Owning your stuff and being able to share it across multiple platforms combines ownershop with reach. This is what “POSSE” is all about: Publish (on your) Own Site, Syndicate Elsewhere. Drupal lead Dries Buytaert has written several posts outlining his POSSE plan.

    Getting started

    This “Connection” part of indieweb publishing is also the most complicated. There are quite a few moving parts to getting it all up and running.

    For Drupal sites, the setup for the community/sharing/syndication parts of indieweb publishing has gotten much more accessible with the release of the IndieWeb module created by swentel. It doesn’t necessarily reduce the number of things to set up, but it provides a centralized UI for all of them: Webmentions, Microformats, Feeds, Micropub, IndieAuth and Microsub.

    Before going over the details of configuring the indieweb module itself, we have to take care of some basics first.

    Introduce yourself (right on)

    To own your content on the web, you have to establish that you are in fact, you. That’s why IndieWeb starts with having your own domain and posting some initial content there. Important part of this initial content is a specific bit of HTML that establishes you as the author and owner of things published on this particular domain:

    Roy Scholten

    The specific part here is that “h-card” class added to the anchor tag. This “h-card” is one of a collection of so-called microformats. With microformats you give more structure and semantics to information presented in HTML. In this case, h-card is the microformat to use for publishing information about people or organisations. We’ll need to add other microformats to (blog) posts you publish on the site, but that’s for later.

    To do in Drupal

    The indieweb module does not (yet?) handle adding this information to your site. Add your version of the HTML snippet above to a (new or existing) Drupal block. Place that block to be visible on your homepage. The site footer or maybe a sidebar are obvious places you can put it. Mine’s in the footer below.

    You can check if all is fine with https://indiewebify.me/validate-h-card/. Enter your domain name there and it will report back with what it found and suggest additional elements you could add to enhance your h-card.

    Even without posting any other content to your own site, you now have your own space on the indie web and setup your identity in a way that you own and control.

    Next: add links to your existing social media accounts

    You’ve seen those signup forms that let you create an account by using your existing Google, Facebook or Twitter account details. In this step, you configure your own domain to be your IndieAuth identity. This lets you use your own domain to sign in to other sites and services.

    There are not many sites outside the indieweb circles itself that offer this, I think. It’s still useful to do this though. You’ll likely want to use some of these indieweb services, especially to automatically share (links to) your content on other platforms like Twitter or Facebook.

    To do in Drupal

    Detailed instructions are here. In short:

    Add links to your other profiles and add the rel="me" attribute. Might as well add this to that h-card block you created in the first step. For example:

    @royscholten on Twitter

    If you have a Github account, that’s also a good one to add.

    To do on the external sites you link to

    Link back to your homepage from your profile page on these services. The indieweb wiki has direct links to edit your Twitter and Github profile.

    Then, try logging in to indieweb.org to see if it all works.

    So far, so good,

    So what? By establishing your identity on your own domain you stake out your own spot on the internet that you control. With this set up, you have created an environment for publishing on your own site and syndicating elsewhere.

    Next time: configuring the indieweb module to start sending and receiving webmentions, the indieweb catch-all term for comments, likes, reposts and the like.

    Tags indieweb posse drupalplanet

    James Oakley: Moving from Piwik to Matomo on Drupal

    9. Juni 2018 - 12:37

    I'm a big fan of Piwik, an open source analytics suite. Think Google Analytics, StatCounter, Sitemeter, etc. … only self-hosted an open source. There are many benefits of using it:

    Blog Category: Drupal Planet

    Ashday's Digital Ecosystem and Development Tips: Decoupled Drupal: Ashday has gone React!

    8. Juni 2018 - 21:00
    Decoupled Deschmupled

    Like many folks in the Drupal space we've been closely following the Decoupled Drupal conversation for the past few years, and occasionally a part of it.  And, again like many folks in the Drupal space, until recently we had felt that it was somewhat in its infancy and a lot of tough questions still remained as to whether it was even a good idea. The SEO implications have not been entirely clear, the impact on estimation has also been very hard to nail down, which decoupled framework to go with has not at all been a consensus, and what Drupal’s exact role is in the decoupled site has not been clear either. 

    Axelerant Blog: Women at Axelerant: Chapter Three

    8. Juni 2018 - 15:12


    I sat down to speak with the amazing women of Axelerant, and they each shared their unique perspectives about what it's like being professionals in their field. In this chapter, Swati, Hetal, Priyasha, and Aliya expound on this—and in their own words.

    OpenSense Labs: How To Devise Your Content Strategy With Drupal

    8. Juni 2018 - 14:01
    How To Devise Your Content Strategy With Drupal Shankar Fri, 06/08/2018 - 17:31

    Content is the fulcrum of any enterprise that gives them the tensile strength to build a robust online presence. Having the right approach towards delivering astounding content involves plenty of effectual content strategies in place. Drupal 8 is your one-stop destination for building an efficacious content strategy with its out-of-the-box capabilities.

    Source: Getty Images

    According to a research by LinkedIn, 72 percent of the digital marketers have a content strategy in place of which 30 percent are the documented and the rest non-documented.

    Before we look at the ways of forming a blueprint for content distribution, let’s see what are the various models of disseminating content.

    Content dissemination

    Every organisation has a different need for content distribution plan and requires different kind of content dissemination. An organisation may have a primary global site that contains the most of the content. This might have to be distributed to different secondary sites if it is a large organisation with a global presence. Even some external sites might be receiving the content from the primary site. It is also possible that these secondary sites would be sharing the content with each other through a peer-to-peer network.

    Primarily, organisations adopt either of the top content distribution models namely, centralized and decentralized models.

    Centralization

    This involves a primary site that acts as the main activity hub when it comes to content production. Large enterprises would have the dire need of such a website which would pass on the content to its global sites or product sites. Thus, this helps in maintaining the brand consistency during cross-channel marketing campaigns.

    Source: Acquia

    It is possible that one of the secondary sites may have a relevant information on the subject. Primary site may need to import important information from its sub-sites so that it can then distribute it to the other secondary sites. In any case, in the centralized model of content dissemination, content is propagated through a primary site to the global sites.

    For instance, the website of United Nations is powered by Drupal. It has a global presence with member nations from across the globe. To meet their needs, it has dedicated country sites that comprises of unique digital marketing teams. So, if a new agreement has been signed on by influential nations on combating climate change, a digital marketer can push the information out to the secondary sites via a primary site thereby publishing the content to both primary site and its secondary sites spread across the nations.

    Another very good example is the Planet Drupal, which displays the aggregated list of feeds about Drupal posted around the globe. Drupal.org, Groups.Drupal.org and several other sub-sites may find several absorbing contents fit into its topical sections. Planet Drupal provides the platform to share interesting, relevant and highly useful Drupal-related informative blogs.

    Decentralization

    It is not always the case where a primary site would be distributing content to additional sites. What if there is no such main site to propagate the information to the secondary sites? Independently run sites can share content with each other through a peer-to-peer model of content dissemination.

    Source: Acquia

    For instance, an organisation from media and publishing industry can have several regional sites. So, in a country like India, with a diverse and multi-linguistic culture, a digital media might have independently run regional sites. If a regional site in Chennai, a metropolitan city in India, is running a cover story of the citywide celebration of a festival, their national television channel can reuse that coverage of festival to be posted on its site.

    It is doubly important to choose the right model of content distribution for your organisation’s needs and its success. It is also significant to have the best content strategies in place in addition to the continuous flow of wonderful content.

    Constructing effectual content strategies Source: Contently

    A question on Quora reads, “How do I develop content strategy?”. It involves identification of roles and workflow to find out who does what, formulation of standard guidelines to be followed by content producers, repurposing available content on your site, and using the best tools and technology available.

    Source: ContentlyHammer out the finer details of your objectives

    Before you commence with the proceedings involving content production, you need to be smart and have the right set of goals and plans for the creation of superabundance of content.

    • Being succinct: Make sure that what you plan is precise, specific and succinct.
    • Relevancy: Your objectives should be relevant to your business. So, if you are a Drupal agency, in addition to Drupal related content, you can explore many other technologies that can work together with Drupal.
    • Being realistic: Setting goals that are attainable would serve you the purpose better. If your Drupal agency has been churning out 30 blogs per month, setting 100 blogs per month would be too drastic.
    • Trackable: Your objectives should be measurable. So, if you want to boost your social media presence, formulate a goal that focuses on increasing it by X percentage so that you can measure your achievement rate.
    • Time constraints: You should have a goal that is time-bound. You should be able to adhere to the timeline set for the particular task.
    Define your target audience

    A proper persona research would help immensely to build content that is ideal for your users. For the creation of optimal content, you should know who your customers and prospects are, what are their interests and concerns, and what sort of content do they want to consume.

    Source: Online Marketing Institute

    Start off by developing the persona research for existing user base. Pen down user profiles like their name, job role, industry information and demographic details. Once you do so, try to gauge what information are they searching for, their needs and challenges.

    Assess your content

    Performing a content audit would help you in re-organising your existing content. Always review your existing content to see what can be repurposed or reused.

    Instead of spending a lot of your time in creating or recreating something, content assessment can help in identifying gaps in the existing ones.

    Choose the right Content Management System

    Selecting the best CMS to power your website can pay dividends. Drupal 8 should be your goto CMS when it comes to choosing the best content-friendly framework.

    Source: Bluehost

    Its amazing themes offer the best UX to the content editors. A plethora of custom and contributed modules assist in customization of your site as per your needs and help hugely in content publication. It can of great use for content analytics. For instance, Real-time SEO for Drupal recommends automatic alterations that can boost the SEO of the content that is going to be published.

    Prepare a super list of topic buckets

    Brainstorming on content ideas can be effectively done through tools like Buzzsumo, Feedly, Semrush and many more. Once done, start preparing a topic cluster to construct a super list of relevant content based on the parameters like search volume and long tail keywords.

    Rummage through the content types

    A plenitude of content types can be derived, after the super list has been prepared, to work upon. Determining the sort of content you should be using would depend on different stages of buying cycle of the prospects.

    • Brand awareness: The prospects would rummage through your products and services, understand your brand value and try to gauge whether they have the need for your product.
    • Identification of problem: Prospect might figure out the problems and start researching about the possible solutions thereby coming across your products.
    • Comparing available options: Prospect can compile the list of vendors and validates these options.
    • Decision-making: After the comparison of different options, the prospect can start deciding which one to choose from.

    Once the different stages of buying cycle are figured out, it is time for mapping what sort of content type would suit best for each of the stages. An illustration below shows the types of content that can be identified with different stages.

    Source: Hubspot

    Drupal can be of great use to build these content formats. Let’s see some of them.

    Posting blogs: Posting blogs on your website on a regular basis is of utmost importance. Blog posts should provide valuable information to your readers ranging from long form to short form blog types. Drupal provides options for posting different types of content on your website. Whether it is business-centric article or an interview of a CEO from a renowned company, Drupal has the provision for posting different sorts of content.

    Developing infographics: Another great way of producing content is the infographics that provide graphical information to convey an information clearly and quickly. Drupal offers a lot of modules that can help in embedding images with infographics in your blog posts. For instance, colorbox, a Drupal module, can help in displaying an image by overlaying it above the current page.

    Embedding videos:  A research by Hubspot, as can be seen in the stats below, shows that video is increasingly becoming the most influential and preferred medium of content. Drupal has plenty of modules that can be used for producing videos and embedding them in the blog posts. For instance, CKeditor Media embed module can help in embedding videos, images, tweets that are hosted by other services.

    Creating Podcasts: Edison research, in one of their studies, reports that 57 million people listen to podcasts every month.  If you have interesting presentations, want to share the latest information on your products and services, or have some amazing conversation with industry leaders, podcasts are the way to go. Drupal 8 module, RSS SimplePodcast, lets you create simple podcast RSS.

    Content Governance

    Governing the publishing of content is one of the foremost things that content editors need to take care. Having the provision for publishing the content should be hassle-free. You should not only be able to publish your blogs posts but also be able to schedule it as per your organisation’s workflow and your convenience. Scheduler, Drupal 8 module, helps in publishing or unpublishing a content at a particular date and time.

    Content editors should also have to administer the publishing of content other than their own sites. Creating original content for an online content portal like Medium would be really helpful in spreading the content to bigger and relevant audience. Also, publishing the content on social media sites like Twitter, LinkedIn etc. can help in targeting more eyeballs.

    Conquering challenges

    Strategizing the content flow can be rewarding but it does have its fair share of hurdles.

    • Construction of right content for the audience can be hassling.
    • Churning out the right amount of content can be tricky.
    • Looking up for a specific content from the wealth of content on website can be strenuous.
    Source: HubspotDrupal 8: Ultimate choice for content strategy

    It is of paramount importance that you choose the right CMS for your business when it comes to producing a great content efficaciously. Drupal offers the belligerent support needed for content-heavy websites.

    APIs as a core feature

    Business enterprises can choose Drupal as the central content repository getting the best out of its rich content structuring, content creation, and administration provisions. Drupal provides the best way to curate, build, and publish content through APIs as its core feature. It makes multi-channel content distribution much easier.

    Web personalization

    Drupal has the means for enabling web personalization that helps in understanding the interests of the users, tailoring the website to accommodate their profile and, offer them the best content that is relevant to them.

    Source: WhiskData

    Acquia Lift Connector, Drupal module, helps in the unification of content and the insight collected from several sources about the customers for delivering in-context and personalized experiences across multiple platforms.

    Intelligent content tool module, supported by Opensense Labs, helps in auto-tagging, text summarization and finding content duplication.

    Multilingual capabilities

    Drupal 8 has out-of-the-box multilingual capabilities that help in building websites in more than 90 languages. With in-built modules for language handling, interface translation, configuration management, content translation, Drupal 8 can of great help in building multilingual sites easily. This helps in tailoring user experiences by translating the content in their own language.

    Mobile-first approach

    Drupal 8 is responsive out-of-the-box. That means the mobile-first approach is a core part of the Drupal framework. It comes with a plethora of fully responsive themes that enables it to work efficiently across platforms. Your content would look exactly the way you want on computers, tablets, and smartphones.

    Content strategy project for Drupal.org

    Drupal.org Content Working Group met for a two-day workshop in 2014 to get the team from Forum One, content strategists and user experience designers, to build a content strategy for the official Drupal website.

    Why is content strategy formulation needed?

    Drupal.org is the hub of Drupal and its community. It is the main source of code, Drupal-related information and collaboration among the community members. From project managers to web developers, everyone contributes towards its development and betterment. Organisations from a wide array of industries like governments, nonprofits, and Fortune 500 companies have been using Drupal for their business needs.

    What were the objectives of this initiative?

    One of the first things that they wanted to improve was the quality and the relevancy of the content available on the Drupal.org website. They also planned to reframe it around all the user roles and proficiencies to address all the audiences. Moreover, their objective was to develop a content governance for the site and improve user engagement within the Drupal community.

    What were the steps taken to improve content strategy?

    Content Working Group and Documentation Working Group of Drupal identified some gaps and put forth some fixes as part of their content strategy for the site.

    • With over a dozen content types, more than a million pieces of content, much more taxonomy terms and views that represent displays of data, thousands of forum topics, projects (including modules, themes and distributions) and issues associated with these projects, Drupal.org had a lot of content.
    • They took steps to break down these content types into more meaningful content types. For instance, a book page content type can be anything ranging from documentation to resource guides. Thus, this had to be broken down into relevant content types so that the new users can find information more easily.
    • Moreover, a dearth of marketing materials was noticed. They pledged to create content to promote Drupal 8 among the likes of CIOs, CTOs, managers, and business decision-makers.
    • A content audit was needed to be performed regularly. They zeroed in on what sort of content could be archived, what can be removed, and what can be updated. Content mapping was done as well to figure what content they have on the site and what sort of content would they need that would assist in building better information architecture for the new users.
    • They analysed and tested the user experience for creating and maintaining the content on the site.
    Tools and technology for content strategy

    Understanding the significance of formulating a master plan for producing content on your website can have dramatic metamorphosis for your business. Now, that we have understood the importance, we need to look for the right technology stack that can help out attain our goals.

    Integration of CMS and DAM

    Content Management System (CMS) like Drupal is primarily designed to build, publish and handle the content on your website. A Digital Asset Management (DAM), in contrast, is highly useful for governing the digital rights and the storage of media content like photos and videos. Integrating DAM capabilities into the CMS can be a big boost for your content endeavours. For instance, integration of Drupal with Acquia DAM, a cloud-based DAM, cam improve brand consistency with the usage of rich media content.

    Project management

    Usage of project management tools like JIRA, Workbench or InMotionNow can help in imbibing an agile approach to your content workflow, incorporate editorial calendar for effective content management and also help in the proper planning of content production.

    Content analysis

    Integrating business intelligence and analytics tools like Tableau and Google Analytics would help in compiling reports on your content marketing efforts and assist in the assessment and measurement of your website content.

    Future of content strategy

    With an enormous presence of disrupting technologies promising to streamline the way existing technologies manage our workflow, curating and distributing content on your website can benefit from some of the future technological advancements.

    Virtual reality

    A Statista report states that by the year of 2022, the market size of virtual reality would amount to 209.2 billion US dollars. Virtual reality can be a great option to produce immersive content for your content marketing campaigns. For instance, IKEA introduced their customers a way of virtually exploring the living room rather than just looking at their products at the store.

    A fictional site of Massachusetts State University was built on Drupal 8 that would help students to take a virtual tour of the University from their website.

     

    Artificial intelligence

    To make your content production more predictive, personalised and relevant, AI can be of great help. For instance, Amazon Rekognition helps in integrating photo and video analysis in your application and lets you identify which influencers are generating more user engagement vis-à-vis various product categories.

    Native advertising

    You might have noticed some form of paid advertisement while reading e-newspaper where the content seems similar to the native content of the platform. Native advertising can play a big role in the content marketing tactics in the future. Almost 60 percent of US digital display ad spending would be done through native advertising.

    Live streaming

    Another form of content dissemination is the live streaming which will grow immensely in the coming years. It is more like a real-life conversation where audience can pose questions and get responses in real-time thereby increasing user engagement. Viewers spend 8 times longer on a live streaming video content than the on-demand videos.

    Conclusion

    Creating cornucopia of content is a great deal of work. Producing content smartly by devising right strategy to disseminate content across channels is the way to go. Drupal has been pioneering in the effective distribution of content and can be a great option to embed your website with the best of content.

    Ping us at hello@opensenselabs.com to implement the best content strategies for your Drupal site.

    blog banner blog image Blog Type Articles Is it a good read ? On

    James Oakley: Security and Performance: Remove old Modules

    7. Juni 2018 - 22:49

    Yesterday, the Drupal Security team issued a Security Advisory for the Mollom module, SA-CONTRIB-2018-038. The module is now marked as "unsupported".

    The security team is marking this project unsupported. There is a known security issue with the project that has not been fixed by the maintainer.

    Blog Category: Drupal Planet

    Acro Media: Drupal with WebSockets for Real-Time Synced Displays

    7. Juni 2018 - 16:45

    The situation: I'm the primary maintainer of the Commerce Point of Sale module and have been building a customer facing display feature for the Commerce 2 version. So, I have two separate pages, one is a cashier interface where a cashier enters products, the second is a customer facing screen where the customer can watch what products have been scanned, review pricing, and make sure everything is correct.

    The problem: Since products can be scanned through quite quickly, it was imperative that the customer facing display update very quickly. The display needs to match wha's happening in near real-time so that there is no lag. Unfortunately, AJAX is just too slow and so I needed a new solution.

    The solution: WebSockets seem like a great fit.

    Design

    AJAX - Too slow!


    WebSocket - Fast!


    The socket server can either not bootstrap Drupal at all, or bootstrap it only once upon load, making it able to relay traffic very quickly.

    Dependencies

    I only needed one dependency for this, Ratchet, which is a PHP library for handling WebSockets and is easily installed via Composer.

    Setup

    The WebSocket server is actually very simple, it finds and loads up the autoload script for Drupal, similar to how Drush does it.

    We bootstrap Drupal, just so we can load a few config settings.

    We terminate the Drupal kernel, since we don’t need it just for ferrying traffic back and forth and it will probably leak memory or something over a long time if we use it a bunch, since Drupal isn’t really meant to run for ages. I did try it with Drupal running the whole time and it did work fine, although this wasn’t under any real load and only for a couple days.

    Now all that we have to do is setup the service.

    All the details of our service come from the class we pass in, which basically hooks in the different server events. I’ll leave the details of that outside of this article as none of it is Drupal specific and there are lots of tutorials on Rachet’s site: http://socketo.me/docs/hello-world

    Javascript

    On the JavaScript end, we connect to the WebSocket using the standard interface.

    I used a few mutation observers to monitor for changes and then passed the changes to the WebSocket to relay. You could do this however you want and probably some nicely integrated JS or even a React frontend would be a lot cleaner.

    Resources

    Related module issue: https://www.drupal.org/project/commerce_pos/issues/2950980
    Ratchet PHP Library: http://socketo.me/

    groups.drupal.org frontpage posts: Drupal Security team response to recent news articles relating to SA-CORE-2018-002 and SA-CORE-2018-004

    7. Juni 2018 - 15:51

    Various media outlets are reporting that a large number of Drupal sites are still vulnerable to the recent highly critical core vulnerabilities SA-CORE-2018-002 and SA-CORE-2018-004.

    Those reports are all based on the same source. The source investigated the contents of CHANGELOG.txt of a large number of sites and assumed all sites reporting a version lower than 7.58 to be vulnerable.

    Checking the contents of CHANGELOG.txt is not a valid way to determine whether a site is vulnerable to any given attack vector. Patches distributed by the Drupal security team to fix the issues were widely used, but did not touch CHANGELOG.txt or any version strings defined elsewhere. There are also other mitigations that vendors have provided which would also not affect CHANGELOG.txt but would protect the site.

    We believe the presented numbers to be inaccurate. We consider it to be misleading to draw conclusions from this sparse information. The Drupal project has a long history of a reliable coordinated disclosure security program. For the past 4 years, the Drupal Security Team has provided support to journalists covering our releases and policies and is available for further enquiries.

    If you are a member of the press and want the Drupal Security Team to comment, please contact security-press@drupal.org.

    Chromatic: Why You Should Consider Drupal – Painless Migrations

    7. Juni 2018 - 15:30

    Making content migrations relatively painless lowers the bar immeasurably in making the switch to a platform like Drupal.

    Tim Millwood: Drupal composer paranoia plugin

    7. Juni 2018 - 11:04
    Drupal composer paranoia plugin

    Over the past few months one of my colleagues, Jean Ribeiro (jribeiro), has been working in conjunction with Florian Weber (webflo) from drupal-composer, on a composer plugin for added Drupal site security.

    The Drupal Paranoia plugin works with two directories, web and app, although these can be renamed within you composer config to whatever works for you. The app directory is where all non-user facing code lives, this includes PHP, yaml, twig etc from core, contrib, and custom modules.The web directory then contains symlinks all user facing code, such as CSS, JS, and other files. It also contains stub PHP files for some items within the app directory.

    Within the plugin the public files directory is assumed to contain only user facing files, so it is symlinked. The codebase is then scanned for what are considered asset files. These are a fixed list of file extensions, which are expected to be used for module themeing and themes themselves, such as css, js, png, gif, etc. There is also a set list of "front controller" files, these are PHP files that do need to be user facing. The list includes index.php, core/install.php, core/rebuild.php, and core/modules/statistics/statistics.php. These files are then added via a stub PHP file, which calls the require function to pull them in.

    This plugin allows you to point your web server to the web directory without exposing any non-public files to users, giving an extra layer of security. There are no known specific security issues this will mitigate, however if there were any contrib or custom code with executable PHP code, this will update the codebase to make sure it's not remotely executable. For example in 2016 there was an issue found with coder module were one of the executable PHP files opened a security hole. If anything like that were to happen again, you would be protected by using the Drupal Parnoia plugin.

     

    Thanks to Jean Ribeiro and Chad DeGoot for helping write and review this blog post.

    timmillwood Thu, 07/06/2018 - 10:04 Tags drupal planet drupal-planet composer plugin drupal drupal 8 drupal8 Add new comment

    Tim Millwood: Workspace upgrade path

    7. Juni 2018 - 11:03
    Workspace upgrade path

    We've taken some time recently to discuss how we're going to handle the upgrade from the Workspace contrib module to the Workspace core module, once it's released. In our setup we have around 20 sites, each with 4 (or more) environments, all with Workspace installed, syncing content between each environments (and sometimes between each site). Therefore this is a task we are taking very seriously and want to make sure we have a super stable approach which will result in no loss of production content.

    The obvious idea is that we provide some kind of update hook that converts all of the workspaces to the new core module, along with all of their content. However, the new Workspace module is quite different in the way that it stores and handled entities, therefore this will be a lot of work. We don't have a lot of time to do a lot of work because we have to port Multiversion and Relaxed modules over to handle all the features that are not going into core. We also have "day job" work to do helping to build and support these 20+ sites.

    The idea we are looking to implement is a lot more simple. Uninstall the contrib Workspace module, and install the core Workspace module.

    Uninstalling the Workspace module (and all dependencies) will delete all workspaces, and all content in them. Therefore what you will be left with, effectively, is the live workspace and all live content. Installing the new module will recreate a live (and stage) workspace, and all content will be associated with the live workspace. There will be some kind of check available to see if all content has been synced up to the live workspace to prevent real data loss, but we see workspaces as disposable anyway.

    Another option we are looking into is being able to replicate content off to another Drupal site (or CouchDB database), then do the uninstall / reinstall process, and sync content back. This will work well because the HTTP API used will be the same on both versions of Relaxed module. However, because of the number of moving parts here we feel the straight uninstall / reinstall process, dropping all non-live content, might actually provide better stability.

    This process will be fully documented in release notes and on Drupal.org when the time comes.

    It'd be great to hear any feedback from users of the contrib Workspace module if this approach would work.

    timmillwood Thu, 07/06/2018 - 10:03 Tags drupal planet drupal-planet drupal drupal8 drupal 8 drupal core workspace Add new comment

    Appnovation Technologies: Drupal Service ID Collectors

    7. Juni 2018 - 9:00
    Drupal Service ID Collectors Since the arrival of Drupal 8, we've had services. This also brought the concept of a service collector or tagged services. This allows services to be tagged with a specific tag, then a service collector can collect all services with the a given tag and use whichever service "applies". As you could imagine loaded all of these tagged services when load...

    orkjerns blogg: Creating services with optional dependencies in Drupal 8

    6. Juni 2018 - 22:54
    Creating services with optional dependencies in Drupal 8 admin Thu, 06/07/2018 - 11:08

    Today I encountered a problem I did not think about earlier. After I pushed a fix to a project I am working on, the CI builds started showing errors. And the problem was coming from a message like this:

    The service "mymodule.attachments_manager" has a dependency on a non-existent service "metatag.manager".

    In many cases when you see that, it probably means your module was installed before a module it depends on. For example, in this case, it would seem that this module depends on metatag, and so declaring it as a dependency would fix the issue. And for sure, it would. But sometimes dependencies are not black and white.

    This particular service does some handling of the attachments when used together with metatag. It does so, because it is a module we use across projects, and we can not be sure metatag is used in any given project. So it's only used in a way that is something like this:

    /** * Implements hook_page_attachments(). */ function mymodule_page_attachments(array &$attachments) { if (!\Drupal::moduleHandler()->moduleExists('metatag')) { return; } \Drupal::service('mymodule.attachments_manager')->handlePageAttachments($attachments); }

    Now, what this means, is that for the attachments manager to be useful, we need metatag. If we do not have metatag, we do not even need this service. So basically, the service depends on metatag (as it uses the service metatag.manager), but the module does not (as it does not even need its own service if metatag is not installed).

    Now, there are several ways you could go about fixing this for a given project. Creating a new module that depends on metatag could be one way. But today, let's look at how we can make this service have an optional dependency on another service.

    At first the service definition looked like this:

    mymodule.attachments_manager: class: Drupal\mymodule\MyModuleAttachmentsManager arguments: ['@current_route_match', '@module_handler', '@metatag.manager', '@entity.repository']

    This would contruct a class instance of MyModuleAttachmentsManager with the following function signature:

    public function __construct(RouteMatchInterface $route_match, ModuleHandlerInterface $module_handler, MetatagManager $metatag_manager, EntityRepositoryInterface $entity_repo) { }

    Now, this could never work if this module was installed before metatag (which it very well could, since it does not depend on it). A solution then would be to make the metatag.manager service optional. Which is something we can do by removing it from the constructor and create a setter for it.

    public function __construct(RouteMatchInterface $route_match, ModuleHandlerInterface $module_handler, EntityRepositoryInterface $entity_repo) { // Constructor code. } /** * Set meta tag manager. * * @param \Drupal\metatag\MetatagManager $metatagManager * Meta tag manager. */ public function setMetatagManager(MetatagManager $metatagManager) { $this->metatagManager = $metatagManager; }

    OK, so far so good. It can now be constructed without having a MetaTagManager. But how do we communicate this in the service definition? Turns out the documentation for Symfony service container has the answer.

    When you define a service, you can specify calls to be made when creating the service, which would be ignored if the service does not exist. Like so:

    mymodule.attachments_manager: class: Drupal\mymodule\MyModuleAttachmentsManager arguments: ['@current_route_match', '@module_handler', '@entity.repository'] calls: - [setMetatagManager, ['@?metatag.manager']]

    So there we have it! The service can be instantiated without relying on the metatag.manager service. And if it is available in the service container, the method setMetatagManager will be called with the service, and our service will have it available in the cases where we need it.

    Now let's finish off with an animated gif related to "service container".