Flow: viaggio nel futuro con un caso realizzato

Flow: viaggio nel futuro con un caso realizzato

Tarcisio Fedrizzi16-17 Novembre 2012

Bologna

17 Novembre 2012 Tarcisio Fedrizzi - T3Camp Bologna 2/37

Federazione provinciale Scuole materne di Trento

✗ Associazione di 135 scuole materne✗ 21 circoli✗ Quasi 1500 maestre


Outline

✗ Presentazione✗ Il progetto

✗ Dominio✗ Tecnologie

✗ POSIT.MethodLogger✗ Annotazioni✗ AOP

✗ Fluid Standalone

✗ Considerazioni su Flow

✗ Conclusioni✗ Domande


Presentazione

✗ Libero professionista dal 2005

✗ Socio di POSIT dal 2009

✗ Progettazione e sviluppo applicazioni ad-hoc

✗ Primo progetto basato su TYPO3.Flow messo in produzione


210ore: tecnologie 1/2

✗ Server: TYPO3.Flow✗ Client:

✗ Insegnanti: ExtJS 4(è statonecessario renderel'interfacciapiù fedele possibilea quella del clientwindows usatoin precedenza)


210ore: tecnologie 2/2

✗ Gestori:TYPO3.Fluid +JQuery DataTable

✗ Amministratori:TYPO3.ExposeoppureTYPO3.Fluid(ancora infase di sviluppo)


Il modulo POSIT.MethodLogger

✗ Estratto dal progetto 210ore✗ Permette di loggare chiamate a qualsiasi

metodo✗ È possibile accedere ai parametri della

chiamata✗ Permette di vedere alcuni aspetti del

framework Flow in azione


Annotazioni 1/2

Elementi che permettono di “appiccicare” dei dati descrittivi (metadati) a classi, metodi e interfacce

✗ In alcuni linguaggi (es. Java) sono un costrutto che fa parte del linguaggio

✗ In altri, tra cui PHP, non sono ancora disponibili nativamente e vengono quindi specificate nei commenti.


Annotazioni 2/2

✗ Flow ne fa un uso piuttosto consistente. Ad esempio:

nelle definizioni delle Entità.

... use TYPO3\Flow\Annotations as Flow; ... /** * @Flow\Entity */ class MethodLog { ...


Definizione Annotazioni

✗ Semplice classe che contiene i parametri passati dove l'annotazione è specificata;

✗ I parametri sono passati al costruttore dell'annotazione in un unico array.

... * @Annotation * @Target("METHOD") */ final class LogMethod { /** * @var string */ public $message; ...

... class PostController { /** * @POSIT\LogMethod( * message="Creato post.") */ public function createAction( ...


AOP 1/2

Ideata da Gregor Kiczales e altri di Xerox PARC

✗ Permette di mantenere una netta separazione tra logica di business e funzionalità non specifiche dell'applicazione

✗ Queste funzionalità vengono aggiunte con un sistema che si basa su tre concetti


AOP 2/2

✗ I concetti sono i seguenti:✗ Advice: definisce la funzionalità che dev'essere

aggiunta (Logging, controlli di accesso, ecc);✗ Pointcut: permette di specificare in quali punti la

funzionalità dev'essere eseguita (prima di chiamare un metodo, quando viene lanciata un'eccezione, ecc);

✗ Join point: descrive il contesto presente nel punto in cui è stata sospesa l'esecuzione.


AOP in Flow: Aspect

✗ L'aspetto in Flow è una classe annotata con @Flow\Aspect.

✗ La classe deve inoltre definire un Advice o un Pointcut per essere un aspetto considerato valido.

... /** * @Flow\Aspect */ class LogMethodAspect { /** * @Flow\Around( * "POSIT\MethodLogger\Aspect\LogMethodAspect->methodsAnnotatedWithLogMethod") */ public function runMethodLogging(\TYPO3\Flow\Aop\JoinPointInterface $joinPoint){ ...


AOP in Flow: Pointcut

✗ Flow offre diversi designatori di pointcut: method, class, ecc...

✗ Essi permettono di selezionare i metodi ai quali dev'essere applicato un advice

... /** * @Flow\Pointcut( * "methodAnnotatedWith( * POSIT\MethodLogger\Annotations\LogMethod)") */ public function methodsAnnotatedWithLogMethod() {} ...


AOP in Flow: Advice

✗ L'advice è il metodo che viene eseguito quando vengono chiamati i metodi selezionati con il pointcut;

✗ Esso viene eseguito secondo le indicazioni dall'annotazione che decora il metodo;

... /** * @Flow\Around( * "POSIT\MethodLogger\Aspect\LogMethodAspect->methodsAnnotatedWithLogMethod") */ public function runMethodLogging(\TYPO3\Flow\Aop\JoinPointInterface $joinPoint){ $logMethod = $this->getLogMethodAnnotation($joinPoint); $this->logMessage($joinPoint, $logMethod); return $joinPoint->getAdviceChain()->proceed($joinPoint); } ...


AOP in Flow: Join point

✗ Il join point permette di accedere al contesto e alla descrizione del metodo al quale è applicato l'advice;

✗ tramite il join point è possibile conoscere il nome del metodo, i parametri che sono stati passati, ecc

... $i = 0; $className = $joinPoint->getClassName(); $methodName = $joinPoint->getMethodName(); $methodArguments = $joinPoint->getMethodArguments(); print("$className->$methodName("); foreach ($methodArguments as $argumentName => $argumentValue) { if ($i++ > 0) { print(", "); } print("$argumentName = $argumentValue"); } print(");\n"); ...


Fluid standalone 1/2

✗ È possibile utilizzare il motore di templating anche in maniera standalone

✗ Questo ci permette di riutilizzare la sintassi di fluid anche in contesti differenti rispetto a quello delle pagine web

private function renderViewText(\TYPO3\Flow\Aop\JoinPointInterface $joinPoint $text) { $textView = new \TYPO3\Fluid\View\StandaloneView(); $textView->initializeObject(); $textView->setTemplateSource($text); foreach ($joinPoint->getMethodArguments() as $name => $value) { $textView->assign($name, $value); } return $textView->render(); }


Fluid standalone 2/2

✗ L'utilizzo del metodo definito nella slide precedente ci permette quindi di accedere ai parametri del metodo loggato all'interno del messaggio di log

... /** * @POSIT\LogMethod(message="{newPost.author} ha creato il nuovo * post intitolato {newPost.title}.") */ public function createAction( \TYPO3\Blog\Domain\Model\Post $newPost) { ...


Considerazioni su Flow 1/9

✗ Dal punto di vista tecnologico offre molte possibilità (AOP, annotazioni, slot e segnali)✗ c'è tutto quello che (e anche di più) può servire per lo

sviluppo web

✗ È in generale semplice aggiungere e/o modificare le funzionalità offerte dal framework✗ Si tratta in genere di ereditare da una classe e di

implementare un'interfaccia definendo pochi metodi (molte volte è sufficiente uno)



✗ Il sistema di controllo degli accessi è molto flessibile✗ Permette di specificare anche condizioni

complesse modificando soltanto i file di configurazione

✗ Il sistema di mapping dei parametri della richiesta sui parametri del metodo dell'azione chiamata nel controller permette di mantenere la logica di business molto pulita



✗ Configurabilità da file✗ Semplice aggiungere la configurazione anche

per i propri moduli✗ L'interfaccia a linea di comando✗ Semplice aggiungere comandi per i propri

moduli



✗ Problema maggiore riguarda l'usabilità:✗ Punti fondamentali per lo sviluppo

di un progetto reale non sonodocumentati. Ad esempio:

✗ Logging e debugging✗ Deployment e amministrazione

✗ L'applicazione di esempio TYPO3.Blog copre alcune casistiche ma non offre un esempio esaustivo

✗ Gli esempi che ci sono nella documentazione sono utili ma anche in questo caso non esaustivi



✗ In molti casi è difficile capire dov'è o a quale elemento si riferisce un errore

✗ Non c'è menzione a qualche cosa che mi possa aiutare a trovare il soggetto dell'errore



✗ E lo stacktrace dell'eccezione scritto su file non offre maggiori informazioni

Uncaught exception #1222268609 in line 146 of Data/Temporary/Development/Cache/Code/FLOW3_Object_Classes/TYPO3_FLOW3_Security_Authorization_AccessDecisionVoterManager. Php: Access denied (1 denied, 0 granted, 0 abstained)

22 TYPO3\FLOW3\Security\Authorization\AccessDecisionVoterManager_Original::decideOnJoinPoint(TYPO3\FLOW3\Aop\JoinPoint) 21 TYPO3\FLOW3\Security\Authorization\AccessDecisionVoterManager::decideOnJoinPoint(TYPO3\FLOW3\Aop\JoinPoint) 20 call_user_func_array(array, array) 19 TYPO3\FLOW3\Security\Authorization\AccessDecisionVoterManager::FLOW3_Aop_Proxy_invokeJoinPoint(TYPO3\FLOW3\Aop\JoinPoint) 18 TYPO3\FLOW3\Security\Authorization\AccessDecisionVoterManager::decideOnJoinPoint(TYPO3\FLOW3\Aop\JoinPoint) 17 TYPO3\FLOW3\Security\Authorization\Interceptor\PolicyEnforcement_Original::invoke() 16 TYPO3\FLOW3\Security\Aspect\PolicyEnforcementAspect_Original::enforcePolicy(TYPO3\FLOW3\Aop\JoinPoint) 15 TYPO3\FLOW3\Aop\Advice\AroundAdvice::invoke(TYPO3\FLOW3\Aop\JoinPoint) 14 TYPO3\FLOW3\Aop\Advice\AdviceChain::proceed(TYPO3\FLOW3\Aop\JoinPoint) 13 POSIT\DuecentodieciOre\Controller\Domain\Accounting\AnnualEstimateController::initializeAction() 12 TYPO3\FLOW3\Mvc\Controller\ActionController_Original::processRequest(TYPO3\FLOW3\Mvc\ActionRequest, TYPO3\FLOW3\Http\Response) 11 TYPO3\FLOW3\Mvc\Dispatcher_Original::dispatch(TYPO3\FLOW3\Mvc\ActionRequest, TYPO3\FLOW3\Http\Response) 10 TYPO3\FLOW3\Mvc\Dispatcher::dispatch(TYPO3\FLOW3\Mvc\ActionRequest, TYPO3\FLOW3\Http\Response) 9 call_user_func_array(array, array) 8 TYPO3\FLOW3\Mvc\Dispatcher::FLOW3_Aop_Proxy_invokeJoinPoint(TYPO3\FLOW3\Aop\JoinPoint) 7 TYPO3\FLOW3\Aop\Advice\AdviceChain::proceed(TYPO3\FLOW3\Aop\JoinPoint) 6 TYPO3\FLOW3\Security\Aspect\RequestDispatchingAspect_Original::blockIllegalRequestsAndForwardToAuthenticationEntryPoints( TYPO3\FLOW3\Aop\JoinPoin t) 5 TYPO3\FLOW3\Aop\Advice\AroundAdvice::invoke(TYPO3\FLOW3\Aop\JoinPoint) 4 TYPO3\FLOW3\Aop\Advice\AdviceChain::proceed(TYPO3\FLOW3\Aop\JoinPoint) 3 TYPO3\FLOW3\Mvc\Dispatcher::dispatch(TYPO3\FLOW3\Mvc\ActionRequest, TYPO3\FLOW3\Http\Response) 2 TYPO3\FLOW3\Http\RequestHandler::handleRequest() 1 TYPO3\FLOW3\Core\Bootstrap::run()



✗ Spesso errori nel progetto (per esempio derivanti da elaborazione del codice del progetto da parte del framework, configurazioni errate all'interno del progetto) producono stacktrace e messaggi in cui non appare niente che riguarda il progetto. Questo rende quindi molto difficile e pesante comprendere qual'è il problema.



✗ Assenza di utility per rendere lo sviluppo più comodo e rapido✗ Mi sarei aspettato di trovare nella distribuzione

base:✗ Un'interfaccia web per il debugging (area che posso

consultare per leggere i log, profiling, ecc)✗ Vedi Debug.Toolbar (debug), Plumber (profiling)

✗ Un'interfaccia grafica per una gestione di base degli oggetti definiti nel progetto

✗ Vedi TYPO3.Expose



✗ Un interfaccia CRUD che mi permetta di gestire gli oggetti nel database senza dover scrivere sempre lo stesso codice.

✗ L'usabilità è troppe volte posta come un elemento a bassa priorità. È invece molto importante dato che la sua carenza:✗ costituisce una barriera per l'adozione da parte di

nuovi utenti✗ rende frustranti operazioni che dovrebbero

essere semplici


Conclusione✗ TYPO3.Flow è un framework completo che offre tutti gli strumenti per creare le più

disparate applicazioni web✗ Offre una base ricca e solida su cui costruire i propri progetti✗ Ancora molto dev'essere fatto sul fronte dell'usabilità perché:

✗ non tutti se la sentono di mettere il naso nel codice del framework per fare il debug della propria applicazione

✗ un framework che si pone come obiettivo di ...“far tornare la gioia di sviluppare.”... dovrebbe rendere veloci e semplici quelle operazioni noiose e ripetitive che fanno parte di ogni progetto

✗ Per evitare che il progetto rimanga nel limbo è necessario cominciare ad utilizzare, e quindi testare, il framework in ambienti reali. Soltanto così è possibile verificare quali aspetti vanno migliorati, capire cosa sarebbe comodo avere e, riportandolo agli sviluppatori oppure contribuendo noi stessi, migliorare il framework fino a renderlo lo strumento più adatto alle nostre esigenze.


Grazie per l'attenzione

✗ Il codice dell'esempio mostrato nella presentazione è disponibile all'url:✗ https://github.com/posit-it/POSIT.MethodLogger

✗ L'esempio gira su Flow 2.0 (ex FLOW3 1.2)

✗ Altri pacchetti menzionati nella presentazione:✗ Plumber:

✗ https://github.com/sandstorm/Plumber✗ Debug.Toolbar:

✗ https://github.com/mneuhaus/Debug.Toolbar/✗ TYPO3.Expose:

✗ http://git.typo3.org/FLOW3/Packages/TYPO3.Expose.git

https://github.com/posit-it/POSIT.MethodLogger

https://github.com/sandstorm/Plumber

https://github.com/mneuhaus/Debug.Toolbar/

http://git.typo3.org/FLOW3/Packages/TYPO3.Expose.git


Persistenza

✗ In Flow la persistenza dei dati è gestita tramite un livello di astrazione

✗ Flow si basa sulla programmazione orientata agli oggetti. Questo implica che in flow la “base dati” è costituita dalla definizione di una serie di oggetti collegati tra loro.

✗ Dietro le quinte il framework si occupa di mappare gli oggetti da e verso il database


Persistenza: Doctrine

✗ Flow supporta diversi metodi di persistenza tuttavia quello maggiormente integrato è Doctrine.

✗ Doctrine (la versione 2 è quella integrata in FLOW) è un Object Relational Mapping Software. Questo genera, a partire dalla descrizione dei dati e dalle azioni che noi facciamo sui dati stessi, le query che aggiornano i dati nel database.


Persistenza: entità

✗ Per poter mappare gli oggetti su database è necessario decorare gli oggetti con alcune annotazioni. Queste permettono all'ORM di raccogliere le informazioni necessarie a generare lo schema.

... * @Flow\Entity */ class MethodLog { ... /** * L'indirizzo del client che ha causato l'invocazione del metodo loggato. * @var string * @ORM\Column(length=15, nullable=true) */ protected $ip; ...


Gestione degli oggetti

✗ In Flow il cliclo di vita degli oggetti è gestito automaticamente dal framework

✗ La gestione degli oggetti viene quindi affidata ad una classe chiamata ObjectManager

✗ Ad ogni classe è associato quello che è definito scope. Questo determina il modo in cui viene gestito il ciclo di vita dell'oggetto


Gestione degli oggetti

✗ Gli scope offerti dal framework sono:✗ Singleton: il gestore degli oggetti crea un'unica istanza

dell'oggetto. Ogni volta che viene richiesto l'oggetto viene ritornata la stessa istanza.

✗ Session: il ciclo di vita dell'oggetto corrisponde alla sessione di un utente. L'oggetto che ha questo tipo di scope è quindi specifico per ogni sessione.

✗ Prototype: ogni volta che si richiede un oggetto con questo tipo di scope ne viene ritornata una nuova istanza


Dependency injection

✗ La gestione centralizzata degli oggetti permette di eliminare la gestione delle dipendenze tra gli oggetti.

✗ È possibile richiedere un oggetto in varie maniere. La più semplice consiste nella specifica di due annotazioni nel commento della variabile che ospiterà l'oggetto.

... /** * Il repository delle operazioni fatte dagli utenti. * * @Flow\Inject * @var \POSIT\MethodLogger\Domain\Repository\MethodLogRepository */ protected $methodLogRepository; ...


Configurazione 1/2

✗ Flow mette a disposizione tramite la dependency injection un meccanismo semplice per l'accesso a impostazioni di configurazioni specifiche del modulo.

... /** * L'array che contiene le * impostazioni specificate per * il package. * @var array */ protected $settings; ... /** * @param array $settings * @return void */ public function injectSettings(array $settings) { $this->settings = $settings; } ...


Configurazione 2/2

✗ Una volta iniettato l'array delle impostazioni sarà possibile accedere all'albero di configurazione che è denominato come il namespace del modulo

... private function isEnabled() { return array_key_exists('enable', $this->settings) && $this->settings['enable']; } ...

... POSIT MethodLogger enable: true ...

Technology

Flow: viaggio nel futuro con un caso realizzato