Codice: obsługa migracji baz danych dla wtyczek

W poprzednim wpisie przedstawiłem zarys głównego API stojącego za obsługą rozszerzeń w Codice. Nie jest to oczywiście całość systemu, wtyczki poza integracją ze rdzeniem za pomocą akcji i filtrów muszą mieć zapewnione inne możliwości, pozwalające na swobodne operowanie. Jedną z bardziej istotnych jest wpływ na strukturę bazy danych.

W większości nowoczesnych frameworków dzieje się to za pomocą migracji, czyli opisanych w ustalony wcześniej sposób procedur kolejnych zmian w bazie danych. Dotyczy to dodawania, usuwania a także modyfikowania kolumn lub całych tabel. Przy instalacji aplikacji (także Codice) wszystkie migracje są wykonywane w kolejności ich definiowania - zapewnia to między innymi bardzo pożądaną możliwość wersjonowania struktury bazy danych.

Po tym opisie widać już że bardzo wskazane byłoby posiadanie analogicznego mechanizmu dla wtyczek. Ponieważ migracje powinno definiować się dwustronnie, można założyć że będą one aplikowane przy instalacji wtyczki, a wszelkie wprowadzone do struktury bazy zmiany będą cofane przy deinstalacji rozszerzenia (owa "druga strona" migracji).

By osiągnąć założone cele nie będziemy tworzyć zupełnie autorskiego systemu. Wszakże Laravel posiada już niemal identyczny mechanizm - brakuje tylko możliwości przypisania każdej z migracji konkretnej wtyczki. Pierwotnie próbowałem osiągnąć to za pomocą parametrów przekazywanych do komendy artisan migrate. Dokumentacja wspomina bowiem o opcji --path, pozwalającej na wykonanie migracji ograniczonych do jednej lokalizacji w systemie plików. Okazuje się jednak że w ten sposób nie możemy odwrócić migracji. Zdecydowałem się więc na rozszerzenie domyślnego repozytorium (w rozumieniu architektury aplikacji obiektowych) migracji o potrzebne wymagania.

<?php

namespace CodicePlugins;

use IlluminateDatabaseConnectionResolverInterface as Resolver;
use IlluminateDatabaseMigrationsDatabaseMigrationRepository;
use IlluminateDatabaseMigrationsMigrationRepositoryInterface;

class MigrationRepository extends DatabaseMigrationRepository implements MigrationRepositoryInterface
{
    protected $plugin;

    /**
     * Create a new database migration repository instance.
     *
     * @param  IlluminateDatabaseConnectionResolverInterface  $resolver
     * @param  string  $plugin  Unique application-wide plugin identifier
     */
    public function __construct(Resolver $resolver, $plugin)
    {
        $this->resolver = $resolver;
        $this->plugin = $plugin;
        $this->table = 'migrations_plugins';

        parent::__construct($resolver, $this->table);
    }

    /**
     * Get the ran migrations.
     *
     * @return array
     */
    public function getRan()
    {
        return $this->table()
            ->where('plugin', $this->plugin)
            ->orderBy('batch', 'asc')
            ->orderBy('migration', 'asc')
            ->pluck('migration')->all();
    }

    /**
     * Get list of migrations.
     *
     * @param  int  $steps
     * @return array
     */
    public function getMigrations($steps)
    {
        $query = $this->table()
            ->where('plugin', $this->plugin)
            ->where('batch', '>=', '1');

        return $query->orderBy('migration', 'desc')->take($steps)->get()->all();
    }

    /**
     * Get the last migration batch.
     *
     * @return array
     */
    public function getLast()
    {
        $query = $this->table()
            ->where('plugin', $this->plugin)
            ->where('batch', $this->getLastBatchNumber());

        return $query->orderBy('migration', 'desc')->get()->all();
    }

    /**
     * Log that a migration was run.
     *
     * @param  string  $file
     * @param  int     $batch
     * @return void
     */
    public function log($file, $batch)
    {
        $record = ['plugin' => $this->plugin, 'migration' => $file, 'batch' => $batch];

        $this->table()->insert($record);
    }

    /**
     * Remove a migration from the log.
     *
     * @param  object  $migration
     * @return void
     */
    public function delete($migration)
    {
        $this->table()->where('migration', $migration->migration)->delete();
    }

    /**
     * Create the migration repository data store.
     *
     * @return void
     */
    public function createRepository()
    {
        $schema = $this->getConnection()->getSchemaBuilder();

        $schema->create($this->table, function ($table) {
            $table->increments('id');
            $table->string('plugin');
            $table->string('migration');
            $table->integer('batch');
        });
    }
}

