Timeout för kö-meddelanden i Windows Azure

En fråga som har dykt upp många gånger sista tiden i mitt projekt men som vi aldrig sök upp svaret på är hur det funkar med timeout för meddelanden i en kö i Windows Azure Queue Storage. Windows Azure garanterar att meddelanden som placeras i köer kommer att hanteras minst en gång. När man gör ett GET-anrop via REST, alternativt GetMessage() från StorageClient, kan man skicka med en alternativ parameter som sätter hur lång tid timeouten ska vara. Om man inte har tagit bort meddelandet innan tiden för timeouten så dyker meddelandet upp på kön igen.

var message = c.GetMessage(TimeSpan.FromSeconds(10));

Om man inte anger någon tid sätts den till 30 sekunder vilket också är maxtiden för ett meddelande idag. Det har pratats om att möjliggöra längre intervall men det har ännu inte dykt upp. Oavsett hur lång tid man skulle kunna sätta måste applikationer byggas så att dess funktioner är idempotenta. Med idempotent menas att om man anropar en funktion två gånger ska det ge samma resultat, f(f(x)) = f(x).

Ett exempel kan vara att en worker role hämtar ett meddelande och börjar hantera det. När den är klar ska det utföras en loggning till Azure Table Storage som av någon anledning tar väldigt lång tid eller misslyckas. Då dyker meddelandet upp på kön igen och en annan instans av samma worker role kan få tag i meddelandet och påbörja att hantera det på nytt. Då måste applikationen hantera den situationen och inte förändra slutresultatet.

Azure Development Storage i SQL Server 2008 R2

Sista tiden har jag utvecklat en hel del mot Windows Azure i Visual Studio 2010 och om man som jag inte gillar SQL Express utan vill använda SQL Server 2008 R2 till Development Storage är det väldigt enkelt att fixa till det. När man startar ett Windows Azure projekt första gången skapas en lokal SQL Server Express-databas med tabeller för köer, blobbar och tabeller. För att istället skapa databasen i en icke-express-variant av SQL Server måste man först själv skapa databasen som behövs med hjälp av ett program i Windows Azure SDK.

I katalogen C:\Program Files\Windows Azure SDK\v1.0\bin\devstore finns filen dsinit.exe. Det är den som exekveras när man startat ett Azure projekt första gången och skapar upp databasen. Starta en command prompt och exekvera dsinit.exe enligt följande för att installera den på default-instasen:
dsinit.exe /sqlinstance:.

Eller om man vill installera den på en namngiven instans:
dsinit.exe /sqlinstance:myLocalInstance

Updatera sedan DSService.exe.config och lägg till attributet dbServer enligt nedan:

<service name="Blob" url="http://127.0.0.1:10000/" dbServer="ComputerName\NamedInstance"/>
<service name="Queue" url="http://127.0.0.1:10001/" dbServer=" ComputerName\NamedInstance "/>
<service name="Table" url="http://127.0.0.1:10002/" dbServer=" ComputerName\NamedInstance "/>

Man kan också använda dsinit.exe om man vill rensa allt innehåll i databasen, dvs tömma köer, blobbar och tabeller med:
dsinit.exe /sqlinstance:myLocalInstance /forceCreate

Det finns en del forum, blogger och liknande som hänvisar till att man ska göra ändringarna i DevelopmentStorage.exe.config men det var det gamla namnet och numera heter den DSService.exe.

Podcast för MSDN Radio med Dag König

Igår var jag med och spelade in en podcast med Dag König från Microsoft för MSDN Radio. Vi samlades runt en soptunna och pratade om vad vi hade upplevt så långt på PDC09. Den finns att ladda ner på http://bit.ly/1ooTeW

Som alltid gör Dag ett lysande jobb som intervjuare och gör det väldigt enkelt att vara med som deltagare!

PDC 2009 – Pre conference workshop

Första dagen spenderade jag på en workshop med kille från Nya Zeeland (Chris Auld) som pratade om Windows Azure. Architecting and Developing for Windows Azure och där och då bestämde jag mig för att mitt fokus skulle helt och hållet ligga på Windows Azure under veckan. Det har inte riktigt gått att hålla fullt ut eftersom att en del sessioner har visat sig för tråkiga eller för att andra har varit för intressanta för att missa.

