Grid Computing – Die helle Seite der Macht
Kommentare

Symphony definiert sein eigenes Frame­work, mit dessen Hilfe Code im Grid RPC-basiert oder Message-orientiert verteilt ausgeführt werden kann. Der ausführende Teil wird als Service bezeichnet und

Symphony definiert sein eigenes Frame­work, mit dessen Hilfe Code im Grid RPC-basiert oder Message-orientiert verteilt ausgeführt werden kann. Der ausführende Teil wird als Service bezeichnet und als Ableitung der Klasse ServiceContainer implementiert. Um die Jobs Message-orientiert mit Symphony ausführen zu können, wird ein JobContainer als Subtyp der Klasse ServiceContainer definiert (Listing 2). Trifft ein verteilter Auftrag an einem Knoten ein, wird die onInvoke-Methode des jeweiligen Service aufgerufen. Zur Ausführung eines Jobs werden daher innerhalb des JobContainer die eingehenden JobParameter ausgelesen, der Job instanziiert, initialilsiert und ausgeführt. Das Ergebnis der Ausführung wird an den Auftraggeber zurückgesendet.

Listing 2
---------------------------------------------------------------------
package grid.jobs;

import java.rmi.RemoteException;

import com.platform.symphony.soam.ServiceContainer;
import com.platform.symphony.soam.ServiceContext;
import com.platform.symphony.soam.SessionContext;
import com.platform.symphony.soam.SoamException;
import com.platform.symphony.soam.TaskContext;

public class JobContainer extends ServiceContainer {

     private ServiceContext serviceContext;
     private SessionContext sessionContext;
          
     public void onInvoke(TaskContext taskContext) throws SoamException {
          try {
               JobParameter params = (JobParameter) taskContext.getTaskInput();
               Job job = JobFactory.createNewJob(params);
               JobResult result = job.execute(this);
               taskContext.setTaskOutput(result);
          } catch (RemoteException e) {
               throw new SoamException(e);
          }
     }

     public void onCreateService(ServiceContext serviceContext) throws SoamException {
          this.serviceContext = serviceContext;
     }

     public void onSessionEnter(SessionContext sessionContext) throws SoamException {
          this.sessionContext = sessionContext;
     }

     public ServiceContext getServiceContext() {
          return serviceContext;
     }

     public SessionContext getSessionContext() {
          return sessionContext;
     }
     
}

Die Kernteile der auf dem Grid auszuführenden Geschäftslogik werden in Form eines Job implementiert. Um die Geschäftslogik des eingangs beschriebenen Use Cases zu implementieren, wird ein Job vom Typ CalculateRevenueJob erzeugt, der die Geschäftslogik in Form von Datenbank-Zugriffen enthält (Listing 3). Die Implementierung erfolgt innerhalb der execute-Methode.

Listing 3
-------------------------------------------------------------------
package businessLogic;

...

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import grid.jobs.Job;
import grid.jobs.JobContainer;
import grid.jobs.JobParameter;
import grid.jobs.JobResult;

public class CalculateRevenueJob implements Job {

     private CalculateRevenueJobParameter params;
     
     public JobResult execute(JobContainer container) throws RemoteException {
          String area = params.getArea();
          SessionFactory factory = null;
          Session sess = factory.openSession();
          Transaction tx = null;
          try {
              tx = sess.beginTransaction();
              //...
              long revenue = 0;
              //...
              tx.commit();
              return new CalculateRevenueJobResult(area, revenue);
          }
          catch (RuntimeException e) {
              if (tx != null) tx.rollback();
              throw new RemoteException(e.toString()); 
          }
          finally {
              sess.close();
          }
     }

     public void setJobParameter(JobParameter params) {
           this.params = (CalculateRevenueJobParameter) params;          
     }

     public JobParameter getJobParameter() {
          return params;
     }

}

Derjenige Teil der Gesamtapplika­tion, der auf dem Application Server Layer de­ployt wird, ist der gewohnte EJB-Code. Die EJB BalanceSheetServiceBean (Listing 4) bietet dem vorgelagerten Layer die Methode calculateRevenueJobs an. Übergabeparameter ist eine Collection vom Typ JobParameter. Rückgabetyp ist eine Collection vom Typ JobResult. Die Verteilung der Geschäftlogik auf dem Grid wurde in der Klasse SynchronousJobScheduler gekapselt. Sofern die Geschäftslogik asynchron aufgerufen werden soll, muss ein AsynchronousJobScheduler verwendet werden.

