Dziennik początkującego programisty

Grails jako klient usługi sieciowej

2010-07-19T20:58:00.000-07:00

W tym przykładzie pokażę jak można szybko i z łatwością stworzyć w Grails klienta usługi sieciowej dla LINK, bazując na informacjach i kodzie udostępnionych w LINK. Interfejs użytkownika będzie w całości wygenerowany przez mechanizm rusztowania(ang. Scaffolding), minimalnie tylko zostanie zmodyfikowany jeden z widoków i strona główna.

Teraz trochę o samej usłudze sieciowej, jest to prosta wyszukiwarka cytatów z dzieł Shakespeara. Należy podać część cytatu jaki chcemy odnaleźć, a wyszukiwarka zwraca nam tytuł sztuki, mówce i pełną frazę odpowiadającą szukanemu fragmentowi.

1. Tworzenie projektu i instalacja biblioteki GroovyWS

Tutaj znowu mamy pewną dowolność, możemy naszą aplikację Grailsową stworzyć w Netbeans IDE, czy też podając odpowiednią komendę w konsoli, tak czy inaczej zostanie wykonany skrypt napisany w języku Groovy, który inicjujemy poleceniem:

> grails create-app ShakesQuoteFinder

Do projektu potrzebujemy biblioteki GroovyWS, która umożliwi nam połączenie z usługą sieciową. Informacje na temat tej biblioteki możemy znaleźć w LINK, bezpośredni link do pobrania LINK.

Mamy przygotowany projekt do dalszej pracy, możemy teraz stworzyć klienta usługi bazującego na protokole SOAP.

2. Modyfikacja i dodanie kodu

Tworzymy dziedzinę problemu, klasę domenową, której atrybuty odpowiadać będą parametrom przesyłanym do i odbieranym od usługi zamieszczonej w internecie. W klasę domenową o nazwie ShakesQuote(grails create-domain-class ShakesQuote) wklejamy kod:

class ShakesQuote {
    String phrase

    String play
    String speaker
    String words

    static constraints = {
        phrase(nullable:true)

        play(nullable:true)
        speaker(nullable:true)
        words(nullable:true)
    } 
}

Dalej, budujemy prostą usługę(zawierającą logikę biznesową) poprzez którą będziemy komunikować się z usługą WSShakespeare(do której link podałem na początku notki). Plik ShakesService(grails create-service Shakes) nadpisujemy kodem:

import groovyx.net.ws.WSClient

class ShakesService {
    boolean transactional = false

    def findQuote(params){
        def proxy = new WSClient("http://www.xmlme.com/WSShakespeare.asmx?WSDL",
            this.class.classLoader)
        proxy.initialize()

        def speech = new XmlParser().parseText(proxy.GetSpeech(params.phrase))

        params.play = speech.PLAY.text()
        params.speaker = speech.SPEAKER.text()
        params.words = speech.text()

        return params
    }
}

Teraz pozostało już tylko wygenerować kontroler i widoki(grails generate-all ShakesQuote) oraz zmodyfikować nieznacznie kod tak aby wykorzystać stworzoną usługę w wygenerowanym kontrolerze i lekko poprawić wygląd stworzonej aplikacji.

Przechodzimy do ShakesQuoteController.groovy i dopisujemy dwie linijki kodu:

def ShakesService //umieszczamy swobodnie(nie w metodzie ani domknięciu) w dowolnym 
                  //miejscu, ta linijka pozwoli na dynamiczne stworzenie instancji
                  //usługi ShakesService

def save = {
        ShakesService.findQuote(params); //drugą linijkę wklejamy w domknięciu
        ...                              //odpowiadającym za zapis naszych danych
        ...
}

Tak naprawdę w tym momencie mamy już gotowy, działający projekt, możemy przetestować jego działanie. Jednak chcę upiększyć nieznacznie stronę główną, w której domyślnie wyświetlane jest menu zawierające status aplikacji, zainstalowane pluginy i tekst powitalny, a żadne z tych rzeczy na tą chwilę nam nie są potrzebne.

Zmiany w pliku index.gsp, który znajduje się w katalogu \Views and Layouts\ zamieszczam w tym miejscu LINK. Myślę, że nie trzeba tłumaczyć, w których miejscach kod został zmieniony, można nadmienić cały kod, albo porównać wygenerowaną domyślną stronę z tą zmodyfikowaną. Zamieszczam dwa zrzuty ekranu prezentujące zmiany.

Przed:

Po:

Kolejna modyfikacja, tym razem w \Views and Layouts\shakesQuote\, czyli w katalogu, w którym znajdują się wygenerowane wcześniej widoki dla naszej klasy dziedzinowej ShakesQuote. Otwieramy plik Create.gsp. Kod zmieniamy tak, aby widok wyświetlał nam tylko pole tekstowe Phrase, ponieważ na wstępie podajemy część cytatu, po którym chcemy szukać, a pozostałe parametry(play, speaker, words) pobierane są z usługi sieciowej WSShakespeare. Pozbywamy się więc trzech wierszy(<tr>) tabeli odpowiadających za trzy niepotrzebne parametry.

Przed:

Po:

3. Podsumowanie i efekt końcowy