Förra veckan släpptes Nov SDK för Windows Azure med flera nyheter. B la så går det nu att använda Visual Studio 2010 för att bygga applikationer för Azure men än så länge är det bara .NET Framework 3.5 SP1 som stöds. .NET 4 kommer så klart inom kort. En annan nyhet är att Worker Roles nu också kan ta emot externa anrop. Tidigare har det bara varit Web Role som kunnat göra det men nu alltså även Worker Role. Vad innebär då det? Vad är det för skillnad då på en Web och en Worker? En skillnad är att en Web Role är hostad i IIS vilket en Worker Role inte är. Det skulle då t ex kunna innebära att du skulle kunna bygga din egen web server och hosta den i en Worker Role.

En annan nyhet i Nov SDK är att det nu också finns stöd för scale up, dvs olika storlekar av virtuella maskiner.

Under Chris dragning blev det också tydligt att det är applikationer som kräver möjlighet till elasticitet eller extrem ökning av krav på resurser som lämpar sig bäst för Azure. Detta är för att den största anledningen till att flytta eller bygga en applikation på en molnplattform är en ekonomisk och inte en teknisk. Det pratas dock om att det kan komma en annan prismodell för applikationer som inte kräver lika stor flexibilitet eller last där man kanske betalar en fast månadskostnad och då inte har samma möjligheter att skala upp men mer om det när det närmar sig årsskiftet.

Windows Azure är tillgängligt idag, den 1 januari kommer det att börja synas hur mycket en körande applikation kostar och from den 1 feb så startar faktureringen.

Chris tog också upp en del patterns för utveckling av applikationer mot Windows Azure och hur de kan påverka den totala prisbilden av en applikation eftersom att delar av plattformen betalas per transaktion. Värt att tänka på är att ibland de-normalisera och duplicera data beroende på om den totala kostnaden för lagring blir billigare än kostnaden för transaktioner. Det dyker alltså upp helt nya faktorer för att fatta beslut för hur arkitekturen ska se ut för en applikation. En refactoring som inte är genomtänkt skulle t ex kunna innebära att man ökar den totala kostnaden för applikationen.

En viktig sak att tänka på när man jobbar med köer är Idempontency. För mig som inte är så mattematiskt bevandrad var det ett nytt begrepp som innebär att f(x) = f(f(x). Dvs att ett anrop till en funktion ska alltid ge samma resultat oavsett om den anropas flera gånger. Windows Azure garanterar att meddelanden i en kö blir hanterade minst en gång. Så även om den VM som just nu hanterar ett meddelande går ner så kommer någon annan att hantera det meddelandet senare. Dock så kan det hända att ett meddelande blir hanterat flera gånger och vi måste hantera det i våra applikationer.

Hela konferensen är väldigt bra organiserad. Det är stora rum och aldrig något problem att få plats på en session. Enda nackdelen är att LA Convention Center är gigantiskt och det är fem – tio minuters promenad från en sal längst bort i hörnan till andra sidan. Det gör att det ibland blir svårt att hinna med alla roliga saker som Ask the Experts och Hands on Labs. Att det varje dag är lunch-sessioner gör inte direkt att man får mer tid!

Nu är det dags för en session av en av mina favorittalare: Clemens Vasters som ska prata om “Building Hybrid Cloud Applications With the Service Bus”. Senare ska jag skriva ett inlägg med länkar till de videor jag kan rekommendera.

 

Panorama från pre conference workshop

Container från ett datacenter till Windows Azure 

Seminarium om Visual Studio 2010

Idag körde Connecta och Addskills ett seminarium tillsammans om nyheterna i Visual Studio 2010. Jag höll en övergripande presentation om nyheterna i verktyget, ramverket och språken. Salong 1 på Sergel var platsen för dagen och de 512 platserna var fyllda till bredden. Fantastiskt kul att det var så många som kom!

Med mig från Connecta var också Hans Sterby och Daniel Karlsson som pratade om F# och Workflow Foundation.

Allt gick helt enligt planerna, inga demo som kraschade eller någon som tappade tråden.

Fick många frågor av vad den application launcher jag använde under presentationen heter. Det är RocketDock och finns att ladda ner på: http://rocketdock.com/

Om det är någon av er som läser det här så tar jag gärna feedback på min presentation. Något man hade velat se mer eller mindre av? Ris eller ros?

Vi kommer även att köra en repris den 22 januari och till den finns det fortfarande platser kvar. Anmäl dig här nu!

Mvh Björn

SortedSet<T> i Visual Studio 2010

En grymt bra nyhet i Base Class Library (BCL) i .NET Framework 4.0 är SortedSet<T>. Den ligger i System.Collections.Generic och implementerar funktionalitet som jag många gånger har implementerat själv. Precis som HashSet<T> som var en nyhet i .NET 3.5 erbjudet SortSet möjligheten att skapa en collection som bara innehåller unika element. Skillnaden är att SortedSet också returnerar elementen sorterade.

Det innebär att om man matar in följande i en SortedSet<String>:

static void Main(string[] args)
{
    var s = new SortedSet<string>();
    s.Add("Hello");
    s.Add("Visual Studio 2010");
    s.Add("Is");
    s.Add("So");
    s.Add("Cool");
    s.Add("Cool");
    s.Add("Cool");


    foreach (var word in s)
    {
        Console.WriteLine(word);
    }
}

Så blir output:
Cool
Hello
Is
So
Visual Studio 2010

Algoritmen som ligger bakom sorteringen i collectionen är en self-balancing red-black tree och det har jag inte tänkt ge mig in på att förklara hur det funkar. Det finns det redan någon som gjort så bra ;-)

