Antonio Esposito

Thin client... ci siamo quasi

2013-04-09T13:52:22Z

Ciao a tutti

Lo so, sono anni che si è abbandonato lo scenario client-server in ottica di un mondo distribuito (non parlo di programmazione)
Una volta i main-frame, oggi i PC, ad ognuno il suo... che peccato però! CPU a 4, 6 e 8 core, 24GB di ram, per una persona sola che magari ci va sul web....

Abbiamo la virtualizzazione (IaaS)

Abbiamo Terminal Services accessibile da RDP (remote desktop)

Abbiamo l'hardware (cloud?!?!)

Abbiamo i dongle con sopra Android (http://android.hdblog.it/2013/03/08/cloudnetgo-cr9-mini-pc-android-quad-core-in-formato-chiavetta/)

Quindi manca solo la volontà :)

Se mettiamo sul dongle un accesso password-free (tanto non serve sul client) per andare in RDP usando una wifi o una ethernet (negli uffici, aziende formazione, etc), connettiamo monitor HD in HDMI, con audio, tastiera e mouse USB, abbiamo il nostro "VERO", per la prima volta nella storia, thin-client, per connetterci al nostro Terminal Server di gruppo

Immaginiamo un'aula di formazione per un corso di programmazione, tiro su una VM sul cloud (privato o pubblico), 2CPU, 6GB RAM, poi una dozzina di dongle con le postazioni in aula, una fibra ottica da 10Mbit, e ho fatto tutto il mio lavoro!

E' solo una questione di volontà, spero che tra poco qualche produttore di dongle ne dia la possibilità di personalizzarle per questo scopo!

a presto

[Legacy] 1994, Iomega Zip 100, 1997 Iomega Zip 250USB

2013-03-18T10:58:00Z

ciao a tutti

oggi sono di umore giusto per fare un nuovo post sul mondo Legacy

in pratica, quello relativo alle cose vecchiarelle, che per alcuni come me significa ricordare qualcosa, per altri significa nuovamente scoprire qualcosa di (non)nuovo

nello scorso post sui Floppy Disk ho appunto parlato di come si usavano e come funzionano ancora oggi; ricordiamo che fino a Windows 2000 erano necessari per avviare il sistema perché il CD non faceva boot (almeno nelle prime versioni)

oggi invece vi mostro come funziona lo Iomega Zip, storico drive da 100MB introdotto nella prima metà degli anni 90, che molti professionisti (si vede ancora in molti vecchi film) usavano per portarsi documenti a casa

era/è un drive magnetico, quindi come i Floppy e come gli HD, a rotazione, esterno, con dischetto di plastica

capacità iniziale 100MB; qualche anno dopo fu introdotta la versione USB (1996/1997), che portava anche il nuovo drive a nuove capacità: 250MB

ricordiamo che il 1995 era anche l’anno dell’introduzione in massa dei CD-ROM, ovviamente con il conseguente uso dei CD-R/RW, che però avevano il problema di essere ottici, e quindi o write-once (CR-R), o altamente scomodi per un utente medio da usare al posto di un floppy (CD-RW)

mancavano oltre 5 anni alle prime Pen-Drive USB, e quindi gli Zip (e un concorrente LS120) la facevano da padrone

ho rimediato su e-bay un drive Zip funzionante di tipo USB1.0 ve lo mostro:

il drive è anche carino, supporta dischi da 100MB

e il nuovi (per l’epoca) 250MB

una volta connesso all’USB (il mio è 3.0, ma retrocede volentieri all’1.0) funziona come un normale floppy:

ovviamente formattato in FAT(16)

con eccezionali tempi di copia (per l’epoca)

spero vi siate divertiti

a presto

WinRT & Html Manipulation + HtmlAgilityPack

2013-03-18T10:01:00Z

Ciao a tutti

una grande categoria di applicazioni ha bisogno di manipolare l’HTML come ad esempio gli RSS reader

le operazioni principali da fare sono in genere mostrare l’HTML come testo all’interno delle proprie applicazioni, possibilmente in maniera formattata

in questo caso WinRT ci da a disposizione una classe molto comoda che è Windows.Data.Html.HtmlUtilities

in questa classe il metodo statico ConvertToText fa il grosso del lavoro per noi, convertendo l’HTML in testo formattato ad esempio con i ritorni a capo, senza importare elementi multimediali come immagini e simili