Klient usługi sieciowej gotowy, dzięki Grailsowi bez jakiegokolwiek wysiłku mamy dostęp do funkcjonalności CRUD(create-read-update-delete) oraz możliwość zapisania wyszukanych informacji w bazie danych. Myślę, że przykład pokazał możliwości jakie daje Grails, podobnie postępując możemy stworzyć interfejs użytkownika dla dowolnej usługi sieciowej. Zainteresowanych dalszą adaptacją usług sieciowych w Grails, odsyłam do serii dwóch artykułów LINK1, LINK2, których końcowym efektem jest aplikacja planująca podróż, zaznaczająca na mapie poszukiwane lotniska.

Zakończenie praktyk IBM

2010-06-17T20:58:00.000-07:00

Praktyka IBM dobiegła końca wraz z oddaniem sprzętu i prezentacją końcową w głównej siedzibie IBM Polska w Warszawie w dniu 11.06.2010r. Ogólne wrażenia po odbytych praktykach - pozytywne, mimo, że były dla mnie dużym wyzwaniem, w szczególności praca z ludźmi, którzy są o kilka lat świetlnych przede mną jeżeli chodzi o wiedzę, umiejętności i doświadczenie w branży IT. Z rezultatów swojej pracy(mimo, że poświęciłem temu projektowi większość wolnego czasu) nie jestem do końca zadowolony, ale zawsze jest tak, że może być lepiej, więc postaram się tym nie przejmować.

Udało mi się poznać środowisko Grails i jego olbrzymie możliwości(z tego jestem najbardziej zadowolony), w szczególności te ułatwiające budowanie interfejsu użytkownika. Uruchomiłem także aplikację z Grails na WebSphere Process Server z połączeniem z DB2, co pokazało, że można tą platformę z powodzeniem odpalić na serwerze IBM. Jednak nie starczyło czasu i wiedzy na to, aby pokazać, że możliwa jest integracja tego środowiska z usługami sieciowymi stworzonymi w WebSphere Integration Developer i bardziej skomplikowanymi procesami biznesowymi. Co nie zmienia faktu, że Grails z powodzeniem można używać do aplikacji zorientowanych na usługi, bardzo szybko można stworzyć interfejs użytkownika(np. dzięki wykorzystaniu mechanizmu rusztowania - ang. Scaffolding) dla usługi sieciowej. W następnej notce w końcu zamieszczę zaległy przykład takiego rozwiązania.

Dwa najważniejsze slajdy w mojej prezentacji:

Same wystąpienie na prezentacji końcowej poszło kiepsko. Stress wziął nade mną górę i na pewno próba stworzenia zbyt technicznej prezentacji w tym wszystkim nie pomogła. Przygotowałem za dużo informacji jak na swoje możliwości oratorskie - co mnie zgubiło.

Także podsumowując, oprócz moich wystąpień na prezentacjach, z praktyk jestem zadowolony. Dzięki nim mogłem się zmobilizować i wziąć udział w ciekawym projekcie, trochę poznać jak wygląda praca w wielkiej międzynarodowej korporacji i współpraca z fachowcami w swej dziedzinie.

Początki pracy z WebSphere Integration Developer

2010-05-12T13:08:00.000-07:00

Wygląda na to, że wraz z rozwiązaniem kłopotu z uruchomieniem WPS pod WID'em w końcu mam gotowe środowisko do pracy. Dlatego teraz można przejść do konkretnych rzeczy nie martwiąc się o to, że coś nie działa, że czegoś nie da się uruchomić, że gdzieś tam wyskakuje jakiś błąd. Dalej będzie już na pewno mniej problemów z samym oprogramowaniem i linuksem.

W tym miejscu chciałbym wspomnieć o tym, że bardzo cenię sobie materiały edukacyjne stworzone przez ekspertów z IBM, mam już trochę z nimi do czynienia nie tylko przy pracy nad tym projektem, muszę przyznać, że potrafią nawet takiego laika jak ja wprowadzić w nowe technologie, rozwiązania, czy też ułatwić pracę z nowo poznawanym oprogramowaniem. Technicznego wsparcia jest czasami nawet za dużo, ciężko jest nieraz przebić się przez taką ilość informacji i znaleźć to co nas w danym momencie interesuje. Ale za to, to czy znajdziemy odpowiedź jest zazwyczaj tylko kwestią czasu.

Po uruchomieniu programu od razu możemy przejść do poznawania procesów biznesowych i usług sieciowych. Zaczynamy od zbudowania aplikacji HelloWorld("Hello World Part 1: Getting Started"), która wywołuje usługę sieciową. Możemy także pójść na skróty i zaimportować już wykonany projekt, ale nie to mnie w tym momencie interesuje. Dlatego wybieram opcje, w której krok po kroku konstruuję przykład(Getting Started>Samples and Tutorials>View Instructions).

Wraz z pierwszym przykładem uczymy się podstaw takich jak tworzenie, wdrażanie i uruchamianie mediacyjnych(ang. mediated, tylko jak to z sensem przetłumaczyć na polski?) zawołań do wcześniej stworzonej usługi sieciowej. W zasadzie nie stworzonej, tylko zaimportowanej gotowej usługi:

public String getHello(String name){
return "Hello " + name;
}

Jedyne co oprócz tego musimy wiedzieć o samej usłudze, jest to, że jest dla niej plik WSDL definiujący nie tylko interfejs, ale także sposób jej wywołania wykorzystujący SOAP.

