Forem: Micael Vinhas

Simple routing system for a PHP MVC application

Micael Vinhas — Tue, 16 Aug 2022 13:48:00 +0000

You don't want to use a framework and yet you want to get rid of messy URLs and complex routing systems? Maybe I have the solution for you.

Any PHP framework can handle extremely well the routing/dispatching system, but not everyone is interested in a framework to do their job. You came here because you want to do your own routing system, right? Come along, I'll show you my approach to this issue and who knows it will help you to get an ever effective way to do a proper routing system.

Understand what you need to grab to build your function call

There is a superglobal that will help you in this challenge: $_SERVER. Just like the PHP documentation says:

$_SERVER is an array containing information such as headers, paths, and script locations. The entries in this array are created by the web server. There is no guarantee that every web server will provide any of these; servers may omit some, or provide others not listed here.

https://www.php.net/manual/en/reserved.variables.server.php

PHP warns you about the potential absence of information, but the main one we will use, PATH_INFO, is very likely to be provided. Even if PATH_INFO is not there (for example, if no actual path is provided), we can create a default value, say '/'.

Without any further introduction, let's write some code!

**Warning: at the time of this writing I'm using PHP 8.1. Please note that the following code may or may not work in your environment, depending not only on the PHP version but also on your web server.

1. Get the URI

The first step is to create a function that simply grabs the URI and breaks it into many parts. These parts will represent the controller, method and method parameters (args).



private static function getURI() : array
{
    $path_info = $_SERVER['PATH_INFO'] ?? '/';
    return explode('/', $path_info);
}

So, for a URL like this:



http://www.example.com/posts/view/3

You will get:



$uri[0] = 'posts';
$uri[1] = 'view';
$uri[2] = '3';

Now you can already imagine a posts controller, with a method called view that receives as an argument post_id.

2. Process the getURI information

Let's build an object that returns the controller, method and args (if any):



private static function processURI() : array
{
    $controllerPart = self::getURI()[0] ?? '';
    $methodPart = self::getURI()[1] ?? '';
    $numParts = count(self::getURI());
    $argsPart = [];
    for ($i = 2; $i < $numParts; $i++) {
        $argsPart[] = self::getURI()[$i] ?? '';
    }

    //Let's create some defaults if the parts are not set
    $controller = !empty($controllerPart) ?
        '\Controllers\\'.$controllerPart.'Controller' :
        '\Controllers\HomeController';

    $method = !empty($methodPart) ?
        $methodPart :
        'index';

    $args = !empty($argsPart) ?
        $argsPart :
        [];

    return [
        'controller' => $controller,
        'method' => $method,
        'args' => $args
    ];
}

Bear in mind that you can simplify your use case and write everything on the same function since it's unlikely that we need to call getURI one more time. I'm separating both for Single-responsibility principle (SRP) purposes.

The controller used here is just an example, with a namespace Controllers. The common convention is Controllers\SomethingController, and I like it.

3. Create a function that wraps up and calls the appropriate controller, method and its arguments

This is the funniest part because you already made the dirty job of deconstructing the URI:



public static function contentToRender() : void
{
    $uri = self::processURI();
    if (class_exists($uri['controller'])) {
        $controller = $uri['controller'];
        $method = $uri['method'];
        $args = $uri['args'];
        //Now, the magic
        $args ? $controller::{$method}(...$args) :
            $controller::{$method}();
    }
}

(Those three dots before the $args array are called array unpacking. Basically, PHP will extract the array values and instantiate them as separate variables.)

But wait! What happened here?

Let's pick up again our previous example, but with an extra argument:



http://www.example.com/posts/view/3/excerpt

In this case, we have:

Controller: \Controllers\PostsController
Method: view()
Args: ('3', 'excerpt')

So, our call will be: \Controllers\PostsController::view('3', 'excerpt'). Essentially, the excerpt of the post with an id equal to '3'.

Very simple, yet effective. If no method is passed, we will assume index as our default method. But beware, the application will throw an error if you don't have any default method called index and you don't explicitly it either.

How can we call this?