altra classe utile per manipolare l’HTML è la System.Net.WebUtility che copre il ruolo della HttpUtility (non WinRT), dandoci la possibilità di fare l’encoding ed il decoding dell’HTML per poterlo ad esempio storare all’interno di un file o di un DB senza incorrere in pericolose injection di vario tipo (script, sql, etc)

ultimo consiglio, l’uso delle librerie HtmlAgilityPack, disponibili da un po anche per WinRT

come la grande maggioranza delle librerie, è disponibile su NuGet

con HtmlAgilityPack è possibile fare il parse dell’HTML anche quando questo è poco ben strutturato, come ad esempio per i vecchi HTML 4.0

con questo codice è possibile ad esempio prendere la prima immagine (tag IMG) per usarla magari in binding da un ViewModel per connetterla ad un controllo image

XAML:

C#:

public string Image
{
    get
    {
        //il proprio HTML magari preso dal tag description di un RSS
        string myHTML="";
        var doc = new HtmlDocument();
        doc.LoadHtml(myHTML);
        var images = doc.DocumentNode.Descendants("img").Select(i => i.Attributes["src"].Value);
        return images.FirstOrDefault();
    }
}

a presto

[LEGACY] Come usare un floppy-disk da 1.44MB da MS-DOS

2013-03-03T18:26:00Z

Ciao a tutti

scrivo questo articolo per le nuove generazioni, ed anche per i non più ragazzini che come me il floppy l’hanno usato… per installare win3.11, per installare win95… etc….

Un floppy disk è un disco flessibile rivestito da una custodia di plastica rigida con apertura sul lato superiore protetta da clip metallica

Le capacità sono variabili, ma nell’ultima e più diffusa versione è di 1.44MB, formattato in FAT per sistemi DOS e Windows

Questa la faccia di un lettore floppy USB 1

il disco si può inserire al suo interno semplicemente immettendolo dal d’avanti come per un CD in un lettore tray-less

una volta inserito il floppy, questo si va a posizionare del tutto al suo interno, facendo fuoriuscire una levetta (in questo caso) sulla dx da ripremere per una espulsione meccanica del supporto

in genere, durante l’utilizzo un LED si illumina per informare l’utente che la testina magnetica sta eseguendo operazioni di IO sul disco

questo un esempio di utilizzo di un floppy da una shell DOS

spero vi sia piaciuto questo tuffo nel passato

a presto

CLR Memory Management

2013-02-25T18:54:00Z

ciao a tutti

nel .NET esistono due categorie di tipi (TYPE in originale): Value Type e Reference Type

questa la loro suddivisione:

VALUE TYPES

INT (short, long, uint, ushort, byte, sbyte, decimal, etc)
FLOAT (double, float)
BOOL
ENUM (enumerazioni)
STRUCT (strutture)

REFERENCE TYPE

Object (e ogni derivato)
STRING

Nel .NET framework esistono due principali aree di memoria in cui vengono conservati gli oggetti durante l’esecuzione (run-time), Heap e Stack

Come in molti libri è enunciato lo Stack è l’area che conserva i value-type, mentre lo Heap è l’area che conserva i reference-type (le istanze delle classi nostre o del framework stesso)

Ovviamente, questa è una “barzelletta”…. nel senso che non è esattamente così – benché possa sembrare

Nel CLR (common-language-runtime) del .NET framework, implementato da Microsoft (in pratica la virtual machine in cui il codice .NET si converte da IL – il precompilato – a binario), esistono 3 aree di memoria in cui le nostre variabili di vario tipo vengono memorizzate durante l’esecuzione (heap, stack & registers). L’unico vero discriminante nella scelta della memoria da utilizzare, è lo scope (la prevista durata come compresa dal compilatore o dal Runtime) della nostra variabile

Questo già mette in luce che esiste un’area di memoria di solito dimenticata (Registers), così come mette in luce il fatto che in realtà MONO (il CLR per Linux e non solo) potrebbe avere una architettura della gestione della memoria completamente diversa (non so se mono si comporti diversamente o egualmente al clr Ms)

Ulteriore appunto alla definizione usuale è il fatto che in realtà non è il tipo di variabile a caratterizzarne l’allocazione in memoria, ma la sua dichiarazione, e più precisamente il suo presunto ciclo di vita (life-time in originale)

Un esempio tipico è il fatto che gli INT dentro una variabile di tipo Reference, non sono sullo Stack ma sullo Heap

La spiegazione sul perché avviene tutto questo è la seguente:

Se dichiariamo una variabile di tipo primitivo, e la utilizziamo in maniera procedurale, il CLR sa esattamente quando verrà dichiarata, e quando verrà abbandonata, quindi la può caricare nello Stack o nel Register