Nadpisywane są wyłącznie niektóre metody, dokładnie tak aby po przekazaniu do konstruktora klasy identyfikatora danej wtyczki, wykonywać operacje na powiązanych z nią migracjach. Ich wywoływanie przebiega niemal analogicznie do klasycznych migracji wbudowanych w Laravela, informacji zasięgnąłem oczywiście buszując w jego źródłach (i zdecydowanie polecam to rozwiązanie, Larwę za wiele rzeczy można słusznie skrytykować, ale w kodzie naprawdę łatwo się połapać).

// ...

// Metoda pomocnicza.
// Używamy wbudowanego migratora, przekazujemy jedynie własne repozytorium.
protected function prepareMigrator($identifier)
{
    $repository = new MigrationRepository($this->app['db'], $identifier);

    if (!$repository->repositoryExists()) {
        $repository->createRepository();
    }

    return new Migrator($repository, $this->app['db'], $this->app['files']);
}

// ...

// Przy instalacji wtyczki
$migrator = self::prepareMigrator($identifier);
$migrator->run([$plugin->path('migrations')]);

// I analogicznie przy jej odinstalowywaniu
$migrator = self::prepareMigrator($identifier);
$migrator->rollback([$plugin->path('migrations')]);

Jak widać jest to naprawdę nieskomplikowane zadanie. Nie dajcie się zmylić ilości kodu, większość z niego to delikatnie zmodyfikowane metody klasy rodzica. Co ważniejsze, kryje się za tym życiowa lekcja.

Nie wynajduj koła od nowa, zwłaszcza jeśli masz już cały zestaw narzędzi w postaci frameworka. Poświęć chwilę na zgłębienie jego działania, zaoszczędzisz wiele czasu i bólu głowy.

~Sobak, gdzieś w tym momencie

Pozdrawiam!


Powyższy wpis przedstawia część doświadczeń zdobytych przy tworzeniu projektu Codice. Po więcej szczegółów zapraszam do pierwszego wpisu oraz na codice.eu. Poza planowaną od dawna serią jest to też realizacja wymogów konkursu "Daj Się Poznać". Więcej o nim możecie przeczytać w tym wpisie. Po nowe materiały poświęcone tworzeniu projektu Codice zapraszam w każdy wtorek. Ponadto więcej wpisów, poświęconych temu projektowi lub ogólnej tematyce bloga przeczytacie co sobotę. Miejmy nadzieję, że tym razem już zgodnie z harmonogramem!

Codice: system wtyczek

Jednym z kluczowych elementów, nad którym pracowałem (i nadal pracuję) przy tworzeniu Codice jest wbudowana obsługa dla rozszerzeń. Zagadnienie, na którym nie raz zjadałem sobie zęby lub, co jeszcze gorsze, cierpiałem przez odkładanie jego implementacji na wieczne nigdy. Do dziś po dysku wala mi się jakaś wczesna wersja Codice... w bodajże 3 odmianach, różniąch się drobnymi detalami. Niby drobiazg, ale nie chcę nawet zaczynać opisywania tego, jak męczące jest równoległe utrzymanie każdego z wariantów.

Skoro próbowałem już tak wiele razy i obecne podejście do Codice miało być wreszcie tym właściwym, musiałem wreszcie zmierzyć się z tym zagadnieniem. Jednocześnie musiałem dopuścić do głosu nieco pragmatyzmu i wybrać podejście, które będzie adekwatne do mojego doświadczenia w tym temacie i na którym, mówiąc wprost, nie polegnę po raz kolejny.

W tym wpisie przedstawię najbardziej podstawowe elementy systemu wtyczek w moim projekcie, mianowicie akcje i filtry. Wielu z Was zapewne zna ten koncept z innych aplikacji (na przykład WordPressa). Wszystko opiera się na zdefiniowanych w rdzeniu hookach, do których możemy podpiąć własne zdarzenia po to, by wykonały się w określonej sytuacji. Pierwszy z brzegu przykład: rejestrujemy akcję dodającą wiadomość powitalną dla zdarzenia (hooka) user.created - utworzenia nowego użytkownika.

Innym sposobem rozszerzalności mogą być filtry - ponownie, zdefiniowane w rdzeniu miejsca, w których istotne wartości możemy później modyfikować (filtrować) za pomocą podpiętych callbacków. W przypadku Codice jest to między innymi zapytanie używane przy wyszukiwaniu notatek. Wszystko z myślą o wtyczkach, które chciałyby je zmienić np. tak aby wykorzystywało inne pola lub też wyszukiwanie pełnotekstowe z MySQL.

Nie będę więcej przedłużał, przejdę do prezentowania stojącego za tym kodu. Jeśli jakiś koncept wciąż nie jest jasny, nie martwcie się, na samym końcu zalinkuję do testów dla tej części kodu, wydaje mi się, że one powinny idealnie zobrazować zamysł i planowany sposób ich wykorzystania.