Route::contentToRender();

This is assuming that we called the class Route. And please note that we are also assuming that our controller methods are static. If they are not static you have to make a little change to contentToRender() function.

Instead of:



$args ? $controller::{$method}(...$args) :
            $controller::{$method}();

You have to write:



$args ? (new $controller)->{$method}(...$args) :
        (new $controller)->{$method}();

I use static methods a lot and I know they are harder to test. Karma will kill me sooner or later for doing that.

Wrapping up, here is our class Route.php:



<?php

class Route

{

    public static function contentToRender() : void

    {

        $uri = self::processURI();

        if (class_exists($uri['controller'])) {

            $controller = $uri['controller'];

            $method = $uri['method'];

            $args = $uri['args'];

            //Now, the magic

            $args ? $controller::{$method}(...$args) :

                $controller::{$method}();

        }

    }

private static function getURI() : array
{
    $path_info = $_SERVER['PATH_INFO'] ?? '/';
    return explode('/', $path_info);
}

private static function processURI() : array
{
    $controllerPart = self::getURI()[0] ?? '';
    $methodPart = self::getURI()[1] ?? '';
    $numParts = count(self::getURI());
    $argsPart = [];
    for ($i = 2; $i &lt; $numParts; $i++) {
        $argsPart[] = self::getURI()[$i] ?? '';
    }

    //Let's create some defaults if the parts are not set
    $controller = !empty($controllerPart) ?
    '\Controllers\\'.$controllerPart.'Controller' :
    '\Controllers\HomeController';

    $method = !empty($methodPart) ?
        $methodPart :
        'index';

    $args = !empty($argsPart) ?
        $argsPart :
        [];

    return [
        'controller' =&gt; $controller,
        'method' =&gt; $method,
        'args' =&gt; $args
    ];
}



}

Do you have another way to make this?

I'm pretty sure you do! I'm always into cleaner and shorter code, so if you have any proposals to improve this approach, please let us know in the comments. That way, we, PHP fanboys, can get the PHP awesomeness bar even higher!

Have a great day!

Write your first QueryBuilder with PDO and PHP

Micael Vinhas — Tue, 16 Aug 2022 13:47:00 +0000

Take this article as storytelling, where you start with the very basics and then improve your code as you move on.

Grab a cup of coffee if you didn't do it already.

Understand the importance of writing cleaner queries

Writing the raw SQL is not necessarily hard or inconvenient most of the time, but as soon as your application takes off and goes big, you will have a bunch of long strings with SQL code that simply does not go along with the other PHP code.

Writing a query builder makes the code much more seamless and readable. Also, you will be less error-prone, because the query building will prepare the query in a consistent way.

In this article, we will approach SELECT statements.

SELECT statements

By the end of this article, your application should run the following query

SELECT customers.id FROM customers LEFT JOIN persons ON customers.person_id = persons.id WHERE customers.name = 'David' AND persons.id = 1 LIMIT 1

With this code

(new Select('customers.id'))
->from('customers LEFT JOIN persons')
->on(['customers.person_id','=','persons.id'])
->where(['customers.name', '=', '"David"'])
->limit(1)->fetch()

But first, we will cover something much more basic

SELECT * FROM customers WHERE name = 'David' LIMIT 5;

With this

(new Select)->from('customers')->where(['name', '=', 'David'])->limit(5)

Looking at the above code, we already know a couple of things:

We have a class called Select
The class has, at least, three methods. They are from, where and limit
One method should be responsible to make the query. Let's call it fetch

This is enough to write the base class:

class Select
{
    public function from(string $table) {}
    public function where(array $condition) {}
    public function limit(int $limit = 1) {}
    public function fetch() {}
}

Looking great, but we are not making any actual query, we are only writing the SQL statement. Making the query itself obliges us to create a PDO Connection (for example).

If we create this initialization code on the Select class, we have to do it over and over again for any other database operation, like insert or update. So, let's create another class called Db and extend it on Select.

<?php

use PDO;
use PDOException;