Mentre se è una istanza di classe, che appunto è un Reference Type, questo rende più difficile al CLR capire quando esattamente potrebbe essere abbandonato l’uso della variabile (cosa che infatti impatta in seguito il GC), e quindi il CLR adottando un approccio conservativo, mette il Reference (il riferimento della variabile – diciamo pure il puntatore) nello Stack, e il contenuto della variabile puntata nello Heap, proprio perché considera long-lived l’oggetto…. in pratica dice: io non riesco a predire se sarà ad uso breve o lungo, quindi lo metto nell’area di memoria degli oggetti a vita lunga, se poi sarà breve, il GC lo rimuoverà

Ulteriore esempi di oggetti nello Heap (long-lived memory area) sono le variabili cross-utilizzate nelle lambda, queste appunto essendo dei Delegate, ed essendo soggetti all’Azione a Distanza per flusso di esecuzione ed anche per distanza temporale, vanno automaticamente nello Heap anche se normalmente di tipo short-lived, ad esempio un INT che viene passato come parametro non diretto all’interno di una lambda (in pratica quelli fuori alla Action/Func, ma che vengono visualizzati anche dal codice anonimo della funzione, perché nello stesso scope della lambda stessa).

BOXING/UNBOXING:

Ovviamente l’operazione di boxing (inserimento di un valore primitivo in un oggetto contenitore – in genere Object) rende il tipo un Reference type, e quindi automaticamente soggetto al problema già detto del passaggio dell’istanza da short-lived a long-lived, e quindi al passaggio da Stack/Register all’Heap, con conseguente perdita di performance dovuta alla copia del valore tra 1 area di memoria ad 1 altra.

Simile il comportamento che avviene quando utilizziamo una lambda: come già detto questa rende tutte le variabili dello stesso scope automaticamente long-lived, quindi al pari di un’operazione di boxing

CONCLUSIONI:

Attenzione a quello che si scrive… molte applicazioni legacy, vedi i gestionali Client-Server, sono molto poco ottimizzati nell’uso delle variabili, lasciando spesso al CLR il compito di “arrangiarsi”. Anche se nel tempo ci si è basati sul fatto che tanto ogni utente avrà il proprio PC e che difficilmente il rallentamento sarà generale e quindi problematico, questo cambia con il cambiare delle architetture software che vanno sempre più verso N-Tier, Servizi/SOA e Cloud Computing.

Inoltre va detto che, realizzando applicazioni che vanno spesso sul Cloud, dove la bassa ottimizzazione la paghiamo noi in bolletta, è meglio fare attenzione a quello che facciamo ed a come lo facciamo.

spero di essere stato chiaro, almeno un po

RIFERIMENTI:

Eric Lippert’s Blobg

[TIP] ASP.NET Custom Handler + Session

2013-02-25T11:50:00Z

Ciao a tutti

sappiamo che con ASP.NET è possibile registrare degli handler custom per generare a Runtime dei files (più precisamente delle response) che non siano statici (presenti) sul web-server, e che non puntino a pagine (aspx) o controller mvc

Per creare un custom handler in ASP.NET è sufficiente creare una classe che implementi l’interfaccia IHttpHandler

namespace WebApplication1
{
    public class MyHandler : IHttpHandler
    {
        public bool IsReusable
        {
            // Return false in case your Managed Handler cannot be reused for another request.
            // Usually this would be false in case you have some state information preserved per request.
            get { return true; }
        }

        public void ProcessRequest(HttpContext context)
        {
            context.Response.Write("ciao!");
            context.Response.Flush();
        }
    }
}

per l’utilizzo, questo handler va poi registrato nel web.config, nella sezione system.webserver per IIS o IIS-express (o nella vecchia sezione system.web se usiamo il web-server demo di VS il Cassini)

<system.webServer>
<handlers>
    <add name="myhandler"
         path="myhandler.axd"
         verb="GET"
         type="WebApplication1.MyHandler,WebApplication1"/>
</handlers>
</system.webServer>

in alternativa, è possibile registrare l’handler in un route di asp.net (come per i controller mvc) implementando in una qualunque altra classe l’interfaccia IRouteHandler per poi tornare il corretto Handler da fare route:

public class MyHandler : IHttpHandler, IRouteHandler
{
public bool IsReusable { get { return true; } }

    public void ProcessRequest(HttpContext context)
    {
        context.Response.Write("ciao!");
        context.Response.Flush();
    }

