_config.php

Vai alla documentazione di questo file.

<?php

    // debug
        // die( 'CONFIG INIT' );

    // TODO documentare
        function path2custom( $p ) {
            return str_replace( '_', NULL, $p );
        }

    // REFACTORING le costanti DIRECTORY_* dovrebbero diventare per brevità DIR_* inoltre il nome dovrebbe rappresentare
    // il percorso (ad es. per DIRECTORY_LOG e DIRECTORY_LOG_LATEST dovrebbero diventare DIR_VAR_LOG e DIR_VAR_LOG_LATEST)
    // inoltre i percorsi dovrebbero essere composti concatenando le cartelle (ad es. DIR_VAR_LOG_LATEST = DIR_VAR_LOG . 'latest/')
    // infine le cartelle figlie di DIR_BASE dovrebbero includere DIR_BASE (ad es. DIR_VAR = DIR_BASE . 'var/' e di conseguenza
    // DIR_VAR_LOG = DIR_VAR . 'log/) questo per semplificare l'uso delle costanti di directory e ridurre il ricorso
    // in concatenazione a DIR_BASE)

    // REFACTORING conseguentemente dove possibile i nomi delle cartelle andrebbero ridotti a tre lettere (ad es. _src/_lib/_external
    // può divnetare _src/_lib/_ext/ e _src/_inc/_controllers può diventare _src/_inc/_cnt/ e così via) lasciando come eccezione
    // le cartelle custom che non esistono in standard (ad es. var/cache/ può rimanere così) anche se preferibilmente per i nomi
    // delle cartelle andrebbe usato l'inglese (ad es. var/immagini/ dovrebbe essere var/images/)

    // controllo performances
        define( 'START_TIME'                    , microtime( true ) );

    // directory base
        define( 'DIRECTORY_BASE'                , str_replace( '_src' , NULL , dirname( __FILE__ ) ) );

    // directory
        define( 'DIRECTORY_ETC'                 , '_etc/' );
        define( 'DIRECTORY_DIZIONARI'           , '_etc/_dictionaries/' );
        define( 'DIRECTORY_MODULI'              , '_mod/' );
        define( 'DIRECTORY_SRC'                 , '_src/' );
        define( 'DIRECTORY_CONFIGURAZIONE'      , '_src/_config/' );
        define( 'DIRECTORY_INCLUSIONI'          , '_src/_inc/' );
        define( 'DIRECTORY_CONTROLLER'          , '_src/_inc/_controllers/' );
        define( 'DIRECTORY_LIBRERIE'            , '_src/_lib/' );
        define( 'DIRECTORY_LIBRERIE_EX'         , '_src/_lib/_external/' );
        define( 'DIRECTORY_TEMPORANEA'          , 'tmp/' );
        define( 'DIRECTORY_VAR'                 , 'var/' );
        define( 'DIRECTORY_CACHE'               , 'var/cache/' );
        define( 'DIRECTORY_IMMAGINI'            , 'var/immagini/' );
        define( 'DIRECTORY_LOG'                 , 'var/log/' );
        define( 'DIRECTORY_LOG_LATEST'          , 'var/log/latest/' );

    // file
        define( 'FILE_LATEST_RUN'               ,  DIRECTORY_BASE . DIRECTORY_LOG_LATEST . 'run.latest.log');
        define( 'FILE_LATEST_CRON'              ,  DIRECTORY_BASE . DIRECTORY_LOG_LATEST . 'cron.latest.log');

    // livelli di controllo
        define( 'FILTERED_CONTROL'              , 'FILTERED' );
        define( 'FULL_CONTROL'                  , 'FULL' );

    // azioni
        define( 'METHOD_DELETE'                 , 'DELETE' );
        define( 'METHOD_GET'                    , 'GET' );
        define( 'METHOD_PATCH'                  , 'PATCH' );
        define( 'METHOD_POST'                   , 'POST' );
        define( 'METHOD_PUT'                    , 'PUT' );
        define( 'METHOD_REPLACE'                , 'REPLACE' );
        define( 'METHOD_UPDATE'                 , 'UPDATE' );

    // costanti per l'identificazione dei database
        define( 'DB_MYSQL'                      , 'MYSQL' );
        define( 'DB_POSTGRESQL'                 , 'PGSQL' );
        define( 'DB_MSSQL'                      , 'MSSQL' );

    // costanti che descrivono lo stato dell'output buffering
        define( 'OB_NON_ATTIVO'                 , 'NOOB'  );
        define( 'OB_ATTIVO'                     , 'OB' );
        define( 'OB_ATTIVO_CON_GZIP'            , 'OBGZ' );

    // costanti che descrivono il backend per le sessioni
        define( 'SESSION_APACHE'                , 'SESS_APACHE'  );
        define( 'SESSION_FILESYSTEM'            , 'SESS_FS'  );
        define( 'SESSION_REDIS'                 , 'SESS_REDIS' );
        define( 'SESSION_MEMCACHE'              , 'SESS_MEMCACHE' );

    // avvio dell'output buffer con compressione gzip se possibile, senza altrimenti
        if( ob_start( 'ob_gzhandler' ) ) {
            $cf['ob']['status']                 = OB_ATTIVO_CON_GZIP;
        } elseif( ob_start() ) {
            $cf['ob']['status']                 = OB_ATTIVO;
        } else {
            $cf['ob']['status']                 = OB_NON_ATTIVO;
        }

    // CHIAVI DI CONFIGURAZIONE
    // $cf['ob']                                contiene le informazioni relative all'output buffering
    // $cf['ob']['status']                      contiene lo stato dell'output buffering

    // NOTA il file src/config/external/config.yaml è stato posizionato lì in modo che sia possibile
    // montare la cartella src/config/external/ come ConfigMap in Kubernetes - questo spiega anche
    // perché src/config/external/config.yaml ha la priorità su src/config/config.yaml

    // NOTA visto che in caso di configurazione tramite mount di partizione su Kubernetes non dovrebbero
    // essere presenti altri file di configurazione non si può semplificare src/config/external/ in
    // src/config/ e montare quella?

    // NOTA si può usare path2custom() per i nomi dei file da includere

    // lettura del file di configurazione aggiuntivi YAML o JSON
        if( file_exists( DIRECTORY_BASE . 'src/config/external/config.yaml' ) ) {
            $cx = yaml_parse( file_get_contents( DIRECTORY_BASE . 'src/config/external/config.yaml' ) );
            $cf['config']['file']               = DIRECTORY_BASE . 'src/config/external/config.yaml';
        } elseif( file_exists( DIRECTORY_BASE . 'src/config.yaml' ) ) {
            $cx = yaml_parse( file_get_contents( DIRECTORY_BASE . 'src/config.yaml' ) );
            $cf['config']['file']               = DIRECTORY_BASE . 'src/config.yaml';
        } elseif( file_exists( DIRECTORY_BASE . 'src/config/external/config.json' ) ) {
            $cx = json_decode( file_get_contents( DIRECTORY_BASE . 'src/config/external/config.json' ), true );
            $cf['config']['file']               = DIRECTORY_BASE . 'src/config/external/config.json';
        } elseif( file_exists( DIRECTORY_BASE . 'src/config.json' ) ) {
            $cx = json_decode( file_get_contents( DIRECTORY_BASE . 'src/config.json' ), true );
            $cf['config']['file']               = DIRECTORY_BASE . 'src/config.json';
        }

    // CHIAVI DI CONFIGURAZIONE
    // $cf['config']                            contiene informazioni generali sulla configurazione del framework
    // $cf['config']['file']                    contiene il percorso del file di configurazione aggiuntiva corrente

    // REFACTORING
    // sarebbe bello poter ricavare implicitamente i moduli attivi dalla struttura dell'array $cx/$cf senza doverli dichiarare
    // esplicitamente in $cf['mods']['active']['array'] cosa che a volte ci si dimentica di fare causando poi errori piuttosto
    // antipatici da debuggare

    // NOTA si potrebbe sfruttare i numeri dei moduli per questo, in maniera simile a quello che già facciamo per i runlevel?
    // c'è il problema che differentemente dai runlevel qui si tratta di fare dei glob() sul filesystem quindi serve in realtà
    // il nome completo della cartella

    // debug
        // echo $cf['config']['file'] . PHP_EOL;
        // print_r( $cx );
        // die( 'EXTERNAL CONFIG DONE' );

    // array dei moduli attivi
        if( isset( $cx['mods']['active']['array'] ) ) {
            $cf['mods']['active']['array']      = $cx['mods']['active']['array'];
            $cf['mods']['active']['string']     = implode( ',', $cf['mods']['active']['array'] );
        } elseif( file_exists( str_replace( '_', '', DIRECTORY_BASE . DIRECTORY_MODULI ) ) ) {
            $cf['mods']['active']['array']      = array_values( array_diff( scandir( str_replace( '_', '', DIRECTORY_BASE . DIRECTORY_MODULI ) ) , array( '..' , '.' ) ) );
            $cf['mods']['active']['string']     = implode( ',', $cf['mods']['active']['array'] );
#       } elseif( ! empty( $_ENV['ACTIVE_MODULES'] ) ) {
#           $cf['mods']['active']['array']      = explode( ',', $_ENV['ACTIVE_MODULES'] );
#           $cf['mods']['active']['string']     = getenv( 'ACTIVE_MODULES' );
        } else {
            $cf['mods']['active']['array']      = array();
            $cf['mods']['active']['string']     = NULL;
        }

    // NOTA fra i tre alberi ci dev'essere corrispondenza completa nella struttura (al netto del fatto che ci sono informazioni
    // in $cx/$cf che non vanno ribaltate su $ct in modo da evitare confusioni e dubbi sulla posizione dei dati, specialmente in
    // fase di reperimento delle informazioni dal template manager

    // CHIAVI DI CONFIGURAZIONE
    // $cf['mods']                              contiene informazioni sui moduli
    // $cf['mods']['active']                    contiene l'elenco dei moduli attivi
    // $cf['mods']['active']['array']           contiene l'elenco dei moduli attivi in forma di array
    // $cf['mods']['active']['string']          contiene l'elenco dei moduli attivi in forma di stringa separata da virgole

    // NOTA la lettura dei moduli attivi dalle variabili d'ambiente è obsoleta

    // moduli attivi
        define( 'MODULI_ATTIVI'                 , $cf['mods']['active']['string'] );

    // collego $ct
        $ct['mods']                             = &$cf['mods'];

    // ricerca dei files di libreria
        $arrayLibrerieBase                      = glob( DIRECTORY_BASE . DIRECTORY_LIBRERIE . '_*.*.php' );
        $arrayLibrerieModuli                    = glob( DIRECTORY_BASE . DIRECTORY_MODULI . '_{' . MODULI_ATTIVI . '}/' . DIRECTORY_LIBRERIE . '_*.*.php', GLOB_BRACE );
        $arrayLibrerie                          = array_merge( $arrayLibrerieBase , $arrayLibrerieModuli );

    // TODO come è possibile saltare dei runlevel, dovrebbe essere possibile saltare delle librerie, sia con
    // una specificazione inclusiva (tipo "voglio solo queste librerie") sia esclusiva (tipo "includi tutte le librerie
    // tranne queste") in modo da alleggerire l'esecuzione del framework in caso non sia necessario includere tutte le
    // librerie

    // NOTA la strategia inclusiva andrebbe creata anche per i runlevel, che attualmente hanno solo quella esclusiva

    // inclusione dei files di libreria
        foreach( $arrayLibrerie as $libreria ) {
            $locale = str_replace( '_' , '' , $libreria );
            if( file_exists( $locale ) ) {
                require $locale;
            } else {
                require $libreria;
            }
        }

    // debug
        // die( print_r( get_included_files(), true ) );
        // die( 'LIBRARY CONFIG DONE' );

    // TODO bloccare l'esecuzione se non esistono le funzioni writeToFile() e logWrite()?

    // inclusione delle librerie esterne
        require DIRECTORY_BASE . DIRECTORY_LIBRERIE . '_external/autoload.php';

    // debug
        // die( 'EXTERNAL LIBRARY CONFIG DONE' );

    // ricerca dei files di configurazione standard
        $arrayConfig                            = glob( DIRECTORY_BASE . DIRECTORY_CONFIGURAZIONE . '_*.*.php' );

    // ordinamento dei file trovati
        sort( $arrayConfig );

    // NOTA in alcuni casi non tutti i runlevel sono necessari, quindi è possibile per uno specifico file richiedere
    // che alcuni di essi vengano saltati; questo migliora le prestazioni del framework e riduce lo spreco di risorse

    // CHIAVI DI CONFIGURAZIONE
    // $cf['runlevels']                         contiene informazioni sui runlevel
    // $cf['runlevels']['skip']                 contiene l'array dei runlevel da saltare

    // REFACTORING $cf['runlevels'] dovrebbe diventare $cf['lvls'] per analogia con $cf['mods']

    // filtro per runlevels
        if( ! isset( $cf['runlevels']['skip'] ) ) { $cf['runlevels']['skip'] = array(); }

    // NOTA le funzioni che hanno "to" nel nome per omogeneità con le altre dovrebbero diventare "2" ad esempio
    // writeToFile() dovrebbe diventare write2file()

    // log
        writeToFile( 'inizio esecuzione runlevels' . PHP_EOL, FILE_LATEST_RUN );

    // NOTA il framework prevede alcuni file di log speciali, utili soprattutto per il debug; questi file vengono scritti
    // a parte, direttamente con appendToFile(), senza passare dalla factory di log principale logWrite() per ridurre le
    // possibilità che un problema di esecuzione ne pregiudichi l'integrità
    //
    // FILE_LATEST_RUN                          contiene il tracciato dell'ultima esecuzione del framework, utile per capire
    //                                          dove si trova il problema in caso di esecuzione parziale che termina con errore
    // FILE_LATEST_CRON                         contiene il tracciato dell'ultima esecuzione dei task e dei job pianificati
    //                                          con cron, utile per verificare che cron stia girando e per monitorare il suo
    //                                          output, altrimenti difficile da catturare in altra maniera

    // debug
        // die( 'INIZIO ESECUZIONE RUNLEVELS' );

    // inclusione dei files di configurazione
    // NOTA questa è l'esecuzione della griglia moduli/livelli
        foreach( $arrayConfig as $configFile ) {

            // debug
                // echo $configFile . PHP_EOL;

            // controparte locale
                $configFileLocale = str_replace( '_', '', $configFile );

            // calcolo runlevel
                $runLvlArray = explode( '.', basename( $configFileLocale ) );
                $runLvlString = array_shift( $runLvlArray );

            // salto i runlevel specificati
                if( ! in_array( $runLvlString, $cf['runlevels']['skip'] ) ) {

                    // inclusione file standard
                        require $configFile;
                        timerCheck( $cf['speed'], $configFile );
                        appendToFile( 'esecuzione runlevel -> ' . $configFile . PHP_EOL, FILE_LATEST_RUN );

                    // inclusione file locale
                        if( file_exists( $configFileLocale ) ) {
                            require $configFileLocale;
                            timerCheck( $cf['speed'], $configFileLocale );
                            appendToFile( 'esecuzione runlevel -> ' . $configFileLocale . PHP_EOL, FILE_LATEST_RUN );
                        }

                    // controparte moduli
                        $arrayConfigModuli = glob( str_replace( DIRECTORY_BASE, DIRECTORY_BASE . DIRECTORY_MODULI . '_{' . MODULI_ATTIVI . '}/', $configFile ), GLOB_BRACE );
                        foreach( $arrayConfigModuli as $configFileModuli ) {

                            // debug
                                // echo $configFileModuli . PHP_EOL;

                            // inclusione file di modulo
                                require $configFileModuli;
                                timerCheck( $cf['speed'], $configFileModuli );
                                appendToFile( 'esecuzione runlevel -> ' . $configFileModuli . PHP_EOL, FILE_LATEST_RUN );

                            // controparte modulo locale
                                $configFileModuliLocale = str_replace( '_', '', $configFileModuli );
                                if( file_exists( $configFileModuliLocale ) ) {
                                    require $configFileModuliLocale;
                                    timerCheck( $cf['speed'], $configFileModuliLocale );
                                    appendToFile( 'esecuzione runlevel -> ' . $configFileModuliLocale . PHP_EOL, FILE_LATEST_RUN );
                                }

                        }

                } else {

                    logWrite( 'saltato runlevel: ' . $runLvlString, 'speed', LOG_DEBUG );

                }

        }

    // CHIAVI DI CONFIGURAZIONE
    // $cf['speed']                             contiene informazioni sulla velocità e sulle performance del framework

    // debug
        // die( 'CONFIG END' );

    // NOTA le costanti e gli array $cx/$cf/$ct dovrebbero essere gli unici ad avere visibilità su file diversi; per evitare
    // confusioni e collisioni le variabili dovrebbero sempre avere il loro ciclo di vita limitato al file in cui vengono
    // dichiarate

    // debug
        // print_r( get_included_files() );
        // print_r( $cf );
        // print_r( $ct );
        // print_r( $cx );

?>