Add-metoden på både SortetSet och HashSet returnerar true eller false beroende på om det det element som skickades in adderades till collectionen eller inte.

En annan metod som är intressant är GetViewBetween(T lowerValue, T upperValue). Om man exekverar den på ett SortedSet så får man ett subset som innehåller alla element från det som är specificerat som lowerValue till upperValue. Det som är dock inte som man skulle kunna med tanke på namnet att den returnerar alla element som ligger mellan de två värdena utan den tar även med de värden man har angett.

var s = new SortedSet<int>();
s.Add(1);
s.Add(5);
s.Add(5);
s.Add(3);
s.Add(2);
s.Add(9);
s.Add(4);
s.Add(11);


var s2 = s.GetViewBetween(4, 9);

foreach (var number in s2)
{
    Console.WriteLine(number);
}

Get då output:
4
5
9

Om man försöker lägga till ett element till s2 som är utanför gränsvärdena får man ett ArgumentOutOfRangeException.

Jag ser väldigt många användningsområden för SortedSet och ser väldigt mycket fram emot att få börja använda .NET 4.0!

Multi touch i VS2010

Touch och multi touch är något som har legat mig varmt om hjärtat senaste året. Det hela började med att vi på Connecta köpte ett Microsoft Surface-bord för snart ett år sedan. Redan då pratade Microsoft om vikten av att börja jobba med och lära sig multi touch och nu ser vi Windows 7 och WPF 4.0 komma med inbyggt stöd för multi touch.

I WPF 4.0 har man lagt till ett antal event till UIElement som rör muti touch. De berörda .NET API:er är baserar på native Win32 API som bara är tillgängliga i Windows 7. UIElement är den basklass som definierar kärnan för visuella kontroller för layout, input och events. De event som finns idag (beta 1 av VS2010) är: ManipulationStarted Event, ManipulationCompleted Event, ManipulationDelta Event, ManipulationInertiaStarting Event och ManipulationBoundaryFeedback Event. Som standard får ett UIElement aldrig händelser rörande Manipulation om inte ManipulationMode är satt till ett annat värde än None. Med hjälp av ManipulationMode kan man styra vilken typ av manipuleringar man ska kunna göra på ett objekt. Det kan t ex vara translatera på X och/eller Y-axeln, rotera, eller skala.

I beta 1 av .NET Framework 4.0 finns eventen för manipulering med men det finns inte några WPF-kontroller som använder sig av dem. I kommande versioner kommer det att man enkelt bara slå på touch-kontroller på t ex sliders eller scrollviewers direkt i XAML.