    public IHttpHandler GetHttpHandler(RequestContext requestContext)
    {
        return this;
    }
}

regitriamo il route nell’application start del file Global.asax (nel caso da aggiungere tramite il tool add-new item)

protected void Application_Start(object sender, EventArgs e)
{
RouteTable.Routes.Add(new Route("handler/my", new MyHandler()));
}

se però nel nostro handler abbiamo bisogno di avere accesso alla sessione utente, eventualmente per usarla come scambio temporaneo di un parametro ID o simili – si sconsiglia di metterci dentro valori di grande dimensioni come elaborazioni e dati DB – alternativamente a passare parametri in query-string ovviamente visibili all’utente, dobbiamo implementare anche una ulteriore interfaccia: IRequiresSessionState

public class MyHandler : IHttpHandler, IRouteHandler, IRequiresSessionState
{
public bool IsReusable { get { return true; } }

    public void ProcessRequest(HttpContext context)
    {
        context.Response.Write(context.Session["SESSION START TIME"]);
    }

    public IHttpHandler GetHttpHandler(RequestContext requestContext)
    {
        return this;
    }
}

e aggiornare – ad esempio – il global.asax per aggiungere un parametro in sessione

protected void Session_Start(object sender, EventArgs e)
{
Session["SESSION START TIME"] = DateTime.UtcNow;
}

avendo questo risultato:

a presto

The session has been terminated because of excessive transaction log space usage. Try modifying fewer rows in a single transaction.

2013-02-18T13:01:00Z

Ciao a tutti

a quanto pare la migrazione su SQL Azure di un DB di produzione di vari milioni di righe mi provoca più di un problema serio