Wykonując kolejne kroki docieramy do stanu, gdzie mamy 3 projekty: HelloService(implementacja usługi sieciowej), HelloWorldLibrary(projekt do współdzielenia zasobów takich jak interfejsy usług sieciowych, obiekty biznesowe, przyda się w kolejnym przykładzie) i HelloWorldMediation. Ten ostatni jest projektem zawierającym logikę integrującą usługi, w tym przykładzie stwarza dostęp do usługi webowej HelloService przekazując ją interfejsowi udostępniającemu tą usługę - HelloWorld.

Przykład uruchomić można bezpośrednio w WID, używając Integration Test Client, podajemy wartości dla każdego z wcześniej stworzonych pól w obiekcie biznesowym i otrzymujemy odpowiedz.

Kolejnym stworzonym już dawno przykładem(ale dopiero parę dni temu udało mi się go uruchomić) będzie wykorzystanie powyższej usługi sieciowej do stworzenia prostej interakcji z użytkownikiem, który będzie miał za zadanie podać imię i nazwisko. Półki co interfejs użytkownika będzie zapewniony przez Business Process Choreographer(BPC) Explorer, narzędzie to jest wbudowane w WebSphere Process Server, służy do testowania procesów biznesowych i zadań użytkownika. Teraz, moim zadaniem jest stworzenie podobnego interfejsu, tyle, że w Grails. Jeżeli chodzi o wpisy, chcę jeszcze jeden zaległy przykład pokazać, który będzie zahaczał o tematykę zadań użytkownika.

Tworzenie pierwszego przykładu procesu biznesowego typu Human Task na WID, problem z uruchomieniem WPS na WID.

2010-04-27T15:22:00.000-07:00

Sama instalacja WID'a przebiegła bez większych trudności, tu wymagane było tylko uruchomienie instalatora z poziomu root'a, po instalacji zastosowałem komendę chown -R rafal na całym katalogu z WID'em. Jako, że wcześniej instalowałem WAS/WPS na tym systemie pominąłem instalację WAS'a , miałem nadzieję, że z dodaniem wcześniej zainstalowanego serwera do WID'a nie będzie problemu i z samym dodaniem faktycznie nie było, ale z uruchomieniem już tak. Na początku myślałem, że to wina limitu na czas uruchomienia WPS'a, standardowo w programie ustawiony na 10 minut (a wiedziałem, że przynajmniej w tej konfiguracji sprzętowej potrafił się dłużej uruchamiać), zwiększyłem więc limit do 20, ale nie pomogło. Wszystko wskazuje na to, że serwer się uruchamia, tylko w programie po upłynięciu określonego czasu wyskakuje błąd:

Czyli jak na razie chyba nie ma szansy żeby WID pomógł wdrożyć stworzony proces biznesowy na WPS, zamieszczam LOGI, w których półki co nie doszukałem się żadnej odpowiedzi(może dlatego, że serwer startuje bez błędu?), poświęcam teraz więcej czasu na naukę usług sieciowych i procesów biznesowych z zadaniem użytkownika (ang. Human Task). Gdy uda mi się przebrnąć przez stworzenie przykładu i uruchomienie go na WPS'ie zamieszczę tu wyniki.

//EDIT 12-05-2010 13:30

Miałem zamiar wcześniej uporać się z problemem wdrożenia na WPS przykładów stworzonych w WID. Wtedy po dwóch - trzech dniach dopisałbym efekty i uruchomienie pierwszego przykładu, ale niestety nie udało mi się tak szybko znaleźć rozwiązania, więc przykład zamieszczam w nowej notce.

Co do samego problemu, rozwiązany był już jakiś czas temu, okazało się, że konieczne jest zainstalowanie WebSphere Integration Developer V7.0.0 Fix Pack 2 for Linux, który wraz z intrukcją znajduje sie w LINK. Menadżera instalacji WID trzeba było uruchomić z uprawnieniami root. Ważne jest także aby po uaktualnieniu oprogramowania ponownie nadać prawa użytkownikowi(chown -R user) żeby wszystko działało poprawnie. Można także dodatkowo aktualizować WPS, wystarczy odpalić menadżera instalacji dla tego programu i kliknąć aktualizuj, wszystko odbywa się automatycznie.

Jednak to nie był koniec moich zmagań z uruchomieniem przykładów. Przy wywoływaniu pierwszego przykładu otrzymałem błąd:

"The server is not running in Development mode" - z tym nie miałem większego problemu, przypomniało mi się, że kiedy wcześniej przeglądałem konsolę administratora napotkałem na opcję, której włączenie mogło pomóc. Zaznaczamy wariant znajdujący się w Servers>Server Types>WebSphere Application Server>server1>Configuration.

Po zrestartowaniu serwera przykład powinien uruchamiać się bez błędu.

Instalacja DB2 na RedHat Enterprise Linux i uruchomienie aplikacji Grails na WPS

2010-04-22T20:22:00.000-07:00