<?php

namespace CodiceSupportTraits;

use Exception;
use Log;

trait Hookable
{
    /**
     * @var array Holds all currently registered hookables
     */
    protected static $hookables;

    /**
     * Register new hookable for given hook.
     *
     * @param string $hook Name of the hook
     * @param string $hookableName Name of the hookable, must be unique within a hookable of given type
     * @param callable $callable Callable containing code to run
     * @param int $priority Order of calling hookables, when priority is equal order is undefined
     * @return bool
     */
    public static function register($hook, $hookableName, callable $callable, $priority = 10)
    {
        $hookableType = self::getHookableType();

        if (self::isRegistered($hook, $hookableName)) {
            Log::warning("$hookableType '$hookableName' was already registered within '$hook' hook and has been overwritten.");
        }

        self::$hookables[$hook][$hookableName] = [
            'priority' => $priority,
            'callable' => $callable,
        ];

        return true;
    }

    /**
     * Check whether hookable of given name has been registered within a specified hook.
     *
     * @param string $hook Name of the hook
     * @param string $hookableName Name of the hookable within a hook
     * @return bool
     */
    public static function isRegistered($hook, $hookableName)
    {
        return isset(self::$hookables[$hook][$hookableName]);
    }

    /**
     * Deregister hookable from given hook.
     *
     * Deregistration must happen before call() method is run to have an effect.
     *
     * @param string $hook Name of the hook
     * @param string $hookableName Name of the hookable
     * @return bool
     */
    public static function deregister($hook, $hookableName)
    {
        unset(self::$hookables[$hook][$hookableName]);

        return true;
    }

    /**
     * Get (sorted) list of all hookables assigned to a hook.
     *
     * @param string $hook Name of the hook
     * @return array
     */
    private static function getHookables($hook)
    {
        $hookables = isset(self::$hookables[$hook]) ? self::$hookables[$hook] : [];

        return self::sortHookables($hookables);
    }

    /**
     * Sort hookables by their priority.
     *
     * @param array $hookables Array of unsorted hookables
     * @return array
     */
    protected static function sortHookables($hookables)
    {
        usort($hookables, function ($a, $b) {
            if ($a['priority'] == $b['priority']) {
                return 0;
            }

            return $a['priority'] < $b['priority'] ? -1 : 1;
        });

        return $hookables;
    }

    /**
     * Return human readable name of hookable
     *
     * @throws Exception
     * @return string
     */
    protected static function getHookableType()
    {
        throw new Exception('getHookableType() must be implemented');
    }
}

Zaczynamy od... traita? Dokładnie tak. Ponieważ główną różnicą między akcjami a filtrami jest to, że pierwsze nie mogą zwracać wartości, a drugie muszą to robić, możemy śmiało stwierdzić że spora część kodu będzie się powtarzać. Dlatego też wszystkie wspólne funkcjonalności, takie jak rejestrowanie konkretnych zdarzeń, wywoływanie ich czy potrzebne w obu wypadkach metody pomocnicze zostały umieszone w jednym miejscu, jak pokazano wyżej.

Jak sami zobaczycie, dzięki temu kod odpowiedzialny za działanie akcji i filtrów będzie naprawdę krótki i prosty. Jest to kolejno:

<?php

namespace CodicePlugins;

use CodiceSupportTraitsHookable;

class Action
{
    use Hookable;

    /**
     * Call all actions registered for a given hook.
     *
     * @param string $hook Name of the hook
     * @param array $parameters Parameters which will be passed to callback
     */
    public static function call($hook, array $parameters = [])
    {
        $actions = self::getHookables($hook);

        foreach ($actions as $action) {
            call_user_func($action['callable'], $parameters);
        }
    }

    /**
     * @inheritdoc
     */
    protected static function getHookableType()
    {
        return 'Action';
    }
}

oraz

<?php

namespace CodicePlugins;

use CodiceSupportTraitsHookable;

class Filter
{
    use Hookable;

    /**
     * Call all filters registered for a given hook.
     *
     * @param string $hook Name of the hook
     * @param mixed $value Value to run filters on
     * @param array $parameters Parameters which will be passed to callback
     * @return mixed Filtered value
     */
    public static function call($hook, $value, array $parameters = [])
    {
        $filters = self::getHookables($hook);

        foreach ($filters as $filter) {
            $value = call_user_func($filter['callable'], $value, $parameters);
        }

        return $value;
    }

    /**
     * @inheritdoc
     */
    protected static function getHookableType()
    {
        return 'Filter';
    }
}

Jak na dłoni widać teraz różnice w działaniu obu hookowalnych (zaczepialnych?) elementów. Tak więc raz jeszcze - w obu wypadkach wykonujemy wszystkie zarejestrowane (przez pluginy bądź samą aplikację) zdarzenia, czyniąc to według określonego priorytetu. Akcje po prostu wykonują kod, a filtry kolejno modyfikują przekazaną wartość.

