środa, 28 kwietnia 2010

Aneks (2) do tutoriala – Glassfih v3 + JRuby (on Rails) + MS SQL Server 2008

W artykułach:
  • Nowa wersja activerecord-jdbc-adapter – 0.9.4 // usunięty //
  • Problem z activerecord-jdbc-adapter w wersji 0.9.3 // usunięty //
przedstawiłem problem, jaki wystąpił podczas próby wpisywania danych do tabel SQL Servera z poziomu aplikacji JRuby on Rails poprzez rdzenny activerecord-jdbc-adapter w wersjach 0.9.3 i 0.9.4, później również – o czym już nie pisałem – w wersji 0.9.5. W tym rozwiązaniu wykorzystywany był sterownik JDBC dla Microsoft SQL Servera 2008.
Ostatnio znalazłem dedykowany adapter dla SQL Servera (activerecord-jdbcmssql-adapter, w wersji 0.9.5). Postanowiłem go wypróbować. Okazało się, że działa! A ponadto nie jest już potrzebny osobny sterownik JDBC i proces tworzenia aplikacji za pomocą kreatora znacznie się uprościł.
Aby skorzystać z dobrodziejstwa activerecord-jdbcmssql-adapter’a należy go oczywiście zainstalować (razem z innymi, ważnymi elementami – bodaj jeden dodatkowy pakiet oraz aktualizacja elementów activerecord) i zmienić odrobinę ustawienia kreatora aplikacji w trzecim kroku (Database Configuration):
Zauważcie, że jako adapter bazodanowy pozostawiłem mysql (jdbc) /mssql nie pojawił się na liście…/, podałem jedynie prawidłową nazwę bazy danych (tutaj video_collection_development). Można też było podać nazwę użytkownika i hasło w celu poprawnej rejestracji w serwerze baz danych, ale te informacje pominąłem.
Dalej wszystko odbyło się jak opisywałem wcześniej – koniec końców została utworzona aplikacja JRuby on Rails. Wygenerowałem sobie dla niej rusztowanie (scaffold) jak w cz. 3 tutoriala i zanim przystąpiłem do uruchomienia migracji, zmieniłem zawartość pliku database.yml na następującą:
# MySQL.  Versions 4.1 and 5.0 are recommended.
#
#####################################################
# Changed to MS SQL (via jdbcmssql adapter) by RW
#####################################################
#
# Be sure to use new-style password hashing:
#   http://dev.mysql.com/doc/refman/5.0/en/old-client.html
development:
#  adapter: jdbcmysql
adapter: jdbcmssql
encoding: utf8
reconnect: false
database: video_collection_development
pool: 5
username: rails_app
password: rails_app
host: localhost

# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
test:
#  adapter: jdbcmysql
adapter: jdbcmssql
encoding: utf8
reconnect: false
database: video_collection_test
pool: 5
username: rails_app
password: rails_app
host: localhost

production:
#  adapter: jdbcmysql
adapter: jdbcmssql
encoding: utf8
reconnect: false
database: video_collection_production
pool: 5
username: rails_app
password: rails_app
host: localhost


W zasadzie zmianie uległa tylko nazwa adaptera (jdbcmssql) oraz nazwa użytkownika i hasło, reszta jak w pierwowzorze (dla mysql). Kreator, mimo że podałem nazwę bazy w wersji development, sprytnie dopasował nazwy pozostałych dwóch baz. Jedyne, co teraz zostało do zrobienia, to utworzenie baz danych (z odpowiednimi uprawnieniami dla użytkownika rails_app), przeprowadzenie migracji i rozwijanie aplikacji. Przetestowałem z poziomu środowiska wbudowanego w NetBeans oraz serwera testowego glassfish-gem, ale myślę, że w warunkach produkcyjnych też wszystko będzie działało prawidłowo.

niedziela, 25 kwietnia 2010

Aneks do tutoriala – Glassfih v3 + JRuby (on Rails) + MS SQL Server 2008

W trzech częściach tutoriala na temat początków tworzenia i wdrażania aplikacji JRuby on Rails na platformie, w skład której wchodzą serwer aplikacyjny Glassfish v3 oraz serwer baz danych Microsoft SQL Server 2008, zabrakło informacji, jak przygotować niezależny od NetBeans serwer Glassfish do współpracy z produkcyjnym JRubym, a JRuby’ego do obsługi SQL Servera poprzez JDBC. Niniejszym nadrabiam zaległości.