Nadszedł czas na napisanie kolejnej notki, co prawda, to co będę tu opisywał udało mi się wykonać z powodzeniem już jakiś czas temu(ostatni krok, czyli wdrożenie war'a na WPS z DB2 jakoś w poniedziałek), ale coś ostatnio nie mogłem zebrać myśli i podsumować zakończone zadanie na moim blogu.

Zabieramy się do roboty, w tym miejscu Drogi Czytelniku zakładam, że masz zainstalowany serwer WPS i stworzony odpowiedni profil(jeżeli nie odsyłam do poprzedniego wpisu LINK). Na początek potrzebujemy zainstalować JDK i Grails, żeby stworzyć war'a, którego potem będziemy wdrażać na WPS.

Instalacja JDK, Grails i wyeksportowanie war'a

Pobieramy JDK na Linuxa - LINK.
Pobieramy najnowszą(v 1.1.2) dostępną pod Linux'a wersję Grails - LINK.

Instalujemy JDK, myślę, że będzie lepiej jak nie będę tutaj opisywał krok po kroku co należy robić, znalazłem świetny materiał znajdujący się na Polskim Forum Linuksa - LINK, który wyczerpuje ten temat. Wystarczy znaleźć interesujący nas podpunkt(ja wybrałem instalację JDK ze źródeł z prawami administratora) i robić kolejno co jest tam napisane. Zwracamy szczególną uwagę przy dodawaniu zmiennych środowiskowych, ponieważ później przyda nam się ta wiedza przy dodawaniu zmiennych Grails'a.

Instalując Grails'a nie używamy komendy chmod a+x, ponieważ tak jak w przypadku WPS chcemy, aby uprawnienia do wykonywania operacji na nim przypadły użytkownikowi. Dlatego też, rozpakowujemy nasze pliki w katalogu domowym wcześniej stworzonego użytkownika(u mnie /home/rafal). Po dodaniu zmiennych środowiskowych tym razem wskazujących na katalog z Grails'em możemy zrestartować system żeby zmiany były widoczne.

Dalej przygotujemy sobie plik war, pozostawiam tu Wam pewną dowolność, ponieważ sama aplikacja nie jest tutaj istotna, może to być najprostszy kod typu HelloWorld, co nam teraz jest potrzebne, to wyeksportować plik war komendą:

$ grails war NaszaAplikacja.war

Wygenerowana w konsoli odpowiedź naprowadzi nas na folder, w którym znajduje się stworzony plik. Jeżeli ktoś chce użyć przykładu stworzonego przeze mnie odsyłam do wcześniejszej notki - LINK(był on pisany na Windows'ie, ale na Linux'ie wszystko robimy analogicznie).

Instalacja DB2

Pobieramy DB2 - LINK, rozpakowujemy w dowolnym miejscu w katalogu domowym użytkownika(instalacja DB2 jako non-root i tak domyślnie wrzuci nam pliki do /home/nazwaUzytkownika/sqllib). Po zainstalowaniu otwieramy okno First Steps w celu stworzenia SAMPLE database. Wybieramy lokacje bazy danych, przeglądając później ten katalog widzimy, że stworzyliśmy węzeł(ang. node) o domyślnym indeksie 0000 oraz z ID użytkownika, dla którego instalowaliśmy DB2.

Otwieramy Applications>IBM DB2>Command Line Processor, uruchamiamy usługę DB2 komendą:

db2 => db2start

Tworzymy bazę danych, jeżeli stworzyliśmy aplikację Biblioteka, to tak jak podane jest w wcześniejszym wpisie tworzymy bazę danych i łączymy się z nią.

Tworzenie połączenia JDBC i wdrożenie war'a na WPS

Uruchamiamy serwer WPS, klikamy i rozwijamy pierwszą opcję czyli Guided Activities>Connecting to a database, tam mamy kolejno opcje do konfiguracji połączenia z bazą danych, na ten moment możemy ominąć pierwszy krok czyli Configure credentials for secure database access. Przechodzimy zatem do Configure a JDBC provider => Click to perform. Po prawej w oknie gdzie figurują dostępni dostawcy JDBC klikamy New.

Wybieramy kolejno:

Step 1: Create a new JDBC Provider:
*Database type: DB2
*Provider type: DB2 Using IBM JCC Driver
*Implementation type: Connection pool data source

Step 2: Enter database class path information
${DB2_JCC_DRIVER_PATH}
/home/nazwaUzytkownika/sqllib/java

Pole Native library path(wiąże się to ze zmiennymi dla WebSphere'a, patrz niżej) możemy zostawić puste i korzystamy z tego przywileju. Pomijamy także następny krok czyli Configure WebSphere variables, ponieważ żadna taka zmienna nie jest nam potrzebna do połączenia z bazą. Klikamy Next i dalej na podsumowaniu Finish.

Teraz konfiguracja Datasource, wybieramy wcześniej utworzonego dostawcę JDBC i po prawej w rubryce Additional Properties klikamy Datasources.

Podajemy JNDI name, dalej wybieramy Driver type - 2 i wpisujemy nazwę wcześniej utworzonej bazy danych, pole Server name zostawiamy puste. Na tym konczymy naszą konfigurację połączenia.

Testujemy nasze połączenie, pamiętając, że jeszcze musimy zapisać nasze zmiany, wyświetli się odpowiedni komunikat, klikamy Save.

Nawiązanie połączenia po wykonaniu powyższych czynności powinno zakończyć się powodzeniem.
Zmieniamy plik DataSource.groovy aby wygladal tak(w miejsce biblio możesz umieścić swoją nazwę):

Wdrażamy war’a na WPS, w konsoli administratora przechodzimy do Application>New Application>New Enterprise Application.

Wyszukujemy nasz wcześniej stworzony plik, klikamy next, wybieramy metodę instalacji - Fast Path. :)

Dalej wszystkie ustawienia do kroku 4 zostawiamy domyślne, jedynie zmieniamy mapowanie context root, jeżeli tego nie zrobimy prawdopodobnie otrzymamy taki błąd:

com.ibm.ws.wswebcontainer.VirtualHost addWebApplication SRVE0164E: Web Application HumanTasks_war#/HumanTasks-production-0.1 uses the context root /*, which is already in use by Web Application DefaultApplication#Default Web Application. Web Application /HumanTasks-production-0.1 will not be loaded.

Teraz przechodzimy do Applications>Applications Types>WebSphere enterprise applications, zaznaczamy naszą aplikacje naciskamy start.

Następnie w zależności od podanego context root'a dla naszej aplikacji i adresu waszego hosta(u mnie defoult_host na porcie 9080) wpisujemy adres naszej aplikacji:

http://localhost:9080/grails

I możemy cieszyć się rezultatem naszej pracy.

Problem z uruchomieniem konsoli administratora dla WAS/WPS

2010-04-07T15:30:00.000-07:00

Na kolejne trudności nie trzeba było długo czekać, po stworzeniu profilu WPS przyszedł czas na uruchomienie konsoli administratora w przeglądarce. I tu po wpisaniu prawidłowego adresu do mojego localhosta tj.:

http://localhost:9060/ibm/console

pojawia się kolejny błąd.

//EDIT 1 - 09.04.2010r. 12:40

Nadal nie uporałem się z powyższym problemem, dla zainteresowanych i chętnych do pomocy zamieszczam logi serwera wyrzucane podczas uruchamiania serwera - PLIK DO POBRANIA.

//EDIT 2 - 11.04/2010r 13:30

Przyczyną błędu powodującego całe zamieszanie był systemowy limit na liczbę otwartych plików:

java.io.FileNotFoundException: /home/rafal/ibm/WebSphere/ProcServer/profiles/ProcSrv01/databases/WPRCSDB/seg0/cb10.dat (Too many open files)

Żeby rozwiązać ten problem odpowiednio modyfikujemy parametr ulimit, postępując zgodnie z LINKIEM, logujemy się w terminalu jako root, podajemy komendę:

#vi /root/.bashrc

Naciskamy "i" i dopisujemy do pliku:

ulimit -u unlimited
ulimit -n 90000

Wciskamy Esc i wpisujemy :wq aby wyjść z pliku i zapisać zmiany. Ustawiliśmy dzięki temu limit uruchomionych procesów dla użytkownika root na nieskończony i maksymalną ilość otwartych plików dla danego procesu na 90 tyś.. Teraz trzeba się prze-logować, wejść z powrotem do terminala dla użytkownika root żeby zmiany były widoczne dla systemu, możemy sprawdzić zmianę ustawień wpisując komendę:

# ulimit -a

Dzięki temu stworzona instancja serwera uruchamia się bez żadnych komplikacji i w końcu mamy dostęp do konsoli administratora.

//EDIT 3 - 12.04.2010r 16:00

Jeżeli chcemy korzystać z serwera z poziomu dowolnego użytkownika, najpierw upewniamy się, że nie otrzymamy ponownie błędu spowodowanego limitem na liczbę otwartych plików, tym razem zwiększamy limit dla danego użytkownika, pomocny LINK.

Otwieramy z poziomu roota plik limits.conf:

# vi /etc/security/limits.conf

Dodajemy dwie linijki tuż przed końcem pliku:

uzytkownik hard nofile 65535
uzytkownik soft nofile 65535

Wychodzimy z pliku zapisując go i przechodzimy do najważniejszej części, czyli nadania wybranemu użytkownikowi praw do katalogu z WAS/WPS, logujemy się jako root w terminalu i wpisujemy komendę:

# chown -R uzytkownik /katalog/z/WAS/WPS
w moim przypadku: # chown -R rafal /home/rafal/ibm

Dzięki temu serwer uruchamia się bez poniższego błędu:

The system is unable to read document cells/localhostNode01Cell/nodes/localhostNode01/node-metadata.properties:java.io.IOException:Permission denied

Kolejnym krokiem w realizowanym projekcie będzie konfiguracja bazy danych DB2 i uruchomienie pierwszej aplikacji Grails na WPS.

Instalacja WAS i WPS na Red Hat Enterprise Linux

2010-04-01T10:26:00.000-07:00

Zainstalowałem linuxa na VMware, przeglądarkę firefox (v. 3.6.2) i przy instalacji WebSphere Process Server v7 (WPS) zaczynają się schody. WebSphere Application Server v7 (WAS) instaluje się bez problemu, jednak gdy odpalam komendę ./launchpad.sh i próbuję zainstalować WPS nie jest już tak kolorowo. Już na samym starcie konsola pokazuje jakiś błąd, a kolejny pojawia się w momencie kliknięcia w miejsce, po którym powinna rozpocząć się instalacja WPS, oto błędy:

Ja próbuję dalej, pomysły jak rozwiązać ten problem mile widziane.

//EDIT 1

Gdy nie wywołuję launchpad.sh jako root i chcę zainstalować WPS jako non-root installation drugi błąd dalej występuje (bez pierwszego ostrzeżenia, które tak naprawdę można zignorować).

//EDIT 2

Problem rozwiązany, a był nim Security-Enhanced Linux (SELinux) i pewnie po części moja niewiedza, bo jakbym wcześniej korzystał z Linuxa to może bym wiedział o tej koncepcji. A chodzi w niej o politykę bezpieczeństwa opartej na zapewnieniu jak najmniejszej ilości uprawnień dla danego obiektu (np. konta użytkownika, urządzenia, programu) potrzebnych do jego poprawnego funkcjonowania, co ogranicza wielkość wyrządzonych szkód po przejęciu kontroli nad obiektem przez osoby nie powołane(źródło: wikipedia).

Aby temu zaradzić wybieramy z menu System>Administration>SELinux Management i zmieniamy ustawienia Enforcing Mode na Permissive(lub całkowicie wyłączamy tą usługę). Dalej instalacja przebiega bez powyższego błędu.

WAS i WPS zainstalowany, profile stworzone, kolejnym realizowanym celem będzie uruchomienie pierwszej aplikacji Grails na WPS.

Grails - wdrożenie war na tomcat + utrwalenie danych w MySQL/DB2

2010-03-26T16:20:00.000-07:00

W ciągu ostatnich kilku dni zajmowałem się powyższym tematem, w końcu mogę się podzielić z Wami wynikami mojej pracy w postaci "krótkiego" tutorialu. Myślę, że warto poświęcić Grailsowi trochę czasu, szczególnie jeżeli ktoś zajmuje się tworzeniem aplikacji webowych, których programowanie ułatwia omawiana tu platforma. Co jest takiego fajnego w Grails? Przede wszystkim to, że zapewnia wysoką produktywność w tworzeniu aplikacji webowych opartych o platformę Java, wykorzystuje sprawdzone technologie takie jak Hibernate i Spring oraz zbudowany jest w oparciu o dynamiczny język Groovy. Jest łatwy w nauce w szczególności dla programistów Java(ale nie tylko), ukrywa przed użytkownikiem wiele szczegółów konfiguracji i posiada wbudowane kompletne środowisko programistyczne(serwer aplikacji, bazę danych itp.).

Zakładam, że zmienne środowiskowe wskazujące na Grails i JDK są ustawione(jeżeli nie - wróć do poprzedniej notki). Otwieramy konsole Windows start>uruchom i tam wpisujemy cmd. Wybieramy dysk, na którym chcemy umieścić naszą aplikację, u mnie dysk D, wpisujemy:

C:\Documents and Settings\X>d:

Tworzymy naszą aplikację:

D:\>grails create-app Biblioteka

Chcemy mieć, co utrwalać, więc przechodzimy do katalogu naszej aplikacji, dalej będziemy tworzyć dwie domain-class i proste powiązanie między nimi:

D:\>cd biblioteka
D:\Biblioteka>grails create-domain-class Ksiazka

WARNING: You have not specified a package... (y, Y, n, N)

Zatwierdzamy ostrzegający komunikat(przez który wcześniej miałem problemy w Netbeans IDE) bo do prostej aplikacji nie potrzebujemy pakietów.

Tak jak poprzednio, tworzymy kolejną domain-class - Czytelnik.

Każda biblioteka ma swoich czytelników, w tym przykładzie również przyda nam się czytelnik, aby pokazać relację pomiędzy dwoma klasami, która będzie miała odzwierciedlenie w naszej bazie danych. Teraz chcemy powiązać te dwie klasy - wypożyczamy książkę czytelnikowi, w Groovy robimy to podobnie jak w Javie dodając pole Czytelnik do klasy Ksiazka. Każdy czytelnik może wypożyczyć wiele książek, a jedna książka może mieć maksymalnie jednego czytelnika, aby otrzymać relację wiele-do-jednego(ang. many-to-one LINK) wystarczy w klasie Czytelnik dodać jedną linijkę kodu. Dodamy jeszcze inne pola klasy, przejdź do katalogu z nowo utworzonymi domain-class, czyli D:\Biblioteka\grails-app\domain\

Otwieramy najpierw klasę Ksiazka i uzupełniamy ją o poniższy kod:

class Ksiazka {

        String autor
        String tytul
        String rokWydania
        Czytelnik czytelnik

    static constraints = {
            autor()
            tytul()
            rokWydania()
            czytelnik(nullable : true)
    }
}

Dla zainteresowanych deklaracją constraints - LINK.

Uzupełniamy klasę Czytelnik kodem:

class Czytelnik {

        String imie
        String nazwisko

        static hasMany = [ ksiazki : Ksiazka ]

        static constraints = {
            imie()
            nazwisko()
            ksiazki(nullable : true)
        }
}

Po wpisaniu kodu, wracamy do konsoli i wpisujemy komendę:

D:\Biblioteka>grails generate-all Ksiazka

Tą samą komendę wywołujemy z parametrem Czytelnik, ta komenda generuje nam implementację elementu bardzo ułatwiającego życie programisty, czyli generuje interfejs CRUD (Create/Read/Update/Delete) dla wybranej klasy. LINK

Przed konfiguracją bazy danych przygotujemy tomcata do pracy, ściągamy LINK, rozpakowujemy i ustawiamy zmienne środowiskowe LINK.

W projekcie realizowanym na praktykach używać będę DB2, więc skonfiguruję sobie połączenie z bazą DB2 i MySQL(z którą miałem wcześniej do czynienia).

Jeżeli interesuje Cię tylko DB2 to omiń część notki poświęconą MySQL.

Konfiguracja MySQL

Dla tych, co zdecydowali się na MySQL LINK do pobrania. Ściągamy od razu bibliotekę, którą wrzucimy później do naszej aplikacji - LINK.

Uruchamiamy serwer - można to zrobić na dwa sposoby, włączyć usługę ręcznie w panelu sterowania>narzędzia administracyjne>usługi i znaleźć pozycję MySQL, lub wpisując komendę:

>net start mysql //uruchamiamy usługę
>net stop mysql //kończymy usługę

Jednak powyższa metoda u mnie nie działa, mimo, że mam poprawnie ustawioną zmienną PATH dla MySQL oraz serwer zainstalowany jako usługę systemu Windows.

Teraz czas na stworzenie bazy danych, otwieramy linie poleceń MySQL (start>programy>MySQL Command Line Client), logujemy się podając wcześniej ustalone hasło dla swojego profilu i wpisujemy:

MySQL>create database biblioteka;

Grails przygotował dla swoich użytkowników kolejne ułatwienie podążając za sloganem konwencja ponad konfiguracje (z ang. convention over configuration), tym razem zmieniając tylko kilka linijek kodu w pliku D:\Biblioteka\grails-app\conf\DataSource.Groovy konfigurujemy połączenie:

dataSource {
   pooled = true
   driverClassName = "com.mysql.jdbc.Driver"
   username = "root"
   password = "root"
}
// environment specific settings
environments {
    development {
        dataSource {
            dbCreate = "update"
            url = "jdbc:mysql://localhost:3306/biblioteka"
        }
    }
}

Zastępujemy bazowe ustawienia na powyższe, jeżeli będziemy korzystać z innych środowisk uruchomieniowych bazy danych to nadmieniamy tylko url do bazy danych dla danego środowiska. LINK

Mamy stworzoną aplikację, bazę danych, przygotowanego tomcata, odpaloną usługę MySQL, teraz tworzymy war uruchamiając komendę:

D:\Biblioteka>grails war Biblioteka.war

Kopiujemy utworzonego wara do katalogu \Apache Tomcat 6.0.20\webapps oraz wcześniej pobranego mysql-connector-java-5.1.12-bin.jar do folderu naszej aplikacji D:\Biblioteka\lib.

Komendą:

>startup

uruchamiamy tomcata.

Widzimy w konsoli tomcata, którego wcześniej uruchomiliśmy, że rozpoczeło się automatyczne wdrażanie war na serwer, jeżeli wszystko przebiegło pomyślnie otwieramy naszą aplikację podając link:

http://localhost:8080/Bilbioteka

Możemy teraz stworzyć czytelnika, potem dwie książki - wybierając w polu czytelnik wcześniej stworzoną osobę tak, aby upewnić się, że nasza relacja zachodzi - wracamy do czytelnika i widzimy, że w polu Książki ma podane dwie pozycję.

Konfiguracja DB2

Pobranie DB2 nawet w wersji darmowej, czyli Express-C wymaga rejestracji na stronie IBM, rejestrujemy się, logujemy i pobieramy LINK.

Instalujemy, zapamiętujemy użytkownika i hasło, które podaliśmy. Teraz jak poprzednio tworzymy bazę danych, ale najpierw uruchamiamy serwer, znowu na dwa sposoby albo uruchamiając usługę, albo start>IBM DB2>Command Line Tools>Command Window:

>db2start

Teraz IBM DB2>Command Line Tools>Command Line Processor i wpisujemy:

db2 =>create database biblio

Pamiętając o tym, że nasza baza danych może zawierać do 8 znaków bo inaczej otrzymamy błąd - LINK.

Znowu nadmieniamy kod w pliku D:\Biblioteka\grails-app\conf\DataSource.Groovy:

dataSource {
    pooled = true
    driverClassName ="COM.ibm.db2.jdbc.app.DB2Driver"
    username = "MOJ_UZYTKOWNIK"
    password = "MOJE_HASLO"
}
environments {
    development {
    dataSource {
            dbCreate = "update"
            url = "jdbc:db2:biblio"
    }
}

Teraz część, z którą miałem więcej problemów, wybranie odpowiedniej biblioteki do połączenia z bazą danych. Na początku skonfigurowałem połączenie dla tomcata wbudowanego w Grails, kopiujemy plik z katalogu instalacyjnego DB2 u mnie \DB2express-c_971\SQLLIB\java\db2jcc4.jar do D:\Biblioteka\lib. Używając komendy:

D:\Bilbioteka>grails run-app

powinno wszystko działać.

Jednak żeby działało połączenie z DB2 na osobnym serwerze tomcat musiałem się trochę bardziej natrudzić, wiecej rzeczy przetestować i przewertować trochę wiecej informacji, aby w końcu natrafić na użyteczny LINK. W kroku 6 podpunkcie 3 znalazłem odpowiedź, "wystarczy" przekopiować plik \DB2express-c_971\SQLLIB\java\db2java.zip i zmienić jego rozszerzenie na .jar do katalogu \tomcat\lib. Teraz gdy wrzucimy nasz plik Biblioteka.war do webapps w tomcat i zrestartujemy serwer możemy się cieszyć działającą aplikacją.

Kolejnym krokiem realizowanym w ramach praktyk będzie zainstalowanie IBM WebSphere Process Server (WPS) na wirtualnej maszynie z systemem Linux.

Grails - pierwsze kroki, podsumowanie

2010-03-19T07:49:00.000-07:00

Stworzenie pierwszej aplikacji webowej w Grails jest bardzo proste więc myślę, że nie ma sensu opisywać szczegółowo jak to zrobić(tymbardziej, że jest już wiele dostępnych materiałów w sieci). Podam za to parę linków, które mogą pomóc początkującemu użytkownikowi Grails:

1. Pobieramy Grails (najlepiej najnowszą wersję, ja korzystam z wersji 1.3-M1) - http://www.grails.org/Download.

2. Ustawiamy zmienne środowiskowe - http://www.grails.org/Installation.

3. Możemy stworzyć naszą pierwszą aplikację:
a) najprostsza aplikacja z możliwych - HelloWorld.
b) trochę większa aplikacja - opis krok po kroku + utrwalanie danych w HSQL.
c) połączenie Grails z bazą danych MySQL - http://www.jaceklaskowski.pl/wiki/Grails_z_MySQL
d) zbiór tutoriali z developerWorks - http://www.grails.org/Tutorials