Jak już mówiłem, najszybszym sposobem na zobaczenie ich w akcji jest spojrzenie na testy - osobno dla akcji oraz filtrów. Przykłady użycia podstawowego API do wtyczek przez samą aplikację znajdują się tutaj, nazwy plików powinny być raczej jasne ;)


Powyższy wpis przedstawia część doświadczeń zdobytych przy tworzeniu projektu Codice. Po więcej szczegółów zapraszam do pierwszego wpisu oraz na codice.eu. Poza planowaną od dawna serią jest to też realizacja wymogów konkursu "Daj Się Poznać". Więcej o nim możecie przeczytać w tym wpisie. Po nowe materiały poświęcone tworzeniu projektu Codice zapraszam w każdy wtorek. Ponadto więcej wpisów, poświęconych temu projektowi lub ogólnej tematyce bloga przeczytacie co sobotę. Miejmy nadzieję, że tym razem już zgodnie z harmonogramem!

Codice: weryfikacja właściciela zasobu (uprawnień użytkownika)

Z kilku przyczyn delikatnie rozjechał mi się harmonogram cotygodniowy, ale czas nadrobić straty. Poprzednio opisywałem doświadczenia zebrane podczas projektowania procesu instalacji dla Codice. Zajmiemy się teraz kolejnym zagadnieniem, które mimo iż oparte na przykładzie tego konkretnego projektu, jest jednym z podstawowych zagadnień dla każdej aplikacji CRUD. Zachęcam do tego aby ten, jak i kolejne wpisy traktować jako zwyczajne poradniki dla piszących w Laravelu, z nutką historii w tle.

Za każdym razem gdy piszemy aplikację, której instancja ma być używana równolegle przez więcej niż jedną osobę, pojawia się kwestia weryfikacji właściciela zasobu. Prościej mówiąc - sprawdzenia czy obecnie zalogowany użytkownik ma uprawnienia do wyświetlenia/edycji/usunięcia danego rekordu. Na pierwszy rzut oka sprawa nie należy do skomplikowanych:

$note = Note::where('id', $request->get('id'))->where('user_id', Auth::id())->get();

Na przykładzie notatek, pobieramy rekord o ID przekazanym w adresie i zaznaczamy że ID przypisanego użytkownika musi być równe identyfikatorowi obecnie zalogowanego (metoda pomocnicza id() z fasady Auth). Przyjmijmy też że naszym celem jest usunięcie wybranej notatki. W razie błędu przekierujemy zaś na inną stronę, na której wyświetlimy czytelny dla użytkownika komunikat. Bardziej kompletny kod oparty o metodzie przedstawionej powyżej mógłby wyglądać tak:

$note = Note::where('id', $request->get('id'))->where('user_id', Auth::id())->get();

if ($note === null) {
    return redirect('/')->with('error', 'Nie jesteś właścicielem podanej notatki');
}

$note->delete();

return redirect('/')->with('success', 'Notatka usunięta');

W wypadku gdy nie uda się odnaleźć pasującego rekordu otrzymujemy null. Wiemy wtedy że podana notatka nie istnieje lub istnieje, ale należy do kogoś innego (wymagamy spełnienia obu warunków), możemy więc cofnąć użytownika i wyświetlić mu odpowiednią wiadomość.

Na dobrą sprawę wpis można by zakończyć już w tym miejscu. Warto jednak spojrzeć bardziej perspektywicznie. Podany fragment kodu będzie się przecież powtarzał także dla innych operacji CRUD (np. edycji lub odczytu), nasza aplikacja może też zarządzać więcej niż jednym rodzajem danych (na przykładzie Codice - notatkami oraz etykietami). W efekcie otrzymamy brzydką i niewygodną w utrzymaniu powtarzalność kodu. Zastanówmy się jak można to poprawić.

Rozsądne wydaje się skorzystanie z metody find(), która przyjmuje za konwencję, że polem, po którym będziemy indeksować tabelę jest id. Możemy połączyć to także z możliwością opisaną w dokumentacji Laravela jako query scopes. Do naszego modelu dodajemy:

public function scopeMine($query)
{
    return $query->where('user_id', '=', Auth::id());
}

a wynikowo naszą metodę kontrolera redukujemy do postaci

$note = Note::mine()->find($request->get('id'));

if ($note === null) {
    return redirect('/')->with('error', 'Nie jesteś właścicielem podanej notatki');
}

$note->delete();

return redirect('/')->with('success', 'Notatka usunięta');