SQL Azure ha un limite di 2GB (http://social.technet.microsoft.com/wiki/contents/articles/1541.windows-azure-sql-database-connection-management.aspx) per commit sul transaction-log… e questo vale anche per le create-index

Questo il testo dell’articolo completo:

Long Transaction Limits

Log Bytes Used
Current mechanism
SQL Database supports transactions generating log of up to 2 GB in size. Example operations that can consume log space in this volume:
insert, update, delete, merge, create index
Error returned
40552 : The session has been terminated because of excessive transaction log space usage. Try modifying fewer rows in a single transaction.
Limit
Logspace per transaction : 2 GB
Type of requests throttled
DDL (Create, Drop, …)
DML (Insert, Update, Delete, Merge, Select)
Recommendations
To avoid getting throttled for row operations, reduce the size of data in your transaction, for example by reducing the number of rows or splitting the operation into multiple transactions. To avoid getting throttled for table/index operations that require a single transaction, ensure that the following formula is adhered to:

number of rows affected in table * (avg size of field being updated in bytes + 80) < 2 GB

(In case of index rebuild, avg size of field being updated should be substituted by avg index size)

In pratica: non si possono eseguire operazioni che nel transaction-log superino i 2GB di dimensione…. si ma io ho una tabella di 12GB solo di dati più indici, come faccio a aggiungere un indice se questo ovviamente pesa più di 2GB?!?!

boh… attualmente non ho risposta…. mi sa ke per fare questa demo farò un cluster SQL sullo IaaS mettendo il fido 2012 che funziona davvero benino…..

se dovessi trovare il modo x farlo andare su sql azure, vi scriverò!

a presto

SQL Export Data Tier Application su Azure (CI RISIAMO!), valori mancanti…

2013-02-18T11:50:00Z

Ciao a tutti

la scorsa volta ho scritto del fatto che alcuni blob salvati su SQL Server 2012 in locale, una volta esportati su SQL Azure tramite l’Export come bacpac (Export DataTier Application), avevano valori sbagliati, immagini sovrascritte l’una con l’altra, etc…

Ieri sera invece ho rifatto export di un altro DB senza blob dentro, ma con quasi 100 milioni di righe con dati GIS al suo interno (in realtà i dati non usano alcuna colonna GIS di SQL)

Ho eseguito questa query sul SQL locale (2012 developer)

SELECT sys.objects.object_id, convert(int, SUM(reserved_page_count) * 8.0 / 1024) as [KB SIZE]
FROM sys.dm_db_partition_stats, sys.objects
WHERE type_desc = 'USER_TABLE' and sys.dm_db_partition_stats.object_id = sys.objects.object_id
GROUP BY sys.objects.object_id
order by sys.objects.object_id;

sulla sx l’ID della tabella (il nome l’ho nascosto per una questione di privacy del cliente), sulla dx la dimensione della tabella in KB

RISULTATO LOCALE:

78623323    26
82099333    1
146099561    0
526624919    12
590625147    0
741577680    22065
942626401    139
1269579561    1565
1461580245    0
1490104349    108
1762105318    0
1781581385    0
1877581727    0

RISULTATO DELL’EXPORT BACPAC su SQL Azure:

501576825    0
533576939    0
565577053    1902
597577167    0
629577281    18888
661577395    0
693577509    0
725577623    0
757577737    0
789577851    0
821577965    0
853578079    0
1397580017    0

sono ovviamente cambiati gli ID, ma anche solo con tutti quegli “0”, qualcosa già non torna……

Ragazzi non ci siamo proprio x niente! il tool va assolutamente aggiornato/aggiustato!

a presto

SQL Export Data Tier Application su Azure, Varbinary duplicati….

2013-02-10T15:40:00Z

Ciao a tutti

ebbene si, ho perso 4 ore per capire dove fosse il problema nella mia applicazione che stranamente mostrava la stessa foto per immagini diverse, alla fine ho capito che il problema era che davvero c’erano le stesse foto nel DB…

Analizzato il DB su Azure, ho scoperto che questo era SBAGLIATO!

A questo punto non posso che dedurre che l’errore è generato dalla combinazione “Export DataTier Application” + “Import DataTier Application” tra SQL 2012 e SQL Azure… assurdo

Per fare il test ho lanciato questo script:

select PhotoID, FileName, DATALENGTH(Picture)
from photos"

Risultato in locale:

3    be04af21-4d45-4908-a0e0-85f59a828240.jpg    1347211
5    729dc91a-ed65-4752-bcd1-cbab163fe3ff.jpg    2893370
14    f5ef2254-9d90-4fac-92b7-315410c652cc.jpg    2415767
38    ca4bd437-bd9a-47bf-bba5-aa996111426d..jpg    4960505
40    e14597b2-6f3c-4e06-9473-960ae6d39744..jpg    4395986
41    d2d2ca93-cd3e-4e7a-a8aa-5af05606db15..jpg    3521621
42    190228e8-e1b6-493e-b4be-fb39b4f7490f..jpg    6301710
43    7d277199-4e90-44ae-819e-228d46aede3c..jpg    5312837
44    d35849b2-8de7-43fa-80a4-1a2053b37ad6..jpg    2738910
45    da553259-70ce-41ec-bc9a-cea7907c1ffb..jpg    17016593
46    657bd0b1-ff15-4065-ae5c-3afe3609ef78..jpg    8823802
47    abe6794a-394c-47df-8e26-ec7e8163b912..jpg    3174525
49    283e0124-9bd6-466d-bf2b-6af4a564b307.jpg    2749057
…

Risultato su SQL Azure:

3    be04af21-4d45-4908-a0e0-85f59a828240.jpg    1347211
5    729dc91a-ed65-4752-bcd1-cbab163fe3ff.jpg    2893370
14    f5ef2254-9d90-4fac-92b7-315410c652cc.jpg    2415767
38    ca4bd437-bd9a-47bf-bba5-aa996111426d..jpg    4960505
40    e14597b2-6f3c-4e06-9473-960ae6d39744..jpg    4960505
41    d2d2ca93-cd3e-4e7a-a8aa-5af05606db15..jpg    3521621
42    190228e8-e1b6-493e-b4be-fb39b4f7490f..jpg    4960505
43    7d277199-4e90-44ae-819e-228d46aede3c..jpg    4960505
44    d35849b2-8de7-43fa-80a4-1a2053b37ad6..jpg    2738910
45    da553259-70ce-41ec-bc9a-cea7907c1ffb..jpg    4960505
46    657bd0b1-ff15-4065-ae5c-3afe3609ef78..jpg    4960505
47    abe6794a-394c-47df-8e26-ec7e8163b912..jpg    3174525
49    283e0124-9bd6-466d-bf2b-6af4a564b307.jpg    2749057

…

dell’ultimo resultset, l’unica len corretta era quella dell’ID 38….

che assurdo comportamento!

non mi resta che sincronizzare i due DB a mano….

a presto

WPReborn–Integrazione con il sistema operativo! Launchers & Choosers

2013-01-28T20:45:00Z

ciao a tutti

ringrazio tutti coloro che mi hanno seguito oggi con la sessione introduttiva allo sviluppo per Windows Phone 8

abbiamo parlato di Launchers e di Choosers

ma anche della filosofia dietro il look&feel delle app per WP8

subito sotto relativi esempi

DOWNLOAD (SLIDE + DEMO)

a presto

Intel dual-core vs Intel quad-core

2013-01-19T11:57:00Z

Ciao a tutti

Le cpu Intel di ultima generazione (Ivy-Bridge) nascondono un piccolo dilemma

Ovviamente si fa per dire..

Credo che tutti noi si sia chiesti ad un certo punto nel voler acquistare un notebook “compro un dual-core?” “o un quad-core?”

La risposta spesso è nel nostro animo… compro il quad perché è più grosso….

Perché, dobbiamo dirlo, che senso ha acquistare un quad-core su un portatile business per poi scriverci una lettera in word, e andare su facebook?!?!

Ma rimaniamo sul piano tecnico: questi i benchmark di http://www.notebookcheck.net/ dei grandi nel settore dei portatili, hanno ottime recensioni di notebook CPU, GPU, etc…

Mettiamo a confronto l’i7-3520m (il più potente dual core), con l’i7-3720qm (un quad di fascia medio-alta) con questi benchmark:

Super PI-1M (calcola il pi-greco in maniera lineare, quindi senza multi-threading, perfetto per far andare la nostra CPU in Turbo)
3DMark 06 (tipico benchmark multithreading e multipurpose)

Risultati (benefit-velocità):

	Mono-Thread (Turbo)	Multi-Thread
3520m	10.4	4081.6
3720qm	(+1 %) 10.3	(+ 38%) 6581.0

Quindi, si può affermare che a meno di usare tutti i cores, ed i thread (hyper-thread) delle CPU, il quad-core è identico al dual-core…

Mentre se abbiamo veramente modo di usare tutti i core della nostra CPU, allora, avremo un +38% di potenza in più

a presto

WCF WebApi! Come creare un framework in standard WebApi con WCF, completamente da zero!

2012-12-23T20:54:00Z

ciao a tutti

ringrazio tutti coloro che mi hanno seguito nella sessione WCF, ASP.NET & NancyFX WebApi all’evento API for Mobile Code Cage

le Web Api sono uno standard, attualmente poco formalizzato, di programmazione distribuita basata su protocollo REST

vengono messi a confronto con un’implementazione parallela (le soluzioni hanno identiche api) tre diverse tecnologie

Questi gli esempi completi di come WCF se l’è cavata! e devo dire, anche molto bene

benché per far funzionare il tutto in ottica MVC (si, ho fatto funzionare WCF in MVC, senza usare asp.net mcv), mi abbia richiesto di riscrivere alcuni componenti essenziali di WCF stesso…..

per scaricare slides ed esempi, clicca QUI

a presto

Transazioni, ACID, SOA & WS-AT…. comuni incomprensioni… una chiara spiegazione

2012-11-28T22:19:00Z

Ciao a tuti

approfitto di questa occasione per fare una delle mie solite digressioni, questa volta sulle transazioni

Inizio con il dire che “transazione” è un modo di dire generico, quasi un diminutivo, di una frase ben più completa che è “transazione atomica”

Le due parole significano quindi “un insieme di comandi” (transazione), eseguiti in maniera “imprescindibile” (atomica)

Degli esempi tipici sono: ho una fattura composta da dettaglio (intestazioni, etc) e corpo (le voci)… se devo persistere su uno storage (un DB) questo insieme di cose, quasi certamente dovrò farlo in maniera transazionale, perché è assurdo pensare di persistere una fattura con qualche riga in meno del dovuto, per gli ovvi motivi

Una transazione è quindi un contenitore di comandi, che ha il compito di garantirne l’esecuzione atomica, e per farlo esegue più compiti (che quindi hanno dei costi in termini di infrastruttura e di risorse), che in genere possono essere riassunte in:

le singole operazioni vengono eseguite
viene analizzato il risultato delle singole operazioni
se tutte danno esito positivo un comando di persistenza (in genere detto “commit”) della transazione viene eseguito per dare il verde a tutte le operazioni
altrimenti, se una qualunque operazione ha dato esito negativo, tutte le operazioni vengono annullate (in gergo detto “rollback”)

ACID

Lo standard di definizione di una transazione è dato dall’acronimo ACID, che sta per:

Atomic: le operazioni contenute nella transazione sono imprescindibili, o tutte vanno a buon fine, o tutte vengono annullate al fallimento di una qualunque di esse

Consistent: le operazioni delle transazioni sottostanno al modello dati su cui vengono persistite (es sui DB referenziali, vengono rispettate tutte le constraint), se una qualunque operazione della transazione non è valida nei confronti del modello dati, tutta la transazione viene annullata

Isolated: ogni transazione, se eseguita in contesto concorrente con altre transazioni, deve essere isolata dalle altre in modo da garantire una esecuzione congrua dall’inizio fino alla fine dei comandi contenuti nella stessa transazione; è anche garantito che il fallimento di una transazione non influisca su altre transazioni in corso di esecuzione

Durable: l’engine che esegue la transazione si impegna a garantire il salvataggio dei dati (che viene dato quindi per certo) una volta richiesto il comando di persistenza di tutte le operazioni contenute nella transazione

All’interno di una transazione, va detto che esiste in gergo un “isolation level”, un livello di isolamento che configura il come la transazione interagisce con altre transazioni, come se e quanto vengano viste le modifiche in corso in una transazione da un’altra transazione, etc.. QUI è possibile averne una spiegazione.

Le transazioni in genere si eseguono nei confronti di un singolo motore di persistenza di dati (in genere un DB), ma anche una coda (queue, es. MSMQ), o altri sistemi

Le transazioni possono essere innestate (transazioni di transazioni), ed infine esistono anche transazioni distribuite, quelle che eseguono transazioni innestate nei confronti di più sistemi (es. 2 diversi database).

Nelle transazioni singole (verso un unico DBMS), esistono 2 approcci per implementare la transazione:

Write-ahead logging: le operazioni di modifica (e)[in base al DBMS] i dati originali (in caso di update) vengono scritte su un file di log e non sul file primario del database. Questo garantisce il commit se tutto va bene, il rollback in caso di errore, il “redo” (secondo tentativo) in caso di BSOD del sistema o crash del DBMS. La pulizia del file di log è impostata sempre dal DBMS.
Shadow-paging: i dati del DB vengono suddivisi in pagine. eventuali modifiche da persistere vengono scritte su una pagina a parte, e solo alla commit della transazione, la pagina viene accodata (in caso di insert), o sovrascritta (in caso di update), o rimossa (in caso di delete) dal file primario del DBMS

Per eseguire queste operazioni, i DBMS utilizzano dei LOCK, dei blocchi a vari livelli, impostati per sincronizzare l’accesso alle risorse

Se più connessioni al DB eseguono transazioni sulle stesse tabelle, il DB utilizzando i lock sulla tabella intera, su un gruppo di righe, o sulla singola riga, riesce a coordinare l’accesso a queste informazioni. Quale di questi lock usare, se usarli, etc, è scelto dal DBMS anche in base al livello di isolamento utilizzato

Transazioni distribuite

Differente è l’approccio utilizzato quando si utilizzano transazioni “distribuite”, che quindi agiscono su più sistemi (es. un software deve chiamare in contemporanea 2 diversi WebServices, o un WS ed un DB, o 2 diversi DB):

In questo caso l’approccio utilizzato principalmente è quello della cosidetta 2PC (two phase commit). Questa è in pratica l’ACID in ottica distribuita. La differenza è il fatto che tutte le operazioni vengono fatte nei confronti di sistemi, che poi in autonomia implementano la loro transazionalità, quindi ad esempio sql server fa il suo dentro di se, oracle il suo, e la transazione distribuita serve per coordinare i due nodi.

La 2PC è suddivisa in 2 fasi (dal nome si evinceva…)

Voting phase: il coordinatore chiede a tutti i partecipanti la transazione (i sistemi) di fare il loro compito tornandone lo stato (successo, fallimento)
Completion phase: il coordinatore analizza i risultati dei partecipanti (detti anche i Voti) e decide se mandare un messaggio di conferma a tutti i partecipanti, o di annullamento, se uno qualunque vota NO, o non vota (e va in timeout)

Nel realizzare WebServices transazionali, che utilizzino il protocollo SOAP, il supporto alla 2PC è dato dai protocolli WS-AT (AtomicTransaction) e WS-Coordination, dove il secondo è il protocollo della gestione del contesto distribuito (in pratica l’attivatore della transazione), ed il primo è un protocollo che virtualizza l’ACID tramite il contesto di coordinamento.

Infine va detto che la quasi totalità dei sistemi nel mondo Microsoft utilizza il Microsoft il DTC (distributed transaction coordinator) per eseguire RPC (remote procedure call) in maniera distribuita e transazionale tra i vari sistemi (es. SQL Server, WS SOAP, etc).

SOA & Transazioni

Non si può avere enterprise senza transazioni, e difficilmente lo si può avere senza SOA, quindi pensare che questi due pilastri dell’enterprise non possano coesistere è assurdo. Una transazione in un contesto SOA ha i seguenti risultati:

Irrobustisce l’ambiente
Rende l’ambiente a servizi più coeso (più fiducia in service-composition)
Aumenta l’integrabilità di sistemi eterogenei facenti parte dello stesso ambiente a servizi
Aumenta i costi di infrastruttura per il maggior numero di messaggi interscambiati

Ma, anche se il punto 4 è un “contro”, va ricordato uno dei principi (diciamo pure capisaldi) del SOA: “Service Composability”, che enuncia: "Services are effective composition participants, regardless of the size and complexity of the composition."

Il significato, secondo Thomas Erl, non è solo che i servizi devono poter essere in grado di essere composti tra di loro, essere richiamabili a cascata, etc, ma anche essere in grado di farlo, senza perdite in latenza, numero di messaggi processati, etc… quindi, pensare di poter fare SOA, senza la potenza e la capacità di gestire migliaia o milioni di messaggi è impossibile, e quindi si può dire che l’unico contro è in realtà incluso per definizione nelle specifiche del SOA stesso.

Comunque, riguardo ai principi, usare transazioni nel SOA apporta, secondo la mappatura dei principi del SOA di Erl, benefici ai seguenti principi:

Service Composability
Service Interoperability
Quality of service

Più precisamente: se una operazione di business è in (contiene una) transazione, questa definisce un contesto di coordinamento, e questi garantiscono funzionalità transazionali ai WebServices

Citando sempre Thomas Erl nel suo famoso libro “SOA Priciples of Service design”, al punto 6.4.5 leggiamo:

“Much of the transactional funciontality implemented in service-oriented solutions is done so among the components that execute an activity on behalf of a single service. However, as more services emerge within an organization and as service compositions become more commonplace, the need to move transaction boundaries into cross-service interaction scenarios increases. Being able to guarantee an outcome of an activity is a key part of enterprise-level computing, and atomic transactions therefore play an important role in ensuring quality of service.”

E continua:

“Not only do atomic transactional capabilities lead to a robust execution environment for SOA activities, they promote interoperability when extented into integrated environments. This allows the scope of an activity to span different solutions built with different vendor platforms, while still being assured a guaranteed all-or-nothing outcome.

Assuming, of course, that WS-AtomicTransaction is supported by the affected applications, this option broadens the application of the two-phase commit protocol beyond traditional application boundaries (thus, supporting service interoperability).”

Transazioni & REST

Mi spiace, ma REST non supporta niente di quanto detto finora…

REST è un WebService puro, in pratica si rifà alla sicurezza del webserver, al caching del webserver… in pratica il protocollo non supporta quasi niente di suo visto che per quasi ogni cosa si poggia sul webserver (IIS nel mondo Microsoft), e visto che non possiamo richiamare pagine Html tramite HTTP in maniera transazionale, non possiamo nemmeno chiamarne API (WebApi, o chiamate REST che siano)

Infatti nelle specifiche di questo tipo di servizi è specificato di non usare transazioni, non usare sessioni, non usare stati… e per quel tipo di servizi è più che corretto! oltre che comunque una buona practice, sempre per quel tipo di servizi (quelli REST)…..

Saluto tutti i lettori che hanno avuto la voglia di leggere fin qui

A presto

WPC 2012 – Grazie 1000 – DEMO & SLIDES

2012-11-27T08:39:00Z

Ciao a tutti

Inizio subito col dire “Grazie” a tutti i partecipanti che mi hanno ascoltato (o sorbito), ed a tutti gli organizzatori che mi hanno accolto nuovamente quest’anno al mitico WPC

Mi dispiace non aver potuto assaporare tutte le giornate di WPC quest’anno per motivi di lavoro (ovviamente), ma posso sicuramente dire che la giornata trascorsa in vostra compagnia è stata una giornata felice!

Si è respirato aria di famiglia… e questo è il più bel complimento che io possa mai fare!

Qui di seguito SLIDES E DEMO

A presto

Anto

Real world SOA for .NET 4.5–SLIDES & DEMO

2012-11-21T13:21:00Z

Ciao a tutti

Ringrazio il Codemotion Venezia 2012 per aver ospitato la mia sessione dedicata allo sviluppo di servizi

qui di seguito i link per scaricare SLIDES e DEMO

a presto