Marcin Wolański

Przekierowanie adresu www na nie-www w nginx

2017-11-28T21:00:00+00:00

Poprzednio skonfigurowałem aplikację stworzoną w ASP.NET Core na serwerze nginx z certyfikatem. Pięknie działają przekierowania http://www.example.com na https://example.com, ale umknął mi jeden szczegół.

Mianowicie strona jest dostępna z adresów https://www.example.com oraz https://example.com. Ze względu na SEO nie jest to najlepszym pomysłem. Chciałbym zostawić adres bez www. W tym celu należy w pliku /etc/nginx/sites-available/default dodać następujący fragment:

if ($host ~ '^www\.') {
    return 301 https://example.com$request_uri;
}

Następnie z linii komend należy sprawdzić, czy konfiguracja nginx jest ok i zrestartować serwer:

sudo nginx -t
sudo systemctl reload nginx

.NET Core 2.0 - development na Windows, deployment na Linux

2017-11-25T23:00:00+00:00

Niniejszym wpisem chciałbym rozpocząć cykl opisujący migrację małego projektu webowego napisanego dawno temu w języku Python do .NET Core 2.0. Trudności na samym początku napotkałem wiele. Wynikają one z tego, że aplikacja powstała dawno temu, a .NET Core nie znam.

Króciutko o projekcie. Aplikację stworzyłem dawno temu. Wykorzystuje ona framework Flask, działa na bazie PostgreSQL i produkcyjnie działa na serwerze z Linuksem. Od dawna chciałem poznać .NET Core, więc zamiast odkopywać swoją znajomość języka Python, postanowiłem przepisać aplikację na ASP.NET Core 2.0. Aplikację chciałbym rozwijać w Visual Studio Code na Windows 10, a produkcyjnie aplikacja ma działać na Linux. Założenie jest takie, że aplikacja po migracji ma mieć dokładnie taki sam zakres funkcjonalności.

Na samym początku projektu lubię dopracować deployment, bo zostawianie tego na koniec nie kończy się nigdy dobrze. Aplikacja nie ma dużego ruchu, więc najtańszy plan za 5 dolarów za miesiąc w DigitalOcean powinien wystarczyć. W sieci jest sporo artykułów nt. instalacji .NET Core na serwerach tej firmy, ale niestety nie są aktualne a sama instalacja sprawiła mi trochę kłopotu. Wpis ten powstał dlatego, żeby być może komuś pomóc zaoszczędzić trochę czasu.

Utworzenie serwera

Proces założenia konta w DigitalOcean pominę, bo nic zaskakującego w nim nie ma. Jeśli je mamy, trzeba stworzyć Droplet. Kiedyś serwis miał prekonfigurowany serwer z .NET Core. Obecnie trzeba samemu trochę się namęczyć. Wybiorę czysty serwer z Ubuntu 16.04.

Po chwili na maila przyjdą namiary na nowy serwer. Z konsoli:

ssh root@adres.ip.serwera

Zmieniamy hasło i już jesteśmy zalogowani na serwerze. Zainstalujmy tam sdk:

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-xenial-prod xenial main" > /etc/apt/sources.list.d/dotnetdev.list'
sudo apt-get update
sudo apt-get install dotnet-sdk-2.0.3

Stworzenie przykładowej aplikacji

Na maszynie developerskiej przygotujmy sobie aplikację. Z natury jestem leniwy, więc na początek umieszczę na serwerze aplikację wygenerowaną z template. Z linii komend polecenie:

dotnet new mvc -o NazwaProjektu

I mamy wygenerowany projekt. Zróbmy jeszcze małą modyfikację. W klasie Startup w metodzie Configure na samym końcu dodajmy:

app.UseForwardedHeaders(new ForwardedHeadersOptions
{
    ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
});

Teraz go zbudujmy, żeby mieć co umieścić na serwerze. W tym celu znów w konsoli trzeba napisać:

cd NazwaProjektu
dotnet publish -c Release

Po chwili w katalogu NazwaProjektu\bin\Release\netcoreapp2.0\publish mamy aplikację, którą wrzucimy na serwer.

Konfiguracja serwera

Dalsze kroki dość szczegółowo opisane są tutaj, więc nie będę ich tłumaczył. Najpierw należy zainstalować i uruchomić serwer nginx:

sudo apt-get install nginx
sudo service nginx start