Jest lepiej. Powtarzalna część zapytania została przeniesiona do modelu (oraz konwencji używanej przez ORM Laravela). Wciąż jednak widzimy niezmienną część logiki, którą także przydałoby się wypchnąć na zewnątrz, w jakieś wspólne miejsce.

W tym celu możemy wykorzystać wyjątki, bazując zresztą na logice używanej przez wbudowaną metodę findOrFail(). Do naszego modelu dodajemy kolejną metodę pomocniczą:

public static function findMine($id)
{
    $note = self::mine()->find($id);

    if (!$note) {
        throw new NoteNotFoundException;
    }

    return $note;
}

W obrębie aplikacji tworzymy wyjątek NoteNotFoundException i importujemy go w modelu.

<?php

namespace AppExceptions;

class NoteNotFoundException extends Exception {}

Logikę obsługi błędów przenosimy natomiast do handlera wyjątków, edytując metodę render() w klasie AppExceptionsHandler.

public function render($request, Exception $e)
{
    if ($e instanceof NoteNotFoundException) {
        return Redirect::route('index')->with('message', 'Nie jesteś właścicielem podanej notatki`);
    }

    // reszta domyślnego kodu, np. ModelNotFoundException
}

Teraz kod użyty w kontrolerze powinien być naprawdę krótki i satysfakcjonujący:

$note = Note::findMine($request->get('id'));

$note->delete();

return redirect('/')->with('success', 'Notatka usunięta');

Jest dobrze? Tak. Może być lepiej? Oczywiście! Wady rozwiązania ujawnią się przy jakiejkolwiek większej skali. Pozostając przy Codice - ten sam kod musiałby być zduplikowany dla notatek i etykiet - dwa różne wyjątki, dwa bloki obsługujące go w handlerze, analogiczne modyfikacje w obu modelach.

Skupimy się więc na wyłączeniu części wspólnych. Wyeliminujemy potrzebę tworzenia indywidualnych wyjątków dla każdego rodzaju danych, a metody wymagane dla każdego z modeli przeniesiemy do traita.

<?php

namespace CodiceSupportTraits;

use Auth;
use IlluminateHttpExceptionsHttpResponseException;

trait Owned
{
    /**
     * Find owned model (limited to the current user).
     *
     * @param  int $id Model ID
     * @return static
     */
    public static function findMine($id)
    {
        $model = self::mine()->find($id);

        if (!$model) {
            $modelLangFile = array_reverse(explode('\', get_called_class()))[0];

            throw new HttpResponseException(redirect()->route('index')->with([
                'message' => trans("$modelLangFile.not-found"),
                'message_type' => 'danger',
            ]));
        }

        return $model;
    }

    /**
     * Query scope for getting owned models (limited to the current user).
     *
     * @param $query IlluminateDatabaseQueryBuilder
     * @return IlluminateDatabaseQueryBuilder
     */
    public function scopeMine($query)
    {
        return $query->where('user_id', '=', Auth::id());
    }

    /**
     * Define relationship to the User owning the model.
     */
    public function user()
    {
        return $this->belongsTo('CodiceUser');
    }
}

W tym wypadku obsługa po stronie kontrolera wygląda dokładnie tak, jak pokazano wyżej, jednak cała implementacja logiki dla określonego modelu ogranicza się do use Owned, bez żadnego powtarzania schematycznego kodu. Dodatkowym klasom wyjątków również możemy już podziękować, korzystamy z wbudowanego HttpResponseException, więc AppExceptionsHandler może zostać przywrócone do wcześniejszej postaci. Dodatkowo mamy też własny scope mine() (przydatny przy innych rodzajach zapytań niż wybranie pojedynczego rekordu po ID) oraz zdefiniowaną relację do modelu użytkownika.

Ciekawostką jest hack w metodzie findMine(), który pobiera nazwę modelu wywołującego metodę i na tej podstawie buduje klucz do pliku z tłumaczeniami (w celu zróżnicowania komunikatów błędów, np. "nie znaleziono notatki" vs "nie znaleziono etykiety").

Przedstawiłem kilka rożnych metod, skracając nieco drogę, przez którą ten kawałek kodu przeszedł w moim własnym projekcie. Zainteresowanych sprawdzeniem faktycznego kodu mogę odesłać do historii zmian w kontrolerze notatek oraz oczywiście traita Owned


Powyższy wpis przedstawia część doświadczeń zdobytych przy tworzeniu projektu Codice. Po więcej szczegółów zapraszam do pierwszego wpisu oraz na codice.eu. Poza planowaną od dawna serią jest to też realizacja wymogów konkursu "Daj Się Poznać". Więcej o nim możecie przeczytać w tym wpisie. Po nowe materiały poświęcone tworzeniu projektu Codice zapraszam w każdy wtorek. Ponadto więcej wpisów, poświęconych temu projektowi lub ogólnej tematyce bloga przeczytacie co sobotę.

Codice: instalator webowy dla aplikacji opartej o Laravel

Dośc długo zastanawiałem się czemu mógłbym poświęcić swój pierwszy, faktyczny wpis poświęcony rozwojowi Codice i problemom jakie musiałem rozwiązać. Daruję sobie rozpoczynanie od struktury katalogów, tworzenia kontrolerów i podobnych zadań — zaczniemy od początku, ale z perspektywy użytkownika.

Dość dużo mówi się o tym, jak zmienił się rozwój aplikacji webowych w ostatnich latach. Kiedyś (czy to patrząc na rok, czy na doświadczenie konkretnego programisty) prawdpodobnie wszyscy zaczynaliśmy, w wypadku PHP, od kilku plików na krzyż, w ekstremalnych przypadkach wrzucając jakąś rozpakowaną bibliotekę do osobnego folderu. Dzisiaj rozwój projektów, zwłaszcza na początku, przypomina budowę z klocków Lego. Zaczynamy od zainstalowania całego środowiska programistycznego — serwera (lub programu do obsługi środowisk zwirtualizowanych), Composera do obsługi zależności PHP, menedżera zależności dla JavaScript popularnego akurat w danym tygodniu (pun intended ;) ) i dopiero ostatecznie przystępujemy do pisania faktycznego kodu.

Ze stawianiem już gotowej aplikacji jest całkiem podobnie. Pobieramy kod, a następnie zdefiniowane w projekcie zależności. Potem jest już z górki — kompilujemy assety dla frontendu (w końcu to tylko kwestia odpalenia task runnera), wypełniamy plik konfiguracyjny (lub ustawiamy zmienne środowiskowe), uruchamiamy migracje dla bazy danych, jeśli nam zależy to wrzucamy do cache co się da — na koniec tworzymy konto użytkownika i voilà. Proste, prawda?

A no właśnie nie bardzo. Wszystkie z opisanych rozwiązań to ogromny krok na przód i ułatwienie dla programistów. Co więcej, przekładające się bezpośrednio na jakość ostatecznego produktu. Nie przerzucajmy jednak całego procesu ustawiania środowiska na użytkownika. Mamy dostępnych tyle świetnych technik i narzędzi, a tymczasem proces instalacji przeciętnego skryptu PHP się uwstecznił. W wypadku Codice postanowiłem połączyć zdobycze naszych czasów z prostotą instalacji dawnych skryptów.

Czynności do wykonania możemy podzielić na trzy grupy:

  • wykorzystanie zewnętrznych narzędzi — node.js wraz z Yarnem zarządzającym zależnościami dla tej technologii i gulpem odpowiedzialnym za przygotowanie zasobów dla client-side, ale także Composer dla zależności PHP
  • wypełnienie plików konfiguracyjnych
  • uruchomienie procesów oskryptowanych w PHP — na przykład migracji dla struktury bazy danych

Pierwszy krok zrealizowałem dzięki udostępnieniu do pobrania wstępnie zbudowanej paczki plików. W archiwum znajdują się produkcyjne zależności PHP, a także skompilowane assety (nie ma za to node_modules i innych plików wykorzystywanych wyłącznie przy developmencie — szanujmy łącza i czas użytkowników).

Resztą zajmuje się już instalator, będący de facto zwyczajnym kontrolerem Laravela. Aplikację zainstalowaną od tej jeszcze niezainstalowanej postanowiłem rozróżniać sprawdzajac obecność pliku .env. Ponieważ jednak jest on tworzony na pewnym etapie instalacji, potrzebny był dodatkowy sposób oznaczenia obecnie trwającej instalacji (tak, aby po kroku wypełniającym .env nie wyrzuciło nas z instalatora) — jest to po prostu plik tymczasowy tworzony po wejściu do instalatora i usuwany na jej ostatnim kroku. Cały proces wygląda następująco:

public function __construct()
{
    if (file_exists(base_path('.env')) && !file_exists(storage_path('app/.install-pending'))) {
        $this->denyInstallation = true;
        return Redirect::route('index')->send();
    }

    // ...
}

Kod znajduje się w konstruktorze więc automatycznie jest wykonywany dla każdego z kroków (akcji) instalatora. Warto zwrócić uwagę na użycie metody send(), jest ona wymagana w wypadku próby obsługi żądań HTTP z poziomu konstruktora.

Kolejnym etapem jest sprawdzenie wymagań, tj. obecności rozszerzeń PHP i zapisywalności określonych katalogów. Nie ma tu żadnej filozofii także przejdę dalej, do wypełniania pliku .env. Z pozoru proste zadanie, ot umieszczenie określonego stringa w pliku tekstowym. Jest jednak pewna pułapka, która swego czasu spędziła mi sen z powiek na ładnych parę godzin...

Problem pojawia się gdy w instalatorze wykorzystujemy jakiekolwiek sesje bądź ciasteczka (w moim wypadku było to ustawienie języka instalacji). Zarówno sesje jak i ciasteczka obsługiwane przez Laravela są szyfrowane przy użyciu klucza, tzw. APP_KEY. Jest on indywidualny dla każdej aplikacji, a więc przechowywany właśnie w pliku .env. Ten jednak nie istnieje na samym początku instalacji. Co wtedy robi Laravel? Spójrzmy na plik config/app.php:

'key' => env('APP_KEY', 'SomeRandomStringSomeRandomString'),

W wypadku gdy zmienna nie istnieje, klucz jest ustawiany na wartość domyślną, podaną w drugim parametrze funkcji. To jest właśnie klucz szyfrujący ciastka i sesje na poczatku instalacji... aż do momentu gdy, wypełniając .env, wstawimy do niego nowy klucz, który własnie wygenerowaliśmy. Skutek można sobie łatwo wyobrazić - dane w nich zapisane stają się niemożliwe do odczytania. Mając tę wiedzę spokojnie możecie wymyślić kilka różnych obejść problemu — ja zdecydowałem się doczepić aktualnie wybrany język do adresu, na który przekierowuję po wypełnieniu pliku konfiguracyjnego. W kolejnym kroku mogę go z tego adresu odczytać i ponownie zapisać do sesji.

W ten sposób doszliśmy do kolejnej kwestii, która na pierwszy rzut oka może wydawać się problematyczna — uruchomienie migracji z poziomu skryptu PHP. Domyślnie jest to bowiem komenda artisana, a dokumentacja zdaje się nie wspominać o alternatywnych drogach. Również wymóg użycia exec() dla zwykłej instalacji wydaje się przesadny, wszkaże wiele hostingów nadal blokuje tę i podobne funkcje. Tym razem jednak rozwiązanie jest wyjątkowo proste, a z pomocą przychodzi nam Artisan::call(), który wykonuje kod danej komendy bez jakiegokolwiek używania warstwy linii komend.

Artisan::call('migrate', ['--force' => true]);

Pamiętajmy o użyciu opcji --force, jest ona wymagana aby migracje mogły być uruchomione w środowisku produkcyjnym.

W wypadku Codice to już praktycznie koniec, pozostało tylko utworzenie konta dla użytkownika i dodanie mu notatki powitalnej. W swoich aplikacjach możecie oczywiście wykonać wszystkie inne czynności związane z instalacją, tak aby jak najbardziej ułatwić życie Waszych użytkowników końcowych. Naprawdę nie ma potrzeby wymagać od nich znajomości typowo programistycznych narzędzi ;) Ponadto, stosując przedstawione tutaj rozwiązanie nie blokujemy żadnej z dotychczasowych dróg instalacji. Nic nie stoi na przeszkodzie aby pobrać źródła (lub sklonować repozytorium) i wszystkie czynności wykonać ręcznie.

Na koniec, wszystkim zainteresowanym dokładnym działaniem instalatora polecam zacząć przeglądanie kodu od tego kontrolera. Aby zamieszać jeszcze troszkę, dodam że Codice obsługuje też instalację z poziomu CLI, dla osób które chciałyby postawić całą instalację bez opuszczania terminala bądź szukają wygodnej drogi na zautomatyzowanie procesu. Odpowiedzialny za to kod znajdziecie w tym miejscu.


Powyższy wpis przedstawia część doświadczeń zdobytych przy tworzeniu projektu Codice. Po więcej szczegółów zapraszam do pierwszego wpisu oraz na codice.eu. Poza planowaną od dawna serią jest to też realizacja wymogów konkursu "Daj Się Poznać". Więcej o nim możecie przeczytać w tym wpisie. Po nowe materiały poświęcone tworzeniu projektu Codice zapraszam w każdy wtorek. Ponadto więcej wpisów, poświęconych temu projektowi lub ogólnej tematyce bloga przeczytacie co sobotę.

Codice: zarządzanie zadaniami i notatnik online

W życiu każdego projektu (i jego twórcy) przychodzi taki moment, kiedy należy wyjść z wygodnego stanu wiecznej wersji beta i niezobowiązującego dłubania w kodzie przy okazji wolnych wieczorów. Wyjść z kodem do ludzi, liczyć się z tym, że ktoś może go rzeczywiście użyć (kto by pomyślał?), a nawet skrytykować. Uznałem, że ten etap nadszedł zarówno dla mnie, jak i mojego dziecka ochrzczonego mianem Codice.

Mówi się że w programowaniu istnieją jedynie dwie trudne rzeczy. Unieważnianie cache i nazewnictwo. Nazwa dla projektu (zarówno w tej wersji i jego wcześniejszych iteracji) powstała już lata temu i z włoskiego oznacza kod lub kodeks. Nawiązanie do kodu jest tak naprawdę miłym zbiegiem okoliczności, który powoduje że wydaje się znacznie bardziej przemyślana niż była w rzeczywistości. Kodeks zaś? Pamięć podpowiada mi że miałem na myśli zbiory notatek Leonarda da Vinci, które nazwano właśnie kodeksami. Czytałem o nich jako dziecko, zafascynowany różnorodnością i ilością zapisków sporządzanych przez signor Leonardo, i jak to dziecko - pomyślałem że też bym tak chciał!. Szczęśliwie, myśl ta przetrwała przez kilka lat i stwierdziłem że mógłbym ją wcielić w życie korzystając z technologii, których się uczyłem.

Długim słowem wstępu przechodzimy do przedstawienia projektu notatnika i aplikacji do zarządzania zadaniami online. Potrzeba gromadzenia i wykorzystywania przeróżnych informacji jest chyba wspólna dla każdego z nas. Pomieszczenie, a zwłaszcza późniejsze odnalezienie istotnych danych z całego szumu którym jesteśmy bombardowani jest niełatwe. Dlaczego więc i w tym wypadku nie wspomóc
się technologią?

Pierwsza wersja Codice (wtedy jeszcze pod inną nazwą) powstała w 2011 roku. Była tak naprawdę jednym olbrzymim switchem, którego eksperymentalnie umieściłem w jednym pliku - bo dlaczego nie? Niespełna 300 linii PHP plus jeden arkusz stylów zapewniał mi miejsce do dodawania notatek, którym opcjonalnie mogłem przypisać termin wykonania, a później oznaczyć taką notatkę (czy już wówczas zadanie) jako wykonaną. Zainteresowanych archeologią zapraszam (ostrzegając jednocześnie) do zobaczenia kodu na własne oczy.

Co zmieniło się przez te 6 lat? Przepisywałem projekt kilka razy, nieraz odkładając go do szuflady na długie miesiące. Na pewno jednak nie zmieniło się założenie, obecna wersja działa w naprawdę zbliżony sposób.

W pewnym momencie zdałem sobie sprawę że w tym właśnie leży siła. Banalnie prosta idea, do której można dobudować bardzo wiele - do tego użyteczna. Zrozumiałem że jest to coś, czemu jestem gotów poświęcić sporo pracy, a przy okazji podzielić się efektem ze światem.

Dzisiaj Codice jest aplikacją MVC, zbudowaną w oparciu o framework Laravel, która, pod względem napisanego kodu, powiększyła się niemal... pięćdziesięciokrotnie. Tyle mniej więcej wypuściłem z pod palców, w wolnych chwilach od grudnia 2015, kiedy raz jeszcze postanowiłem wymienić fundamenty i większość kodu.

Codice, o wciąż niezmiennej koncepcji, doczekał się nowego designu, wielu dodatkowych możliwości, nieco lepszej architektury a także protego systemu wtyczek, który powinien zapewnić mu pewną elastyczność na najbliższe lata i moje plany z nim związane.

Na obecnym etapie można chyba zaryzykować nazwanie go produktem używalnym, czego powinienem być żywym dowodem, korzystając z niego na co dzień od około pół roku. W dalszym ciągu udziela mi się oczywiście syndrom malarza i widzę w nim nieskończenie wiele rzeczy, które można by zrobić lepiej. No ale cóż, w myśl tego, co napisałem we wstępie czas zmierzyć się z odbiorem na zewnątrz i wykorzystać go jako niezaprzeczalną szansę na zebranie kilku opinii, przed osiągnięciem wersji stabilnej.

Swoje postępy na tej drodze będę opisywał od tej chwili na blogu. Według obecnego planu wpisy powinny pojawiać się w każdy wtorek, co najmniej do połowy maja.

Jeśli zaintrygowałem kogoś już w tym momencie, zapraszam na stronę projektu. Można poczytać sobie dokumentację jeśli ktoś ma problemy z zasypianiem lub po prostu pobrać paczkę i spróbować coś zepsuć ;)


Powyższy wpis poza planowanym już dawno przedstawieniem Codice i wstępem do serii, w której postaram się przybliżyć jego możliwości, pokazując przy tym jak rozwiązałem co ciekawsze problemy, jest też realizacją wymogów konkursu "Daj Się Poznać". Więcej o nim możecie przeczytać w moim wczorajszym wpisie. Oznacza to też, że co najmniej do połowy maja co sobotę będą pojawiać się kolejne materiały, tym razem poświęcone niekoniecznie rozwojowi Codice, ale również związane z tematyką bloga.