Listing 4
-------------------------------------------------------------------
package j2ee;

import grid.jobs.JobParameter;
import grid.jobs.JobResult;
import grid.management.SynchronousJobSchedulingSession;
import grid.management.SynchronousJobScheduler;
...
import com.platform.symphony.soam.SoamException;

/**
 * @ejb.bean name="BalanceSheetService"
 *           jndi-name="ejb/BalanceSheetService"
 *           type="Stateless"
 *           view-type="both"
 */
public class BalanceSheetServiceBean implements SessionBean {

     private SessionContext ctx;
     private SynchronousJobScheduler jobScheduler;

     ...
     
     /**
      * @throws CreateException
      * @ejb.create-method
      */
     public void ejbCreate() throws CreateException {
          try {
               jobScheduler = new SynchronousJobScheduler("BalanceSheetService",.);
          } catch (SoamException e) {
               throw new CreateException(e.toString());
          }
     }

     /**
      * @ejb.interface-method
      * @throws EJBException
      */
     public Collection calculateRevenues(Collection params) throws EJBException {
          try {
               SynchronousJobSchedulingSession jsSession = 
                    jobScheduler.createNewJobSchedulingSession(.);
               
               Collection results = jsSession.scheduleJobs(params);
               jsSession.close();
               return results;
          } catch (SoamException e) {
               throw new EJBException(e);
          }
     }
     ...
}

Angenommen, die EJB soll die Gewinne der Regionen Asien, Vereinigte Staaten, Europa und Afrika ermitteln. In diesem Fall werden der EJB-Methode vier verschiedene JobParameter für vier einzelne Jobs übergeben. Die Jobs werden parallel auf dem Grid verteilt. Somit wird die Last von der unter Umständen teuren Highend-Hardware des Application Server Layer genommen und an günstigere Infrastrukturkomponenten weitergereicht. Die Generation der EJBs und der Delegationslogik kann automatisiert werden.

Fazit

Grid Computing ist keine Technologie mehr, die ausschließlich in der wissenschaftlichen Forschung ihr Potenzial entfalten kann. Grid Computing eröffnet auch im Wirtschaftsleben neue Möglichkeiten. Besonders das Java EE-Umfeld, das in der Praxis häufig als langsam und teuer bekannt ist, wird durch Grid Computing in ein anderes Licht gestellt.

Praktisch umsetzbar sind Szenarien, in denen Java EE Server unterschiedlicher Hersteller bedarfsgesteuert und zeitversetzt auf ein- und derselben Maschine gestartet und angehalten werden. Die Steigerung der Realausnutzung der vorhandenen Infrastrukturressourcen kann sogar dahingehend erweitert werden, dass einzelne Systemteile der Gesamtarchitektur in virtuellen Partitionen (VMWare, Xen, Lpars, Solaris Container etc.) angestartet werden.

Beeindruckend sind Grids besonders dann, wenn wie beispielsweise auf mehreren hundert bis tausend Servern betrieben werden. Aus wirtschaftlicher Sicht sind Grids beeindruckend, wenn immer mehr Applikationen in einem bestehenden Grid deployt werden können, ohne dass weitere Hardware in großen Stückzahlen angeschafft werden muss.

Platform Symphony wird in einer Developer Edition kostenlos zur Verfügung gestellt. Die im Artikel abgedruckten Beispiele sind über eine Mail an den Autor mit dem Betreff „Symphony Samples“ erhältlich.

Torsten Langner ist Mitautor des Buches „J2EE mit JBoss“. Nach mehreren Jahren Beratung im Java EE-Umfeld hat er sich vor zwei Jahren entschlossen, eine Doktorarbeit in Zusammenarbeit mit der Postbank Systems zu erstellen. Er hofft, sie in diesem Jahr trotz Ehefrau und Hund fertig stellen zu können. Seit 2006 arbeitet er als Grid-Experte bei Platform Computing.
Unsere Redaktion empfiehlt:

Relevante Beiträge

Meinungen zu diesem Beitrag

X
- Gib Deinen Standort ein -
- or -