class Db
{
    public static function initialize()
    {
        try {
            return new PDO(
                'mysql:host=localhost;dbname=db',
                'user',
                'password'
            );
        } catch (PDOException $e) {
            die("Could not connect to the database: $e");
        }
    }

}

<?php

class Select extends Db
{
    public function from(string $table) {}
    public function where(array $condition) {}
    public function limit(int $limit = 1) {}
    public function fetch() {}
}

A good basis to work with.

Now, we need to create three variables: $from, $where, and $limit. These variables will save the different parts of the query we want to do. There are many more for a SELECT query, but it's wise to start with the basics and then work our way up to create more complex queries.

public $from;
public $where;
public $limit;

All declarations are set, time to fill the methods with code

public function from(string $table)
{
    $this->from = "SELECT * FROM $table";
    return $this;
}

public function where(array $condition)
{
    $this->where = "WHERE $condition[0] $condition[1] $condition[2]";
    return $this;
}

public function limit(int $limit = 0)
{
    $this->limit = "LIMIT $limit";
    return $this->fetch();
}

public function fetch()
{
    $sql = implode(' ', (array)$this);
    $db = self::initialize();
    $db->beginTransaction();
    $query = $db->prepare($sql);
    $db->commit();
    $query->execute();
    return $query->fetchAll(PDO::FETCH_OBJ);
}

Finally, a call on index.php

<?php

require_once 'Select.php';
require_once 'Db.php';

$query = (new Select)->from('customers')->where(['name', '=', 'David'])->limit(5);

echo "<pre>";print_r($query);"</pre>";

To get something like this:

Array
(
    [0] => stdClass Object
        (
            [id] => 3
            [name] => David
        )

    [1] => stdClass Object
        (
            [id] => 4
            [name] => David
        )

)

We have the foundations, but our code is too basic right now. We cannot select a particular field, or make multiple wheres, aside from other constraints.

I have a couple of ideas to make our Select class richer and more featureful. Use the comments section to throw some more ideas.

Select particular fields
Multiple wheres
Joins
Discard the mandatory use of limit

Select particular fields

In the above example, we already know that the name we want to query is David, so grabbing the id only should be enough.

This is the query we want to make:

SELECT id FROM customers WHERE name = 'David' LIMIT 5

And here is a potential approach:

(new Select('id'))->from('customers')->where(['name','=','"David"'])->limit(5);

We are passing id as a parameter of the class, so we need to implement this code on the constructor.