När man fångar ManipulationDelta på ett Window får man ManipulationDeltaEventArgs. Den kan man sedan använda för att ta reda på vilken förändring som har inträffat. Med metoden GetDeltaManipulation får man ut en System.Windows.Input.Manipulation som innehåller all transformationsdata som fanns när eventet inträffade. Den informationen kan man sedan använda för att utföra translateringar på objektet. Lite komplext men ett kodexempel gör det nog enklare att förstå!

Observera att ManipulationDelta aldrig kommer att exekveras med en vanlig mus utan det måste vara något slags touch device. Med hjälp av ett projekt på CodePlex som heter Multi-Touch Vista kan man simulera användandet av flera touchpunkter med vanlig mus eller touch pad.

I xaml-filen lägger jag till en bild i en canvas. Till den kopplar jag en MatrixTransform så att jag sedan kan komma åt den från kod. Jag lägger också till en event handler för ManipulationDelta.

<Window   x:Class="WpfApplication13.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Window1" Height="300" Width="300" 
        WindowState="Maximized" ManipulationDelta="Window_ManipulationDelta">
    <Window.Resources>
        <MatrixTransform x:Key="InitialMatrixTransform">
            <MatrixTransform.Matrix>
                <Matrix OffsetX="200" OffsetY="200"></Matrix>
            </MatrixTransform.Matrix>
        </MatrixTransform>
    </Window.Resources>
    <Canvas>
        <Image Width="100" Source="/WpfApplication13;component/Images/Sonicspree.jpg" ManipulationMode="All" RenderTransform="{StaticResource InitialMatrixTransform}" ></Image>
    </Canvas>
</Window>

I code behind använder jag ManipulationDelta för att flytta bilden baserat på input:

private void Window_ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
{
    var delta = e.GetDeltaManipulation(this);
    var image = e.OriginalSource as Image;
    var matrix = ((MatrixTransform)image.RenderTransform).Matrix;
    var originalCenter = new Point(image.ActualWidth / 2, image.ActualHeight / 2);

    //Translate on the x and y-axis
    matrix.Translate(delta.Translation.X, delta.Translation.Y);

    //Get the new center point and rotate around that based on the delta
    var center = matrix.Transform(originalCenter);
    matrix.RotateAt(delta.Rotation, center.X, center.Y);
    center = matrix.Transform(originalCenter);

    //Scale the matrix based on the delta
    matrix.ScaleAt(delta.Scale, delta.Scale, center.X, center.Y);

    //Apply the new MatrixTransform
    image.RenderTransform = new MatrixTransform(matrix);

    e.Handled = true;

}

Notera de två röda prickarna som symboliserar de två möss jag har koppad till den här datorn. Koden i exemplet är baserat på en video på You Tube som också visar applikationen in action.

Historical debugging

En ny feature i Visual Studio 2010 är Historical Debugging. Den funktionen erbjuder oss möjligheten att debugga applikationer som redan har kört. Det vanliga sättet att felsöka en applikation idag är att man sätter ett antal breakpoints och kör sedan sin app för att se om man fastnar eller om det smäller. Det är en procedur som ofta är väldigt tidskrävande.

Man kan jämföra Historical Debuggin med svarta lådan i ett flygplan. Med Historical Debugging påslaget information om viktiga händelser som har inträffat i applikationer under exekvering. Därifrån kan man sedan gå tillbaka till ett tillstånd när t ex ett exception inträffade eller en LINQ-fråga exekverades mot databasen och återskapa vad som hände vid just den tidpunkten.

Historical Debugging slås på under Options och man kan där också välja hur mycket information som ska sparas. Antingen bara events eller så väljer man att få hela kakan med events, metoder och parametrar. De tre knapparna under som är disablade i beta 1 visar att man kommer att kunna importera och exportera insamlat data. Det kommer att innebära att man kan exporera en debugginghistorik och dela med sig av den till en annan användare!



Tyvärr ser det ut som att Historical Debugging bara kommer att finnas med som en feature i Developer och Test-versionerna av Visual Studio Team System 2010. Det är tråkigt men förståeligt för att utöka användandet av Team System.

Efter det att exekveringen av applikationen är klar och data är insamlat kan man välja var i listan man vill ”gå in i” applikationen igen. Därifrån kan man sedan enkelt steppa vidare i koden och se exakt vad som händer. Med Historical Debugging påslaget kommer det också att vara möjligt att stega bakåt vid vanlig debugging.