Najpierw musimy zainstalować (proces instalacji jest raczej intuicyjny i chyba nie wymaga opisu) i uruchomić niezależny serwer Glassfish, np. za pomocą polecenia (oczywiście polecenie do uruchomienia, nie instalacji :-)):

asadmin start-domain

Następnie w odpowiednim polu naszej ulubionej przeglądarki wpisujemy adres (numer portu według naszej konfiguracji, ustalonej w procesie instalacji – tutaj wartość domyślna):

http://localhost:4848

Po udanym logowaniu do Konsoli Administratora (adres podany wyżej prowadzi właśnie do tej konsoli), udajemy się do podstrony Ruby Container:

Na tej podstronie podajemy informacje na temat położenia na dysku środowiska produkcyjnego JRuby oraz kilka innych danych, które proponuję wstępnie ustawić jak na obrazku powyżej. Co do środowiska JRuby – należy pamiętać, aby to środowisko, nazywane przeze mnie produkcyjnym, wyposażyć we wszystkie dodatki (pakiety gems), których używaliśmy w środowisku deweloperskim podczas tworzenia naszej aplikacji. Zapewni nam to bezproblemowe wdrażanie aplikacji. Oczywiście można, zamiast tego, użyć pakietów aktualizacyjnych Glassfisha zawierających JRuby i Rails, jednak przedstawiona tu metoda (użycie zewnętrznej instalacji JRuby) zdaje się dawać nam większą kontrolę nad JRubym.

Kolejna sprawa to sterownik JDBC dla SQL Servera. Otóż przeczytałem gdzieś w Internecie, że wystarczy przekopiować plik sqljdbc4.jar do podfolderu lib folderu zawierającego instalację JRuby. Okazuje się, że ta metoda działa :-) Plik sqljdbc4.jar to oczywiście sterownik JDBC dla SQL Servera dostarczony przez Microsoft.

Po tych zabiegach możemy już wdrażać i testować nasze aplikacje railsowskie na niezależnym serwerze aplikacyjnym Glassfish v3. Wykorzystanie Glassfish do obsługi JRuby on Rails to rozwiązanie moim zdaniem najlepsze, ponieważ W 100% DZIAŁA! I jest to – jak by nie było – sprawdzony, profesjonalny i duży serwer aplikacyjny.

sobota, 24 kwietnia 2010

JRuby on Rails + NetBeans + GlassFish +… Microsoft SQL Server 2008 (cz. 3)

To już ostatnia część tutoriala. W poprzednich częściach przygotowaliśmy środowisko pracy oraz utworzyliśmy bazy danych dla naszego projektu. Wykorzystując NetBeans wygenerowaliśmy również wstępną formę projektu aplikacji Rails i sprawdziliśmy z powodzeniem, czy jej uruchomienie jest możliwe.

Teraz zajmiemy się rozbudową przykładowej aplikacji (nie ukrywam, że wygenerowany przez nas w części drugiej projekt był po prostu pusty…). Właściwie, to powinniśmy podejść do sprawy fachowo, czyli zaprojektować aplikację w oparciu o wzorzec MVC, jednak do naszych potrzeb użyjemy generatora rusztowań – będziemy po prostu “scaffoldowali” (scaffold – oznacza m. in. szkielet lub rusztować).

Otwórzmy naszą aplikację-projekt Rails (SimpleApp) w środowisku NetBeans. Możemy jeszcze raz sprawdzić, czy wszystko gra (czyli działa). Jeśli tak, to kontynuujemy.

W panelu Projects odnajdujemy nazwę naszego projektu (SimpleApp) i klikamy w nią prawym przyciskiem myszy. Z menu kontekstowego wybieramy opcję Generate, co powoduje pojawienie się okienka generatorów Rails. Jako typ generatora (lista rozwijalna) wybieramy scaffold. Teraz decydujemy (ależ nieprofesjonalne podejście, no no!), do czego będzie służyć nasza przykładowa aplikacja. Niech więc to będzie prosta aplikacja WWW przechowująca dane o filmach DVD: tytuł filmu, imię i nazwisko reżysera oraz liczbę płyt w pudełku. Biorąc te dane pod uwagę wypełniamy okienko jak na rysunku poniżej:

Nazwa modelu w naszym przypadku to Video (koniecznie liczba pojedyncza!), a atrybuty to tytuł (title) oraz reżyser (director) typu napisowego (string) oraz liczba płyt (krótko count) typu liczbowego całkowitego. Kolejne pary atrybut:typ oddzielane są spacjami. Generator rusztowania można uruchomić “na poważnie” lub w trybie przeglądowym (bez zmian w projekcie), można również za pomocą tego generatora usunąć nieudane rusztowanie – zamiast opcji Generate zaznaczamy Destroy. Wygenerujmy więc nasz szkielet na poważnie – kliknijmy OK. Po względnie krótkiej chwili środowisko zgłosi nam udane zakończenie pracy nad rusztowaniem – możemy się rozejrzeć po projekcie i wyszukać poszczególne elementy typu model, kontroler i widok. My jednak od razu zmierzać będziemy do uruchomienia i wdrożenia naszej aplikacji.

Najpierw musimy nakazać frameworkowi Rails utworzenie odpowiednich tablic w bazie danych (podczas tworzenia aplikacji pracujemy na wersji deweloperskiej bazy danych - simple_development). Proces ten w fachowym języku JRoR nazywany jest migracją – Rails automatycznie wygeneruje odpowiednie instrukcje SQL-DDL konieczne do utworzenia tabel oraz połączy się z SQL Serverem i wyda mu odpowiednie polecenia. Migrację do aktualnej wersji bazy danych przeprowadzamy – jak większość operacji – klikając prawym przyciskiem myszy w nazwę projektu i wybierając z menu kontekstowego Migrate Database –> To Current Version. Jeśli proces migracji przebiegnie w sposób udany, zapis logu w panelu u dołu okna głównego NetBeans będzie zawierał informację, że utworzono tablicę videos (zauważcie, że użyta została liczba mnoga – automatycznie przez Rails!). Aby przekonać się, że to prawda, należy udać się do panelu Services i rozwinąć połączenie z naszą bazą danych – przy okazji dowiemy się, że Rails wygenerował tablicę zawierającą więcej informacji, niż sami chcieliśmy, m. in. klucz główny i pola dat utworzenia i modyfikacji rekordu:

No więc wyobraźcie sobie, że to już wszystko! Właśnie wygenerowaliście aplikację Rails! Pozostaje już tylko ją uruchomić i przetestować jej działanie w przeglądarce (w naszej konfiguracji podajemy adres http://localhost:3000/videosvideos to jednocześnie nazwa tabeli, kontrolera i widoku z nim skojarzonego).

Oto aplikacja po pierwszym uruchomieniu:

Klikamy New Video i wprowadzamy dane filmu:

Klikamy przycisk Create i film zostaje zarejestrowany – najpierw widzimy informację o tym fakcie:

a następnie, klikając Back, wracamy do strony głównej:

Podejrzewam, że działań związanych z opcjami Show, EditDestroy nie trzeba pokazywać na przykładach :-)

Jeśli nasza aplikacja pomyślnie przejdzie testy, możemy ją wdrożyć na serwerze produkcyjnym. W tym celu musimy zmienić konfigurację aplikacji z development/test na production. Na początku zmienimy konfigurację projektu. Za pomocą prawego przycisku myszy wybierzemy z menu kontekstowego projektu opcję Properties. W okienku, które się pojawi, w opcji Rails environment z listy rozwijalnej wybieramy production i zatwierdzamy klikając OK:

Następnym krokiem jest migracja bazy danych – tym razem jednak musimy wykorzystań bazę simple_production. Ponieważ ta baza jest skojarzona właśnie z środowiskiem produkcyjnym, nie musimy nigdzie podawać jej nazwy, jedynie konieczne będzie przedefiniowanie zmiennej środowiskowej RAILS_ENV podczas migracji.

Migrację przeprowadzimy trochę inaczej. Otóż po kliknięciu prawym przyciskiem myszy w nazwę projektu, z menu kontekstowego wybieramy Run/Debug Rake Task. W okienku, które pojawiło się po wybraniu tej opcji, w polu Parameters wpisujemy:

RAILS_ENV=production

i uruchamiamy migrację (klikamy Run):

Jeśli wszystko się uda, to powinniśmy mieć utworzoną tablicę videos w bazie simple_production:

Dla sprawdzenia poprawności powyższych operacji możemy jeszcze raz uruchomić naszą aplikację – tym razem w trybie produkcyjnym – na testowym serwerze Glassfish (glassfish-gem) z poziomu NetBeans. Jeśli poprzednio, w środowisku development, wprowadziliśmy do bazy jakieś dane i ich nie usunęliśmy, to teraz żadnych danych nie zobaczymy, ponieważ pracujemy na innej bazie. Myślę, że jest to w miarę zrozumiałe :-)