(Don't feel lost. I will paste the complete code at the end of this article.)

On class Select.php:

public $fields;

public function __construct(string $fields = '*')
{
    $this->fields = "SELECT $fields";
}

Since the constructor is now responsible to start the query, we have to adapt our from function.

public function from(string $table) {
    $this->from = $table;
    return $this;
}

The rest stays exactly the same, and here is the produced result:

Array
(
    [0] => stdClass Object
        (
            [id] => 3
        )

    [1] => stdClass Object
        (
            [id] => 4
        )

)

Which is exactly want we want.

Moving on.

Multiple wheres

You may have noticed that we are passing a unidimensional array to the where function. So, for the following query...

SELECT * FROM customers WHERE name = 'David' AND id = '3' LIMIT 1

...how can we write the query builder to accommodate two clauses on where?

There are a couple of possible solutions, but, I like the CodeIgniter way:

(new Select)
->from('customers')
->where(['name','=','"David"'],'AND',['id','=','3'])
->limit(1);

This is not 100% equal to how CodeIgniter implements their where function, but for this article, I think it's the most comprehensive way.

We need to use array unpacking because we don't know the number of parameters needed. You may only need to use one clause, or twenty.

Let's try to make it work:

public function where(...$conditions)
{
    $where[] = 'WHERE';
    foreach ($conditions as $condition) {
        $where[] =
            is_array($condition) ?
            implode(' ', $condition) :
            $condition;
    }
    $this->where = implode(' ', $where);
    return $this;
}

Joins

Joins are very useful and usually help us to get everything we want on a single query.

They will also bring more complexity to our code, but not that much.

For the following query:

SELECT customers.id FROM customers LEFT JOIN persons ON customers.person_id = persons.id WHERE customers.name = 'David' AND persons.id = 1 LIMIT 1

Our query builder can look like this:

(new Select('customers.id'))
->from('customers LEFT JOIN persons')
->on(['customers.person_id','=','persons.id'])
->where(['customers.name', '=', '"David"'])
->limit(1);

Look at the new function, on. Notice something familiar? Yes, it is very similar to where, so why don't we reuse some code?

public $on;

public function where($conditions)
{
    $this->where = $this->clause('WHERE', $conditions);
    return $this;
}

public function on($conditions)
{
    $this->on = $this->clause('ON', $conditions);
    return $this;
}

public function clause(string $prefix, ...$conditions)
{
    $array[] = $prefix;
    foreach ($conditions as $condition) {
        $array[] = is_array($condition) ?
            implode(' ', $condition) :
            $condition;
    }
    return implode(' ', $array);
}

One more step and we are done!

Discard the mandatory use of limit

If we don't call limit, our query will not be done, ever. This is because we request the fetch on the limit function, which is not ideal.

Why complicate? The solution is in the front of our eyes. We already have a class called fetch, so why don't we call it?

(new Select('customers.id'))
->from('customers LEFT JOIN persons')
->on(['customers.person_id','=','persons.id'])
->where(['customers.name', '=', '"David"'])
->limit(1)->fetch();

You only need to make a tiny change on the limit function, because we don't want to call fetch from there anymore:

public function limit(int $limit = 1) {
    $this->limit = "LIMIT $limit";
    return $this;
}

Bonus: orderBy

Since we are using LIMIT 1, there is no need to use ORDER BY, but you may need it in the future.

The solution is very similar to the limit function, except in this case we have to accept two parameters:

public function orderBy(string $field = '', string $order = 'ASC')
{
    if (empty($field)) return $this;
    $this->orderBy = "ORDER BY $field $order";
    return $this;
}

Wrapping up

To see this query builder in action, create three files: index.php, Db.php, and Select.php, and then paste the following code:

Db.php

<?php
use PDO;
use PDOException;

class Db
{
    public static function initialize()
    {
        try {
            return new PDO(
                'mysql:host=localhost;dbname=db',
                'user',
                'password'
            );
        } catch (PDOException $e) {
            die("Could not connect to the database: $e");
        }
    }

}

Select.php

<?php

require_once 'Db.php';

class Select extends Db
{
    //Declare the variables in this order
    public $fields;
    public $from;
    public $on;
    public $where;
    public $orderBy;
    public $limit;

    public function __construct(string $fields = '*')
    {
        $this->fields = "SELECT $fields";
    }

    public function from(string $table) {
        $this->from = "FROM $table";
        return $this;
    }

    public function where($conditions)
    {
        $this->where = $this->clause('WHERE', $conditions);
        return $this;
    }

    public function on($conditions)
    {
        $this->on = $this->clause('ON', $conditions);
        return $this;
    }

    public function clause(string $prefix, ...$conditions) : string
    {
        $array[] = $prefix;
        foreach ($conditions as $condition) {
            $array[] = is_array($condition) ?
                implode(' ', $condition) :
                $condition;
        }
        return implode(' ', $array);
    }

    public function orderBy(string $field = '', string $order = 'ASC')
    {
        if (empty($field)) return $this;
        $this->orderBy = "ORDER BY $field $order";
        return $this;
    }

    public function limit(int $limit = 1) {
        $this->limit = "LIMIT $limit";
        return $this;
    }

    public function fetch() {
       $sql = implode(' ', (array)$this);
       $db = self::initialize();
       $db->beginTransaction();
       $query = $db->prepare($sql);
       $db->commit();
       $query->execute();
       return $query->fetchAll(PDO::FETCH_OBJ);
    }
}

index.php

<?php

require_once 'Select.php';
require_once 'Db.php';

$query = (new Select('customers.id'))
->from('customers LEFT JOIN persons')
->on(['customers.person_id','=','persons.id'])
->where(['customers.name', '=', '"David"'])
->limit(1)->fetch();

echo "<pre>";print_r($query);"</pre>";

Remember to create the tables customers and persons, and, of course, the proper database (in this example: db). Change the code to suit your data if you want.

Looking for our GitHub repository? Here it is!

Further steps?

There are always things to improve. For example, we can create some error messages to bring more feedback to the user when something is not ok.

And many more things, like subqueries and unions. If you think that it's a good idea to fill our class with more functionality, let me know in the comments.

Stay tuned!

PHP MVC: the easy way

Micael Vinhas — Tue, 16 Aug 2022 13:46:43 +0000

Get to know MVC better and learn why it's so great.

Tired of getting confused about how to structure your application? You start small and simple but suddenly you have a bunch of files organized almost randomly? You are not alone, and you are not facing a minor problem. An organized application improves code maintainability and reusability and helps other people to cooperate with you.

In the old times, the usual way of writing applications was by using procedures and global states. We used to write everything on the same file: Infrastructure, Presentation, UI, you name it. Over time, the files got bigger and bigger and we struggled to know where the database operations start and where the UI ends.

This is where a Separation of Concerns (SoC) comes in handy. By splitting up concepts, the code gets more organized, and you can take it to the next level by creating layers for each concern. You can either find your own way to structure the application or use a proven pattern, like MVC.

MVC stands for Model-View-Controller. This is a layered architecture, which means that the main goal is to separate different components of an application. There are many more, such as MVVM (Model-view-viewmodel), but this is the most common one. Almost every famous PHP framework uses it by now (Symfony, Yii, Laravel, and CodeIgniter to give some examples).

By definition, MVC is a paradigm that divides the application into three layers: Model, View, and Controller.

A simple MVC diagram as found on Wikipedia

When writing a form, you are essentially dealing with the three layers. Writing is interacting with the View. Clicking on Save is sending instructions to the Controller, so it can tell the Model to save your data.

Some examples will be provided as we explain the three layers more deeply.

The Model

This layer is responsible to handle all the data. Every action that the user triggers on the application requires some sort of operation on the database. Someone should be responsible to ask the database to change it, and that will be the Model.



<?php

namespace Cv\Models;

use Cv\Db;

class Resume
{
    public static function getSections()
    {
        return Db::select(['*'], 'resume_sections');
    }

    public static function getEntries($section)
    {
        return Db::select(
            ['*'],
            'resume_section_entries',
            ['section_id = '.$section->id]
        );
    }
}

There are a couple of extra things worth noting: we are assuming that a class called Db exists and handles querying the database. In that database, two tables, resume_sections, and resume_section_entries, represent an entire Resume: resume_sections divide the Resume and resume_section_entries describe each Resume section.

The View

This layer handles what you see on your screen. It can communicate with both Model and Controller, and its main purpose is to give Model some sort of UI. Think of it as a representation of data for human interaction.

View: Resume/index.php



<div class="container">
    <?php foreach ($data ?? (object)[] as $section) : ?>
        <section class="resume" id="<?= trim(strtolower($section->title),' ') ?>">
            <div class="resume-content">
                <h2 class="mb-3"><?= $section->title ?></h2>
                <?php foreach ($section->entries ?? (object)[] as $entry) : ?>
                <div class="mb-3 content">
                    <div class="content-body">
                        <h3><?= $entry->position ?></h3>
                        <div class="subhead mb-1"><?= $entry->at ?></div>
                        <p><?= $entry->description ?></p>
                    </div>
                    <div class="content-footer">
                        <?= $entry->from ?> - <?= $entry->to ?? 'Present' ?>
                    </div>
                </div>
                <?php endforeach; ?>
            </div>
        </section>
        <hr class="m-0">
    <?php endforeach; ?>
</div>

Nothing fancy here. The view is expecting a $data object to fill the resume on the frontend.

There is one issue, though. You should separate at all costs PHP from HTML, but this is only achievable with a template engine like Twig. Since we don't want to introduce more concepts here, let's keep Twig out of our examples. We will get back to it in another post.

The Controller

The Controller handles organizing and adapting both View and Model. It can receive data from the View and tell the Model what to do, and also it can receive data from the Model and arrange it so it can be comprehended by the user when interacting with the View.

Controller: ResumeController.php



<?php

namespace Cv\Controllers;

use Cv\Models\Resume;

class ResumeController extends Controller
{
    public static function index()
    {
        $sections = Resume::getSections();
        foreach ($sections as &$section) {
            $section->entries =
                Resume::getEntries($section);
        }
        return self::view($sections);
    }
}

In this controller, self::view is responsible to call the view and pass *$section*s on it.

But where is the view function?

Perhaps you already noticed that this controller extends Controller. When extending another class, you are inheriting any methods of that class that are not private, and you can use them if you like.

Let's get to know this Controller to get a grasp of what we are doing here.

Main Controller: Controller.php



<?php

namespace Cv\Controllers;

class Controller
{
    public static function view(object $data = null)
    {
        include __DIR__.
            '/../Views/'.
            self::path().
            '/'.
            self::file();
    }

    private static function path() : string
    {
        return str_replace(
            'Controller.php',
            '',
            end(
                explode(
                    '/',
                    debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]['file']
                )
            )
        );
    }

    private static function file() : string
    {
        return debug_backtrace(
            DEBUG_BACKTRACE_IGNORE_ARGS, 3)[2]['function'].'.php';
    }
}

