.NET, ASP.NET, Ottimizzazione, Security, XSS Cross Site Scripting, News, Architettura, Cache, Distributed Caching, Scalabilità, Velocity, Beta, Configurazione, Framework 4.0, Windows Communication Foundation, .NET RIA Services, Silverlight, .NET Framework 4.0, Visual Studio 2010, Webcast, Historical Debugger, Dexter, IIS, Linq, LinqToNHibernate, Nhibernate, .NET Services, Azure, SQL Azure, Windows Azure, QConf, Project Manager, Technical Lead, Deploy, HttpModule, SEO

Da poche settimane è stata rilasciata la versione 3.0 della libreria Microsoft Anti-Cross Site Scripting, che introduce numerose novità.
Per chi non la conoscesse, si tratta di una libreria che facilita l’utente nella prevenzione di attacchi di tipo XSS (Cross Site Scripting) alle proprie applicazioni web.

Nello specifico questa libreria è composta da una serie di metodi come l’HtmlEncode, UrlEncode, JavascriptEncode, ecc, che offrono un controllo maggiore sulle stringhe rispetto agli analoghi metodi presenti nel .NET Framework.

Maggiori informazioni sono presenti sul blog del Team qui, il download è invece disponibile direttamente sul sito Microsoft qui, mentre sotto potete trovare un video che ne descrive le nuove funzionalità.

continue...

This entry was posted on Thursday, 30 July, 2009 and is filed under ASP.NET . You can follow any responses to this entry through here . You can leave a response.

Su Channel9 è uscita un’ottima registrazione di un’intervista a Scott Hanselman che spiega come rendere scalabile un’applicazione web grazie al caching; nello specifico si discute di strategie di caching in applicazioni distribuite con Velocity di Microsoft.

Di Seguito potete trovare la registrazione.

continue...

This entry was posted on Tuesday, 28 July, 2009 and is filed under ASP.NET . You can follow any responses to this entry through here . You can leave a response.

Nello sviluppare Dexter ho avuto diversi problemi con la cache che, per cause non mie, non ne voleva sapere di andare, al contrario di quello che succede nell’ambiente di sviluppo dove funziona alla grande.

Nello specifico il problema consiste nel fatto che, spesso, gli oggetti inseriti precedentemente in cache risultano nulli, venendo quindi rimossi.

I motivi per cui un oggetto può essere rimosso dalla cache sono decisamente pochi:

• rimozione manuale tramite codice;
• Shoutdown causa riciclo o crash del worlprocess;
• fine della memoria disponibile.

Dato che sono certo di non aver svuotato la cache via codice J, la ricerca del problema si è subito spostata sulla seconda ipotesi, e mi son messo a loggare lo shoutdown lato applicativo, non avendo accesso al server.

Sfortunatamente questa non è cosa semplice perchè non è detto che il WorkProcess non venga “killato” manualmente sul server, oppure che un’altra applicazione presente all’interno dello stesso application pool non provochi un’eccezione che termini il processo.

ScottGu, nel suo blog, propone una possibile soluzione che consiste nell’invocare via reflection i metodi _shutDownMessage e _shutDownStack, che forniscono tutte le informazioni per capire il motivo che ha scatenato lo shoutdown, come mostrato di seguito.

public void Application_End()
{

    HttpRuntime runtime = (HttpRuntime)typeof(System.Web.HttpRuntime).InvokeMember("_theRuntime",BindingFlags.NonPublic| BindingFlags.Static| BindingFlags.GetField,null,null,null);

    if (runtime == null)
        return;

    string shutDownMessage = (string)runtime.GetType().InvokeMember("_shutDownMessage",BindingFlags.NonPublic| BindingFlags.Instance| BindingFlags.GetField,null,runtime,null);

    string shutDownStack = (string)runtime.GetType().InvokeMember("_shutDownStack",BindingFlags.NonPublic| BindingFlags.Instance| BindingFlags.GetField,null,runtime,null);
    
    Logger.Error(shutDownMessage, shutDownStack);
}

Maggiori info le trovate qui.

This entry was posted on Sunday, 26 July, 2009 and is filed under ASP.NET . You can follow any responses to this entry through here . You can leave a response.

Mentre pianificavo il deploy di una nuova versione di Dexter, mi è venuto in mente di realizzare un HttpModule che bloccasse l’accesso al sito a tutti clients non provenienti da un determinanto indirizzo IP, reindirizzandoli verso una pagina temporanea che comunicava all’utente che era in corso un aggiornamento.

Fin qui nulla di particolare, un semplice HttpModule che  verifica IPAddress del client e, nel caso questo non sia presente nella “white list”, effettua un semplice redirect.

Ma cosa accade nel caso in cui un crawler di un search engine passi in quel determinato momento?

Una buona soluzione è quella di comunicare al bot che il sito non è momentaneamente disponibile e di rimandare la fase di crawling.