Najwyższy czas wdrożyć naszą palikację w środowisku produkcyjnym na niezależnym (czyli nie związanym z naszym środowiskiem pracy – NetBeans) serwerze WWW. Jak wspominałem w części pierwszej, wybrałem potężny serwer GlassFish v3, w którym skonfigurowałem również niezależne od NetBeans środowisko JRuby on Rails (jak je przygotować i połączyć z GlassFish’em poczytać możecie w aneksie do tutoriali).

Po pierwsze, zakończmy NetBeans, zapisując wszystkie dotychczas niezapisane zmiany.

Folder zawierający naszą aplikację – zwykle jest to folder o nazwie takiej, jak nazwa aplikacji i znajduje się w domyślnym folderze projektów NetBeans (jeśli nie wskazaliśmy innego podczas tworzenia projektu) - możemy teraz skopiować do folderu zawierającego aplikacje WWW przeznaczone do wdrożenia w warunkach produkcyjnych. Z wielu względów zalecam takie rozwiązanie, ponieważ nic nie stoi na przeszkodzie, żeby wdrażać aplikację umieszczoną w folderze roboczym i wiele osób tak może robić. Jestem jednak zwolennikiem trzymania osobno wersji deweloperskiej (rozwijanej) i wersji produkcyjnej. Zresztą narzuca ten sposób myślenia sama architektura Rails i filozofia tego frameworka. A poza tym, po ponownym uruchomieniu NetBeans i przed rozpoczęciem dalszych prac nad naszą aplikacją na pewno przywrócimy ją do konfiguracji typu development – ze względów oczywistych (odrębna baza danych, możliwość zmian kodu “w locie” itp.)

W przypadku mojej konfiguracji folder wdrożeniowy to:

C:\Developing\RailsWWWRoot

Co prawda nazwa folderu “Developing” wskazuje jednoznacznie, jakie jest jego przeznaczenie, jednak – wierzcie mi – podfolder “RailsWWWRoot” przeznaczony jest wyłącznie do testowania aplikacji produkcyjnych.

Kopiujemy więc naszą aplikację do tego folderu i uruchamiamy konsolę (wiersz polecenia). Oczywiście moglibyśmy wdrażać aplikację z poziomu konsoli zarządzania serwerem GlassFish v3 (poprzez przeglądarkę WWW) ale… ta operacja powoduje występowanie błędów (zresztą zgłoszonych już twórcom GlassFish). Na szczęście w konsoli wszystko gra :-)

Na poniższym obrazku widzimy kolejne polecenia wydawane w celu wdrożenia aplikacji:

Najpierw sprawdzamy nazwę folderu z naszą aplikacją (po prostu dir). Następnie – jeśli nie zrobiliśmy tego wcześniej lub jeśli serwer nie uruchamia się automatycznie wraz ze startem systemu – uruchamiamy serwer GlassFish:

asadmin start-domain

I po uruchomieniu serwera wdrażamy naszą aplikację, wskazując jednocześnie serwerowi, że ma działać w trybie produkcyjnym:

asadmin deploy --property jruby.rackEnv=production SimpleApp/

Jeśli nie będzie żadnego komunikatu o błędzie, nasza aplikacja jest wdrożona i możemy ją testować:

Zauważmy, że adres WWW naszej aplikacji to teraz:

Adres portu 8081 zależy od Waszej konfiguracji serwera.

Jeśli aplikacja Wam się znudzi lub nie spełnia oczekiwań/założeń, to można ją odinstalować za pomocą polecenia

asadmin undeploy SimpleApp/

co pokazane zostało na rysunku poniżej:

I w ten sposób trzecia i ostatnia część tutoriala dobiegła końca. Mam nadzieję, że przyda się on komukolwiek i ktokolwiek go przeczyta, ponieważ istnieje masa podobnych kursów :-) Liczę jednak na Wasze opinie i uwagi, ponieważ mój tutorial jest oczywiście wyjątkowy, choćby za względu na nietypowe środowisko pracy (zwykle wszyscy piszą o natywnym Ruby, systemie baz danych MySQL czy prostym SQLite, niedziałającym koniec końców wdrażaniu na popularnych serwerach WWW itp.). Środowisko nietypowe, ale działające! Oczywiście jeśli ktoś nie chce pracować w systemach Windows, może po prostu zmienić SQL Server 2008 na MySQL (ostatnio zresztą znów polubiłem ten serwer :-)) czy PostgreSQL.

Zachęcam do śledzenia mojego bloga na bieżąco, ponieważ będę starał się wracać do tematyki Rails, choćby już wkrótce – muszę przecież napisać parę słów o konfiguracji serwera GlassFish v3 do współpracy z JRuby on Rails oraz SQL Serverem 2008.

Dziękuję za uwagę!