This code itself is not essential to understanding this paradigm, but this way you get a rough idea of how a simple MVC application should work.

Naming conventions

You should create separate folders for different layers. In this case, Views, Models, and Controllers.

In the Models folder, every class file should be named by its section. For example Home.php for the homepage-related stuff, Resume.php for everything related to the resume, and so on.

In the Controllers folder, you should give the classes a similar name to the model classes, but with "Controller" suffix. For example, HomeController.php. Mind that nothing here is mandatory, just a few common practices.

The view name should match the controller method. So, if you are writing a function called index for the HomeController, the view should be Views/Home/index.php. This is a great way to understand what that particular View is about. Also, if you need to change its behavior, you already know what method you should change.

Finally, the application directories should look like this:



App/
    Models/
        Home.php
        Site.php
        Resume.php
    Controllers/
        HomeController.php
        SiteController.php
        ResumeController.php
    Views/
        Home/
            index.php
        Site/
            index.php
            about.php
        Resume/
            index.php
            edit.php
            delete.php

Now, a question. Looking at the above folder structure and respective files, how many methods do ResumeController.php have, and how are they called?

Final thoughts

This type of layered architecture is one of the most used because it's also easier to understand. Once you get used to it, you want to write all your applications using MVC patterns because they will look much more polished and organized. Other types of layered architecture have their merits but MVC represents a great foundation to write better software.