Po tym zabiegu w przeglądarce pod adresem http://adres.ip.naszego.dropleta powinna pojawić się strona startowa serwera nginx.

Serwer trzeba przygotować do serwowania naszej aplikacji. Zawartość pliku /etc/nginx/sites-available/default zamieniamy na następującą:

server {
    listen 80;
    server_tokens off;
    location / {
        proxy_pass http://localhost:5000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection keep-alive;
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Żeby serwer załapał zmiany, należy go zrestartować:

sudo nginx -s reload

Teraz serwer wszelkie żądania na porcie 80 będzie przekierowywał na 5000. Wrzućmy naszą aplikację do katalogu /var/aspnetcore/naszaaplikacja i dodajmy monitoring. W tym celu stwórzmy plik /etc/systemd/system/kestrel-naszaaplikacja.service o treści:

[Unit]
Description=Opis naszej aplikacji

[Service]
WorkingDirectory=/var/aspnetcore/naszaaplikacja
ExecStart=/usr/bin/dotnet /var/aspnetcore/naszaaplikacja/naszaaplikacja.dll
Restart=always
RestartSec=10  # Restart service after 10 seconds if dotnet service crashes
SyslogIdentifier=dotnet-naszaaplikacja
User=www-data
Environment=ASPNETCORE_ENVIRONMENT=Production
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target

Następnie należy uruchomić stworzoną krok wcześniej usługę:

systemctl enable kestrel-naszaaplikacja.service
systemctl start kestrel-naszaaplikacja.service

Po tym kroku pod adresem http://adres.ip.naszego.dropleta powinna pojawić się nasza aplikacja.

HTTPS z Let’s Encrypt

Wypadałoby zabezpieczyć stronę certyfikatem. Cały proces jest opisany tutaj, więc będę się streszczał. Zainstalujmy certbota:

sudo add-apt-repository ppa:certbot/certbot
sudo apt-get update
sudo apt-get install python-certbot-nginx

Dodajmy domenę do serwera. W tym celu należy w pliku /etc/nginx/sites-available/default dodać:

server_name example.com www.example.com;

a następnie przeładować serwer:

sudo systemctl reload nginx

Otwórzmy ruch HTTPS przez firewall. W tym celu w konsoli należy uruchomić następujący zestaw poleceń:

sudo ufw enable
sudo ufw allow 'OpenSSH'
sudo ufw allow 'Nginx Full'
sudo ufw delete allow 'Nginx HTTP'

Teraz wystarczy pobrać certyfikat:

sudo certbot --nginx -d example.com -d www.example.com

Pod adresem https://example.com powinniśmy zobaczyć naszą stronę.

Trac na Windows

2010-11-14T23:00:00+00:00

Kiedy VisualSVN Server zainstalowałem tak, jak chciałem, zachciało mi się systemu do zarządzania błędami. Padło na Trac. Do instalacji postanowiłem wykorzystać Apache VisualSVN Servera. Wiem, że mógłbym wziąć sobie paczkę z Trac dla VisualSVN Server, ale nie zrobiłem tego, bo po pierwsze, nie zawiera najnowszej, stabilnej wersji Trac, a po drugie – niezależna instalacja Trac uprości aktualizację narzędzia w przyszłości.

Przygotowanie środowiska

Zainstalowałem po kolei używając defaultowych ścieżek:

Niestety najnowsze bindingi SVN dla Pythona 2.5 nie pomogą w integracji Trac z VisualSVN Server (gdzieś znalazłem informację, że winne są zmodyfikowane biblioteki SVN w VisualSVN Server). Ale poradziłem sobie z tym pobierając wspomnianą paczkę Trac dla VisualSVN Server i kopiując z archiwum katalogi trac\python\Lib\site-packages\libsvn oraz trac\python\Lib\site-packages\svn do c:\Python25\Lib\site-packages.

Konfiguracja Trac

Z wiersza poleceń wykonujemy:

c:\Python25\Scripts\trac-admin.exe c:\trac initenv

Na pytania instalatora odpowiadamy następująco:

Project Name: Moja_nazwa
Database connection string [sqlite:db/trac.db]: <enter>

Do katalogu c:\trac dajemy prawa do odczytu i zapisu użytkownikowi, na którym uruchomiona jest usługa.

Na tym etapie można już uruchomić webserwer Traca poleceniem:

tracd --port 8000 c:\trac

My chcemy jednak, żeby Trac serwowany był przez Apache. W związku z tym trzeba doinstalować mod_python dla Apache 2.2 i Python 2.5. Instalator zapyta nas, gdzie jest zainstalowany Apache. Chcemy wykorzystać serwer dostarczany razem z VisualSVN Server. W związku z tym tworzymy katalog modules w C:\Program Files\VisualSVN Server\bin i wskazujemy instalatorowi katalog C:\Program Files\VisualSVN Server\bin, a w konfiguracji Apache C:\Program Files\VisualSVN Server\conf\httpd.conf dodajemy linie:

LoadModule python_module bin/modules/mod_python.so

Dodajemy do konfiguracji Apache katalog Trac:

<Location /trac>
    SetHandler mod_python
    PythonInterpreter main_interpreter
    PythonHandler trac.web.modpython_frontend 
    PythonOption TracEnv "C:/trac"
    PythonOption TracUriRoot /trac
</Location>

Chcemy, aby w Trac mogli się zalogować użytkownicy domenowi. W związku z tym w konfiguracji dodajemy jeszcze poniższy fragment:

<Location /trac/login>
    AuthType SSPI
    AuthName "Trac"
    SSPIAuth On
    SSPIAuthoritative On
    SSPIDomain NAZWA_DOMENY
    SSPIOfferBasic Off
    Require valid-user
</Location>

Pod adresem http://nazwa_hosta/trac mamy dostęp do Trac.

External Tools w Visual Studio 2010 Express

2010-10-24T23:00:00+00:00

Zainstalowałem sobie Visual Studio 2010 Express. Jest kilka narzędzi, które lubię mieć zdefiniowane jako External Tools. Wchodzę zwyczajowo w menu Tools i… nie ma opcji External Tools.

Okazało się, że autorzy nie usunęli tego wielce przydatnego narzędzia, ale je ukryli. Wystarczy włączyć opcję Tools > Settings > Expert Settings i External Tools wrócą na swoje miejsce.

Użytkownicy domenowi w VisualSVN Server

2010-10-09T23:00:00+00:00

Korzystałem kiedyś z VisualSVN Server, ale wówczas wystarczała mi autoryzacja Basic, czyli każdy użytkownik ma swoją nazwę i hasło. Rozwiązanie to jest niewygodne, jeśli działamy w ramach domeny Windows. Po co nowa nazwa i hasło użytkownika specjalnie dla Subversion?

VisualSVN Server w darmowej wersji Standard Edition nie udostępnia możliwości zmiany sposobu autoryzacji użytkowników z poziomu konsoli serwera. Trzeba zakupić wersję Enterprise Edition za 950 dolarów. Jako, że nie znalazłem na stronie narzędzia informacji, że modyfikacja serwera jest niezgodna z licencją, postanowiłem spróbować zmusić darmową wersję do autoryzacji użytkowników domenowych.

Ściągnąłem i zainstalowałem najnowszą wersję narzędzia (zachowałem defaultowe ustawienia instalatora).

Aby móc skorzystać z logowania użytkowników domenowych w darmowej wersji VisualSVN Server należy ściągnąć moduł mod_auth_sspi. Archiwum rozpakowujemy do katalogu C:\Program Files\VisualSVN Server\bin. Trzeba jeszcze zmienić konfigurację Apache znajdującą się w pliku C:\Program Files\VisualSVN Server\conf. Deklarujemy załadowanie modułu:

LoadModule sspi_auth_module bin/mod_auth_sspi.so

W tym samym pliku linie:

AuthType Basic
AuthBasicProvider file
AuthUserFile "C:/Repositories/htpasswd"

zastępujemy następującymi:

AuthType SSPI
SSPIAuth On
SSPIAuthoritative On
SSPIDomain NAZWA_DOMENY
SSPIOfferBasic On

Użytkownika o nazwie NAZWA_DOMENY\uzytkownik można dodać zarówno z poziomu konsoli VisualSVN Server, jak i edytując plik C:\Repositories\authz.

Wykorzystanie Rake do budowy projektu .NET

2010-10-05T23:00:00+00:00

Przy okazji rozpoczęcia nowego projektu chciałem w prosty sposób umożliwić budowę projektu z linii komend. Do tej pory używałem do tego NAnta, ale tym razem chciałem dać szansę narzędziu, z którego korzysta wiele projektów open-source: Rake.

Wymagania miałem dwa: kompilacja projektu wykorzystującego .NET 4.0 oraz uruchomienie testów jednostkowych wykorzystujących bibliotekę xUnit.net.

Rozpocząłem od ściągnięcia i instalacji środowiska Ruby dla Windows. Aby nie wynajdywać od nowa koła, zainstalowałem bibliotekę Albacore, która znacznie ułatwia pracę ze skryptem wykorzystywanym do budowy projektu .NET. Aby zainstalować Albacore, należy w wierszu poleceń uruchomić komendę:

gem install albacore

Mój projekt ma w uproszczeniu taką strukturę:

MyApplication\lib
MyApplication\lib\xunit-1.6.1
MyApplication\source
MyApplication\source\MySolution.sln
rakefile.rb

Aby nie musieć wskazywać w wywołaniu w wierszu poleceń narzędzia rake pliku ze zadaniami, skrypt budujący projekt należy utworzyć w pliku o nazwie rakefile, Rakefile, rakefile.rb lub Rakefile.rb. Ja wybrałem sobie nazwę rakefile.rb. Dzięki temu, aby wywołać defaultowe zadanie dla Rake, będąc w katalogu projektu, w wierszu poleceń wystarczy wykonać komendę:

rake nazwa_zadania

Na początku pliku rakefile.rb deklarujemy użycie biblioteki Albacore:

require 'albacore'

Następnie dodajemy zadanie budujące solucję:

desc "Build solution"
msbuild :build do |msb|
    msb.path_to_command =  File.join(ENV['windir'], 'Microsoft.NET',
        'Framework',  'v4.0.30319', 'MSBuild.exe')
    msb.properties :configuration => :Debug
    msb.targets :Clean, :Build
    msb.solution = "source/MySolution.sln"
end

Pierwsza linijka zawiera opis zadania i ma tylko znaczenie dokumentujące. W drugiej linii msbuild oznacza nazwę zadania z Albacore, a :build alias dla tego zadania. Dzięki temu, aby zbudować projekt, w wierszu poleceń należy wykonać komendę:

rake build

Jeśli pominąłbym alias, to budowę solucji mógłbym uruchomić tak:

rake msbuild

Trzecia linia nie wygląda najlepiej, ale jest niestety konieczna, jeśli projekt używa .NET 4.0. A to dlatego, że zadanie msbuild z Albacore domyślnie używa .NETa 3.5 i wykonanie go, bez zdefiniowania ścieżki do msbuild.exe z właściwego frameworka, zakończy się błędem.

Pozostała część kodu zadania jest oczywista: chcemy zbudować solucję MySolution.sln w trybie Debug, uprzednio robiąc porządki.

Zadanie uruchomienia testów jednostkowych jest krótkie:

desc "Run unit tests"
xunit :test => :build do |xunit|
    xunit.path_to_command = "lib/xunit-1.6.1/xunit.console.clr4.exe"
    xunit.assembly = "unit_tests_file.dll"
end

Podajemy ścieżkę do narzędzia uruchamiającego z wiersza poleceń testy jednostkowe wykorzystujące bibliotekę xUnit.net i wskazujemy bibliotekę z naszymi testami.

Aby uruchomić testy jednostkowe, w wierszu poleceń należy wykonać komendę:

rake test

Jeśli mamy jakieś zadanie, które wykonujemy wyjątkowo często, to przed definicją zadań można dodać linię:

task :default => :nazwa_lub_alias_zadania

Dzięki temu, aby wykonać to zadanie, w wierszu poleceń wystarczy wywołać komendę:

rake

Nie bawiłem się zbyt długo tym rozwiązaniem, ale póki co, przynajmniej dla mnie, nie ma porównania czytelność skryptu napisanego w Ruby z plikami dla NAnta czy też msbuilda. Chcę jeszcze dodać kilka różnych zadań i zintegrować wszystko z narzędziem CI. Zobaczymy, czy się uda.

Recenzja: Debugowanie. Jak wyszukiwać i naprawiać błędy w kodzie oraz im zapobiegać

2010-09-29T23:00:00+00:00

Debugowanie jest procesem niezwykle złożonym. Istnieją publikacje opisujące techniczne aspekty wyszukiwania błędów w kodzie w ten właśnie sposób. Czasami warto jednak zapoznać się z jakimś zagadnieniem w oderwaniu się od konkretnej technologii. Taką właśnie pozycją jest Debugowanie. Jak wyszukiwać i naprawiać błędy w kodzie oraz im zapobiegać (oryg. Debug It!: Find, Repair, and Prevent Bugs in Your Code).

Książka nie jest opisem jakiegoś narzędzia wspomagającego debugowanie, platformy uruchomieniowej czy też języka programowania (kodu jest bardzo niewiele). Autor skupił się raczej na mentalnym podejściu programisty do wyszukiwania błędów w aplikacji.

Książka składa się z 3 części: Istota problemu, Szersza perspektywa oraz Debug-Fu.

W części pierwszej autor opisuje metodę empiryczną debugowania tj. reprodukcję błędów, diagnozowanie ich przyczyny, poprawki oraz refleksja nad tym, co zrobić, aby w przyszłości nie musieć usuwać takich samych usterek.

Część druga poświęcona jest miejscu debugowania w całym procesie tworzenia aplikacji m.in. współpracy z użytkownikami aplikacji, innymi zespołami, czy błędy powinny być naprawiane od razu po ich stwierdzeniu, czy może lepiej dodać jakąś nową funkcjonalność itd.

W części trzeciej autor skupił się na technicznym aspekcie procesu debugowania: stworzeniu odpowiedniego środowiska umożliwiającego skuteczne debugowanie, systemach kontroli wersji, ciągłej integracji, testach jednostkowych, użyteczności asercji, kontraktów i bibliotek ułatwiających logowanie itd.

Podobało mi się

Książki podejmujące tematykę debugowania od strony technicznej nie są, przynajmniej dla mnie, lekką lekturą. Trzeba znaleźć wolną chwilę, aby wiedzę zgłębiać w skupieniu i koniecznie przy komputerze. Opisywana pozycja ma tą cechę, że takich fragmentów jest naprawdę niewiele.

Dodatkowo jej gabaryty zdecydowanie nie przeszkadzają w czytaniu np. w drodze do pracy.

Nie podobało mi się

Choć tematyka książki sugeruje, że powinno się ją czytać lekko i przyjemnie, to tak niestety nie było w moim przypadku. Nie czytałem oryginału, ale wydaje mi się, że to kwestia przekładu.

Dawno nie czytałem nic wydawanego przez Helion Zraziły mnie do tego skutecznie przede wszystkim nieudane tłumaczenia. Do zakupu opisywanej pozycji skusiła mnie cena dużo niższa niż w Amazon. Następnym razem się zastanowię, bo w tym przypadku skąpstwo nie popłaciło.

Moim zdaniem nie powinno się tłumaczyć niektórych angielskich zwrotów. “Zaślepki testowe” (ang. test doubles), “atrapy” (ang. mocks), “namiastki” (ang. stubs) czy też mój ulubiony “profilator” (ang. profiler), to tylko niektóre kwiatki.

Czego się nauczyłem

Lubię od czasu do czasu przeczytać trochę mniej techniczną książkę. Lektura Debugowania… zmusiła mnie do refleksji nad tym, czy w codziennej pracy właściwie podchodzę do procesu diagnozy przyczyn błędów w rozwijanych i utrzymywanych aplikacjach.

Polecam, ale raczej w języku angielskim.

Zaznaczanie błędów w Visual Studio a deinstalacja Resharpera

2010-09-23T23:00:00+00:00

Po odinstalowaniu Resharpera zauważyłem, że w edytorze nie są zaznaczane błędy. Chwila grzebania w opcjach i udało się doprowadzić Visual Studio do stanu sprzed instalacji narzędzia.

Wystarczy wybrać Tools > Options > Text Editor > C# > Advanced i zaznaczyć w Editor Helper opcje Underline errors in the editor oraz Show live semantic errors.

NHibernate i wyjątki ADO

2010-03-02T23:00:00+00:00

Próba zapisania obiektu naruszającego więzy integralności przy użyciu biblioteki NHibernate spowoduje wygenerowanie wyjątku GenericADOException. Dopiero sięgając do wartości właściwości InnerException możemy przekonać się, co jest przyczyną niepowodzenia. Istnieje jednak sposób na zastąpienie standardowego wyjątku własnym.

W przykładzie użyję prostej klasy:

public class User 
{ 
    public virtual int Id { get; set; } 
    public virtual string UserName { get; set; } 
    public virtual int Age { get; set; } 
}

i mapowania:

public class UserMap : ClassMap<User>
{
    public UserMap()
    {
        Id(x => x.Id);
        Map(x => x.UserName).Unique();
        Map(x => x.Age); 
    }
}

Próba zapisu dwóch użytkowników o tej samej nazwie kończy się wyjątkiem GenericADOException:

[Test, ExpectedException(typeof(NHibernate.Exceptions.GenericADOException))]
public void CannotAddTwoUsersWithTheSameUsername()
{
    var janKowalski1 = new User {UserName = "Jan Kowalski"};
    var janKowalski2 = new User {UserName = "Jan Kowalski"};

    using (var session = DataAccessFacade.OpenSession())
    using (var tx = session.BeginTransaction())
    {
        session.Save(janKowalski1);
        session.Save(janKowalski2);
        tx.Commit();
    }
}

Oczywiście można sprawdzić, co jest przyczyną błędu przy zapisie:

var janKowalski1 = new User {UserName = "Jan Kowalski"};
var janKowalski2 = new User {UserName = "Jan Kowalski"};

using (var session = DataAccessFacade.OpenSession())
using (var tx = session.BeginTransaction())
{
    try
    {
        session.Save(janKowalski1);
        session.Save(janKowalski2);
        tx.Commit();
    }
    catch (GenericADOException ex)
    {
        if (ex.InnerException is SQLiteException)
        {
            var sqLiteException = (SQLiteException) ex.InnerException;
            switch(sqLiteException.ErrorCode)
            {
                case SQLiteErrorCode.Constraint:
                    // do something with constaint exception
                default:
                    throw;
            }
        }
        throw;
    }
}

Jednak ten sposób uzależniamy nasz kod od konkretnego providera. Ewentualna zmiana silnika bazy danych powoduje konieczność zmian w wielu klasach warstwy dostępu do danych. Poza tym obsługa wydawałoby się trywialnego problemu wymaga każdorazowo napisania wielu linii kodu.

Czy powyższy fragment nie mógłby wyglądać tak:

var janKowalski1 = new User {UserName = "Jan Kowalski"};
var janKowalski2 = new User {UserName = "Jan Kowalski"};

using (var session = DataAccessFacade.OpenSession())
using (var tx = session.BeginTransaction())
{
    try
    {
        session.Save(janKowalski1);
        session.Save(janKowalski2);
        tx.Commit();
    }
    catch (ConstraintViolationException ex)
    {
        // do something with constaint exception
    }
}

O ile krócej, prawda? I nie obchodzi nas, że w danej chwili wykorzystujemy bazę danych SQLite, Oracle czy MSSQL Server.

Aby osiągnąć ten efekt używając NHibernate, musimy stworzyć własną implementację interfejsu ISQLExceptionConverter:

public class MyCustomSQLExceptionConverter: ISQLExceptionConverter
{
    public Exception Convert(AdoExceptionContextInfo adoExceptionContextInfo)
    {
        var ex = ADOExceptionHelper.ExtractDbException(
            adoExceptionContextInfo.SqlException) as SQLiteException;
        if (ex != null)
        {
            switch (ex.ErrorCode)
            {
                case SQLiteErrorCode.Constraint:
                    return 
                        new NHibernate.Exceptions.ConstraintViolationException(
                            adoExceptionContextInfo.Message,
                            ex.InnerException,
                            adoExceptionContextInfo.Sql,
                            null
                        );
            }
        }
        return SQLStateConverter.HandledNonSpecificException(
            adoExceptionContextInfo.SqlException,
            adoExceptionContextInfo.Message,
            adoExceptionContextInfo.Sql
        );
    }
}

Metoda ADOExceptionHelper.ExtractDbException wyłuskuje pierwszy wyjątek System.Data.Common.DbException z drzewa wraz z jego InnerExceptionami. Reszta jest chyba oczywista.

Konfigurujemy jeszcze NHibernate w pliku konfiguracyjnym:

<property name="sql_exception_converter">
    NameSpace.MyCustomSQLExceptionConverter, AssemblyName
</property>

albo za pomocą Fluent NHibernate:

_configuration.SetProperty(
    NHibernate.Cfg.Environment.SqlExceptionConverter,
    typeof(MyCustomSQLExceptionConverter).AssemblyQualifiedName
);

NHibernate.Validator: komunikaty przyjazne dla użytkownika

2010-01-15T23:00:00+00:00

Jakiś czas temu przedstawiłem sposób użycia biblioteki NHibernate.Validator w aplikacji Windows Forms. Miał on jedną zasadniczą wadę: komunikaty walidatora były takie, jakie stworzyli autorzy biblioteki.

Przypomnę, że poprzednio stworzyliśmy użytkownika z właściwościami: imię, nazwisko i wiek. Założyliśmy, że imię i nazwisko nie mogą być puste i użytkownik musi mieć przynajmniej 18 lat:

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}

public class UserValidationDef: ValidationDef<User>
{
    public UserValidationDef()
    {
        Define(x => x.FirstName)
            .NotNullableAndNotEmpty();
        Define(x => x.LastName)
            .NotNullableAndNotEmpty();
        Define(x => x.Age)
            .GreaterThanOrEqualTo(18);
    }
}

Niewypełnienie imienia i nazwiska skutkowało niskopoziomowym komunikatem: nie może być nieokreślony i pusty, natomiast wpisanie wieku mniejszego niż 18: musi być większe lub równe od 18.

Chciałbym, aby komunikaty były bardziej przyjazne dla użytkownikowa np. Imię jest wymagane czy też Wiek musi być większy lub równy 18. Można dostosować komunikaty dla każdej reguły:

public class UserValidationDef: ValidationDef<User>
{
    public UserValidationDef()
    {
        Define(x => x.FirstName)
            .NotNullableAndNotEmpty()
            .WithMessage("Imię jest wymagane.");
        Define(x => x.LastName)
            .NotNullableAndNotEmpty()
            .WithMessage("Nazwisko jest wymagane.");
        Define(x => x.Age)
            .GreaterThanOrEqualTo(18)
            .WithMessage("Wiek musi być większy lub równy 18.");
    }
}

Rozwiązanie jest zadowalające dla niewielkiej aplikacji. W bardziej skomplikowanej kosmetyczna zmiana jest wymagane na musi być wypełnione wymaga przejrzenia i aktualizacji kilku/kilkunastu/kilkudziesięciu klas. Autorzy przewidzieli taki przypadek: komunikaty można zdefiniować w zewnętrznym pliku zasobów.

Dodajmy plik zasobów do projektu:

Definiujemy komentarze przyjazne dla użytkownika:

Obrazek chyba nie wymaga wyjaśnień, może poza {Value} w komunikacie message.user.age.GreaterThanOrEqualTo. Jest to właściwość publiczna atrybutu MinAttribute wykorzystywanego w metodzie GreaterThanOrEqualTo. Dzięki temu argument wspomnianej metody będzie przekazywany do komunikatu. Jeśli zmieni się wartość dopuszczalnego wieku, wystarczy edycja reguły bez konieczności uaktualniania pliku z komunikatami.

Zmieńmy klasę UserValidationDef tak, aby wykorzystywała komunikaty z pliku zasobów:

public class UserValidationDef: ValidationDef<User>
{
    public UserValidationDef()
    {
        Define(x => x.FirstName)
            .NotNullableAndNotEmpty()
            .WithMessage("{message.user.firstname.NotNullableAndNotEmpty}");
        Define(x => x.LastName)
            .NotNullableAndNotEmpty()
            .WithMessage("{message.user.lastname.NotNullableAndNotEmpty}");
        Define(x => x.Age)
            .GreaterThanOrEqualTo(18)
            .WithMessage("{message.user.age.GreaterThanOrEqualTo}");
    }
}

Ostatni krok, to konfiguracja biblioteki tak, aby wykorzystywał plik zasobów ValidationMessages.resx:

Environment.SharedEngineProvider = new NHibernateSharedEngineProvider();

var config = new FluentConfiguration();
config.SetCustomResourceManager("NHVWinForms.Properties.ValidationMessages",
         typeof(Program).Assembly)
      .Register(typeof (UserValidationDef).Assembly.ValidationDefinitions())
      .SetDefaultValidatorMode(ValidatorMode.UseExternal);

var ve = Environment.SharedEngineProvider.GetEngine();
ve.Configure(config);

I mamy przyjazne i łatwo modyfikowalne komunikaty: Imię jest wymagane zamiast nie może być nieokreślony i pusty i Wiek musi być większy lub równy 18 zamiast musi być większe lub równe od 18.