Förutom att det finns stöd i Visual Studio kommer det även att finnas stöd i Camano som är en ny test case management-klient. Det innebär att en testare kan köra applikationen i Camano och, direkt från det verktyget, leverera en felrapport till Team Foundation Server. Utvecklaren kan sedan plocka upp den rapporterade buggen, använda data från Historical Debugging och pdb-filer med källkod för att se exakt vad det var testaren såg när felet inträffade.

Dags att använda nUnit igen...

För ett par dagar sedan började jag jobba med NUnit igen. Sista tiden har jag använt mig av Visual Studios unit testing men nu ska vi använda oss av NUnit i projektet som jag sitter i. Det första jag gjorde var att lägga till tangentbordsgenvägar för att kunna köra respektive debugga det test som är i fokus (CTRL +R, T och CTRL + R + T) samt genväg för att köra alla test i en solution (CTRL + R, A). Can’t live without them! Som tur var så använder jag mig av ReSharper som också har en integrerad test runner i Visual Studio.

Sedan skapade jag ett nytt class library och la till referens till nunit.framework och konverterade ett par test som var skrivna med Visual Studios testramverk till NUnit.

En sak som jag alltid har gillat med NUnit är deras Asserts som är mycket mer avancerade än Visual Studios. Det är kanske inte alltid man behöver det men det ökar läsbarheten att kunna skriva:

Assert.That(expected, Is.EqualTo(actual));

Istället för:

Assert.AreEqual(expected, actual);

Så efter att ha copy/paste:at in mina tester och bara uppdaterat attributen till classen och testmetoderna var det bara att köra.

Alla test fungerade bra i NUnits egna testrunner men ett av testen misslyckades i ReSharpers integrerade testrunner i Visual Studio. Det test som rapporterades som misslyckat var ett test som hade attributet [ExpectedException]. Det visade sig att ReSharper inte kan hantera det attributet. Istället för att använda ett attribut för att markera att man förväntar sig ett fel från en metod får man använda sig av en annan assert från NUnit:

var ex = Assert.Throws(() => target.MethodThatWillReturnException());

Nyheterna i Visual Studio 2010 Redux

Jag skrev ett inlägg om Visual Studio 2010 i samband med att första CTP släpptes i november 2008. Nu när beta 1 funnits tillgänglig ett tag tänkte jag ta upp det igen.

Initialt tänkte jag fokusera på nyheterna i Visual Studio 2010 och Team Foundation Server 2010 medan nyheterna C# 4.0 får vänta lite…

Mellan varje release av Visual Studio släpps det ett antal tillägg som varje användare får ladda ner och installera själv. Vi har sett det med tidigare med t ex tilläggen till .NET Framework 3.0 och ASP.NET Ajax. Det är funktioner eller utökningar som först har släppts separat för att sedan inkluderas i nästa release av Visual Studio. Det fortsätter även för Visual Studio 2010 som t ex kommer att inkludera ASP.NET MVC, Windows Azure Tools, F#, P-LINQ och JQuery.

Parallell utvecklings kommer att bli mycket enklare i Visual Studio 2010. Det inte bara genom nyheter i språken som P-LINQ utan även en hel del nyheter i IDE´n som ska ge ett bättre stöd. Felsökning och analyser med parallell exekvering ska bli också bli enklare.

Det har länge varit känt att Visual Studio 2010 är omgjord och numera utvecklad i WPF. Detta gör att vi kommer att få se många add-ins till Visual Studio 2010 som antagligen kommer att vara väldigt kreativa. Det kommer också att finnas en hel del nyheter direkt i Visual Studio 2010 där man kommer att använda IDE´n för att göra utvecklare mer produktiva.

Förutom en hel del nyheter och uppdateringar av Team Foundation Server 2010 så kommer även efterlängtade uppdateringar av Visual Studio Team System 2010 Architecture Edition samt Test Edition. Dessa två roller har varit i fokus för nya funktioner och bland nyheterna finns stöd för UML, nya arkitekturdiagram och ett helt nytt verktyg för att köra tester som ser mycket intressant ut.

Det här är delar av det som jag tänkte blogga om framöver som rör Visual Studio 2010!