If you have any further questions please let me and readers know by using the comment section.

Further reading: Domain-Driven Design in PHP -- you can get here some MVC examples on the Chapter 2: Architectural Styles.

4 great plugins to improve your Wordpress website performance

Micael Vinhas — Tue, 22 Mar 2022 16:51:30 +0000

I created a website called Poupa Pilim (portuguese), which is image heavy since this is mostly supermarket flyers.

Because of that, and since some posts are really huge, I had to research for some plugins to improve my website performance, which made this beauty score:

So, let me show you what they are:

1. Bunny CDN

This is a great CDN, with servers all around the world. Ultra cheap, only 0,01$ per GB of bandwith!

2. The SEO Framework

You probably know Yoast, but The SEO Framework is more lightweight, simple, unbranded and extremely clear SEO solution.

3. WP Rocket

I bet you already came across with WP Rocket. It is just too great and completely worth the price you pay for it. I use it to minify CSS and JS, defer Javascript and delay Javascript execution, and also to preload fonts and links.

4. WP-Optimize - Clean, Compress, Cache

When you install and uninstall plugins, some junk just stays on the database. WP-Optimize will remove that junk and also will optimize your tables. It's free to use.

On top of this, I make sure that I'm running the latest PHP version (currently PHP 8.1) with some extensions, like APCu and OPCache.