4. Możemy również zintegrować Grails z obsługującym go IDE i tam w jeszcze bardziej ułatwiony sposób tworzyć nasze aplikacje - http://www.grails.org/IDE+Integration.

Ja na początek wybrałem tą nieco łatwiejszą drogę, czyli Grails w środowisku Netbeans, chociaż praca przy samych tutorialach w konsoli windows jest równie prosta, ale bardziej czasochłonna. Miałem małe problemy, które jak się okazało później sam sobie przysporzyłem. Zainstalowałem Grails 1.2.1, zabrałem się do tworzenia pierwszej domain-class i w momencie tworzenia klasy, w oknie output w Netbeans pojawia się komunikat, ostrzeżenie, że nie powinno się tworzyć klas bez pakietów i czy chce kontynuować. W tym momencie Netbeans się zawiesza, można jedynie wpisać coś w okno tworzenia klasy i wtedy się odwiesza, tylko, że jedyne wyjście jakie pozostaje to wcisnąć cancel. :)

Jak się później okazało można było po prostu stworzyć klasy komendami Grails - prawym na projekt i run grails command. Jeszcze tego nie wiedząc zainstalowałem starszą wersję Grails 1.1.2. Co prawda naprawiło to wcześniejszy błąd, ale podczas późniejszej pracy z bazą danych MySQL pojawiły się kolejne błędy, które znowu naprawione były w nowszej wersji Grails.

