Mailing-List: contact dev-help@airavata.apache.org; run by ezmlm
Precedence: bulk
Reply-To: dev@airavata.apache.org
Received-SPF: pass (nike.apache.org: domain of sanjayamrt@gmail.com designates
 209.85.214.170 as permitted sender)
MIME-Version: 1.0
Date: Tue, 11 Jun 2013 17:52:34 +0530
Message-ID: 
 <CAJEo2dFB=68BktGXoox4=iubZrzFs8m5KktrMmJkCnAkcA_U7w@mail.gmail.com>
Subject: GFac Handlers
From: Sanjaya Medonsa <sanjayamrt@gmail.com>
To: dev@airavata.apache.org
Content-Type: multipart/alternative; boundary=e89a8ff1bfcab210be04dedff30b

--e89a8ff1bfcab210be04dedff30b
Content-Type: text/plain; charset=ISO-8859-1

Hi,
     As per current design of Handlers, there are two types of handlers.
        1. IN Handlers
        2. OUT Handlers

Basically IN handler does the pre processing and out handler does the post
processing. With Airavata OODT integration, I am planning to implement IN
handler to perform file staging and out handler perform output ingesting
into CAS. That means two handler instances to handle pre/post processing.
In my scenario, this approach seems bit inefficient. Both IN/OUT handlers
are based on OODT PGETaskInstance. Due to current handler architecture, I
need to create two instance of PGETaskInstance (One for IN handler and one
for OUT handler). I guess we could have avoid this situation by having just
GFac handlers which could either be IN, OUT or IN/OUT. In my case, I
actually need to implement IN/OUT handler. In high level, I am proposing
the following approach.
        1. At configuration level no differentiation on IN/OUT handlers
        2. Instead GFacHandler interface should contain two methods
(preInvoke/postInvoke). Depending on the type of handler either pre/post
method should be implemented.
               PRE - preInvoke
               POST - postInvoke
               PRE/POST - Both preInvoke/postInvoke
        3. Either we could instantiate all the handlers initially and
invoke all pre methods prior to task execution and invoke all post methods
after task execution. If this approach is bit inefficient, then we could
introduce type into handlers (PRE/POST/PREPOST). Prior to task execution we
could instantiate PRE/PREPOST and invoke pre execution method.After task
execution we could instantiate POST handlers and  invoke postExceution
method for both POST/PREPOST handlers.

I guess Handler may not be the correct name here, we could name these
handlers as task wrappers as it refers in OODT. Let me know your feedback.

Cheers,
Sanjaya

--e89a8ff1bfcab210be04dedff30b--