Also, if your server supports that, enable HTTP2, Deflate and Brotli to get the best performance of your site.

Have fun!

How to: Apache Userdir with SELinux installed

Micael Vinhas — Sat, 08 Sep 2018 17:27:19 +0000

One of the first struggles I had when I started using Fedora as my Linux production environment was to be able to use my /home folder with Apache and SELinux. Initially I had the habit of linking content from home to /var/www/html, and then accessing via browser to my projects.

It turns out that, with SELinux, that’s not an easy task. SELinux’s access control policies, by default, do not allow access to the /home contents, showing the HTTP 403 Forbidden error. I did a lot of searching over the Internet and I was absolutely silly by the amount of responses that suggested that SELinux should be disabled or put in permissive mode. Disabling things is not a thing I like to do, especially when those things are actually important.

According to the NSA Security-enhanced Linux Team:

NSA Security-Enhanced Linux is a set of patches to the Linux kernel and utilities to provide a strong, flexible, mandatory access control (MAC) architecture into the major subsystems of the kernel. It provides an enhanced mechanism to enforce the separation of information based on confidentiality and integrity requirements, which allows threats of tampering, and bypassing of application security mechanisms, to be addressed and enables the confinement of damage that can be caused by malicious or flawed applications. It includes a set of sample security policy configuration files designed to meet common, general-purpose security goals.

That is, its use helps reduce the likelihood that programs will cause an unwanted behavior on the system, especially if they already have a defect that would allow someone to gain unauthorized access to any part of the system.

For those who, like me, like to have their projects in their home directory and still want to access these via Apache, how should they proceed? Based on my research, I will introduce you the one that for me is the best solution, and that does not have major security implications.

NOTE: The process that I’m going to show you was only tested on Fedora 28, but due to the similarities, should work on previous Fedora version as well on Red Hat Linux Enterprise 7.5 and CentOS 7.5.

Enable Apache UserDir

This way we can access a specific directory of our /home as our projects directory. Usually it can be accessed as follows:
http://localhost/~user

1. Edit userdir.conf file

sudo vim /etc/httpd/conf.d/userdir.conf

Now enable UserDir and specify the folder you want to give access to.

NOTE: for this tutorial I will use user mvinhas and folder workspace.



<IfModule mod_userdir.c>
 #
 # UserDir is disabled by default since it can confirm the presence
 # of a username on the system (depending on home directory
 # permissions).
 #
 UserDir enabled mvinhas
#
 # To enable requests to /~user/ to serve the user’s public_html
 # directory, remove the “UserDir disabled” line above, and uncomment
 # the following line instead:
 #
 UserDir workspace
</IfModule>
<Directory /home/*/workspace>
 AllowOverride FileInfo AuthConfig Limit Indexes
 Options MultiViews Indexes SymLinksIfOwnerMatch IncludesNoExec
 Require method GET POST OPTIONS
</Directory>

This will enable UserDir to all users on your computer.

If you want to specify the users you show keep UserDir disabled and then enable it to the users you want:

UserDir disabled UserDir enabled mvinhas user1 user2

Note that you can do the opposite, ie. enable UserDir and then deny access to some users:

UserDir enabled UserDir disabled mvinhas test1

2. Restart Apache
sudo systemctl start httpd.service

3. Change folder permissions to your folder and /home directory
chmod 711 /home/mvinhas sudo chown mvinhas:mvinhas /home/mvinhas/workspace chmod 755 /home/mvinhas/workspace

4. Adjust SELinux to enable Apache homedirs
sudo setsebool -P httpd_enable_homedirs true sudo chcon -R -t httpd_sys_content_t /home/mvinhas/workspace

Now you should be able to use your folder with SELinux enabled!

You can see the folder and file SELinux context by doing ls -Z in the terminal. You can also combine -Z with the traditional -la argument, so you can see both SELinux policy and traditional file/folder permissions:

As you can see, I checked the SELinux status first, showing me that SELinux is in Enforcing mode, the default and recommended mode.

That’s it. If you have any questions, feel free to ask!