Per far ciò una possibile soluzione consiste nell’effettuare il redirect di ogni pagina verso un’altra, ed impostare uno status code differente, così che il search engine non sostituisca nell’indice il contenuto della pagina richiesta con quello della pagina temporanea.

Ma quale status code è più adatto a questo tipo di operazione?

Leggendo da W3C, un possibile status code sarebbe il “503 Service Unavailable”, ma questo non è customizzabile come spiegato qui:

The 503 error cannot be customized because they are handled in the kernel mode by HTTP.sys. This means that user-mode routines cannot be run.

Una soluzione alternativa è effettuare un “302 Found” ad una pagina html custom, che verrà esclusa dall’indicizzazione tramite l’apposito file Robots.txt.

Il redirect con status code 302 indica al client che il contenuto è stato spostato solo temporaneamente verso il nuovo indirizzo, e che successivamente potrà trovarlo nuovamente al vecchio url.

Questo permette di reindirizzare il client verso una pagina esclusa dall’indicizzazione.

Di seguito potete trovare il codice e l’apposita area di configurazione del HttpModule.

public class MaintenanceModule : IHttpModule
{
    #region IHttpModule Members

    public void Dispose()
    {
    }

    public void Init(HttpApplication context)
    {
        if (MaintenanceConfiguration.Instance.EnableMaintenance)
            context.BeginRequest += context_BeginRequest;
    }

    #endregion

    private void context_BeginRequest(object sender, EventArgs e)
    {
        HttpContext context = HttpContext.Current;

        if (context.Request.Url.AbsolutePath == MaintenanceConfiguration.Instance.AbsolutePagePath)
            return;

        if (MaintenanceConfiguration.Instance.AllowedIP.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries).Contains(context.Request.UserHostAddress))
            return;

        context.Response.StatusCode = 302;
        context.Response.Cache.SetCacheability(HttpCacheability.NoCache);
        context.Response.AddHeader("Location", MaintenanceConfiguration.Instance.AbsolutePagePath);
    }
}

/// <summary>
/// Maintenance Configuration class.
/// </summary>
public static class MaintenanceConfiguration
{
    private static readonly MaintenanceConfigurationSection section;

    /// <summary>
    /// Initializes the <see cref="MaintenanceConfiguration"/> class.
    /// </summary>
    static MaintenanceConfiguration()
    {
        section = ConfigurationManager.GetSection("dexter.maintenance.configurationSection") as MaintenanceConfigurationSection;

        if (section == null)
            throw new MaintenanceSettingException("Maintenance section not found in the configuration file.");
    }

    /// <summary>
    /// Gets the instance of MaintenanceConfigurationSection class.
    /// </summary>
    /// <value>The instance.</value>
    public static MaintenanceConfigurationSection Instance
    {
        get { return section; }
    }
}

/// <summary>
/// Log Configuration Section class.
/// </summary>
public sealed class MaintenanceConfigurationSection : ConfigurationSection
{
    [ConfigurationProperty("enableMaintenance", DefaultValue = false, IsRequired = true)]
    public bool EnableMaintenance
    {
        get { return (bool) this["enableMaintenance"]; }
        set { this["enableMaintenance"] = value; }
    }

    [ConfigurationProperty("allowedIP", IsRequired = true)]
    public string AllowedIP
    {
        get { return (string) this["allowedIP"]; }
        set { this["allowedIP"] = value; }
    }

    [ConfigurationProperty("absolutePagePath", IsRequired = true)]
    public string AbsolutePagePath
    {
        get { return (string) this["absolutePagePath"]; }
        set { this["absolutePagePath"] = value; }
    }
}

public class MaintenanceSettingException : Exception
{
    /// <summary>
    /// Initializes a new instance of the <see cref="MaintenanceSettingException"/> class.
    /// </summary>
    /// <param name="message">The message.</param>
    public MaintenanceSettingException(string message) : base(message)
    {
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="MaintenanceSettingException"/> class.
    /// </summary>
    /// <param name="message">The message.</param>
    /// <param name="innerException">The inner exception.</param>
    public MaintenanceSettingException(string message, Exception innerException) : base(message, innerException)
    {
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="MaintenanceSettingException"/> class.
    /// </summary>
    /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
    /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
    /// <exception cref="T:System.ArgumentNullException">
    /// The <paramref name="info"/> parameter is null.
    /// </exception>
    /// <exception cref="T:System.Runtime.Serialization.SerializationException">
    /// The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
    /// </exception>
    public MaintenanceSettingException(SerializationInfo info, StreamingContext context)
        : base(info, context)
    {
    }
}

<dexter.maintenance.configurationSection 
            enableMaintenance="true" 
            allowedIP="127.0.0.1" 
            absolutePagePath="/Maintenance.aspx" />

Ciauz

This entry was posted on Thursday, 23 July, 2009 and is filed under ASP.NET . You can follow any responses to this entry through here . You can leave a response.