Do nauki na początek polecam książkę, o której przeczytałem na blogu mojego mentora Jacka Laskowskiego - Dave Klein Grails A Quick Start Guide, Oct.2009. Jest w niej ciekawy przykład, książkę przyjemnie się czyta, a szczególnie zachęcająca jest ilość stron. :)

Wiem jak pracuje się nad Grailsem w Netbeans i konsoli Windows, jak skonfigurować Grails żeby korzystał z bazy danych MySQL. Następny krok to własnoręczne wdrożenie wygenerowanego pliku war na osobny serwer tomcat i skonfigurowanie bazy danych DB2 albo Oracle XE.

Notka wprowadzająca - praktyki IBM

2010-03-19T07:27:00.000-07:00

Tytułem wstępu:

Witam wszystkich na moim blogu. :)

Jest to moja pierwsza styczność z notowaniem w internecie tego, co robię w swoim życiu, proszę o podwójną wyrozumiałość z tego względu, że będę się starał zamieszczać tutaj postępy moich prac nad nowo poznanymi technologiami, tworzonymi projektami itp., a nie jestem specjalistą w tej dziedzinie.

Jako, że niedługo kończę studia, a w CV nadal pusto, jakiś czas temu podjąłem decyzję o wzięciu udziału w praktykach IBM. Postaram się zamieszczać na swoim blogu postępy w mojej pracy nad tematem projektu jaki sobie wybrałem: "Creating user interface for Human Tasks in IBM WebSphere Process Server V7 with Grails".

Główne cele mojej pracy obejmować będą:

1. Naukę Grails.

2. Uruchomienie Grails na Websphere Process Server (WPS).

3. Stworzenie przykładowego procesu biznesowego w Websphere Integration Developer (WID) z zadaniem użytkownika (z ang. Human Task).

4. Rozpoznanie sposobu tworzenia interfejsu użytkownika dla procesu biznesowego w Grails.

5. Stworzenie interfejsu użytkownika, o którym mowa w powyższym punkcie.

6. Podsumowanie pracy w postaci dokumentu.

Cała praca wykonana będzie na VMware z Linuksem. Już od jakiegoś czasu realizuję pierwszy cel, niedługo postaram się napisać jak mi idzie.