source: contributed/trunk/dail/dail.py @ 7306

# ----------------------------------------------------------------------
#    The dacheAdminInterfaceLib V0.3  26.04.2009
#    
#    Copyright (c) 2009 DESY IT (Sven Sternberger)
#    (All rights reversed)
#    Based on "getPoolInfos.py"  from DCACHE.ORG (R)
#
#    This program is free software; you can redistribute it and/or
#    modify it under the terms of version 2 of the GNU General Public
#    License published by the Free Software Foundation.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, contact Novell, Inc.
# ----------------------------------------------------------------------
#
# This is the first release it is NOT heavily tested.
# Please don't use this for critical tasks on your
# real world production system.
#-----------------------------------------------------------------------
# 0.2 - Empty results set causes endlless loop
# 0.3 - bug resolved if you contact different instances
#
#-----------------------------------------------------------------------

from org.pcells.services.connection import *
from dmg.protocols.ssh import *
from dmg.cells.nucleus import NoRouteToCellException
from java.lang import System
from java.io import File
from java.io import FileNotFoundException
import sys,time,types,string,threading,signal

DEBUG=False

class queryStore:
    def __init__(self):
        self.storeHash={}
      
    def save(self,id,obj):
        if DEBUG: print "Save ID: %d" % id
        self.storeHash[id]=obj

    def retrieve(self,id):
        if self.storeHash.has_key(id):
            return self.storeHash[id]
        else:
            return False

    def check(self,id):
        return self.storeHash.has_key(id)
      

class ourDomainEventListener( DomainEventListener,DomainConnectionListener) :
    connectionId=0
    queryId=0
    Connection=None
    activ=False
   
    def __init__(self,store):
        self.myStore=store

    def connectionOpened( self , connection ) :
        #self.__class__.connectionId+=1
        #self.__class__.Connection=connection
        #self.__class__.activ=True

        self.connectionId+=1
        self.Connection=connection
        self.activ=True
       
    def domainAnswerArrived( self , obj , id ) :
        if DEBUG: print "Answer id=%d // type=%s" % (id,type(obj))

        self.myStore.save(id,obj)
                     
      
    def _sendObject(self,cellName,cmd):
        self.__class__.queryId+=1
        if DEBUG:
           print "CellName: %s, Command: %s, queryid: %d" % (cellName,cmd,self.__class__.queryId)
           
        #self.__class__.Connection.sendObject( cellName, cmd , self, self.__class__.queryId) ;
        self.Connection.sendObject( cellName, cmd , self, self.__class__.queryId) ;
        
        return self.__class__.queryId


class queryDcache:
    def __init__(self,door,port,user,passwd):
        self.door=door
        if DEBUG:
            print "Query DOOR: %s" % (door)
            
        self.myStore=queryStore()

        #
        #  Define Host and portnumber
        #
        self.connection=Ssh1DomainConnection(door,port)
        self.connection.setLoginName(user)

        #
        # Establish the secret : either password or identity file
        #
        if passwd[0] == "/" :
            self.connection.setPassword("")
            try:
                self.connection.setIdentityFile( File(passwd) )
            except FileNotFoundException, e :
                sys.stderr.write("Authentication Failed ...%s" % (e.getMessage()))
                System.exit(1)

               
        else:
                self.connection.setPassword(passwd)

        #
        # Define the ListenerObject for all incoming message
        #
        self.MyDomainEventListener=ourDomainEventListener(self.myStore)
        self.connection.addDomainEventListener( self.MyDomainEventListener )

        #
        #  start the dcache connection thread
        #
        if DEBUG:
            print "Start Thread for %s" % (door)
        threading.Thread(target=self._startCellQuery).start()
        if DEBUG:
            print "Thread for %s started" % (door)


    def query(self,domain,cmd):
        self.timeOutCounter=0
        if DEBUG:
            print "Start Query DOOR: %s, CELL: %s, CMD: %s" % (self.door,domain,cmd)
        
        while not self.MyDomainEventListener.activ:
            time.sleep(1)
            self.timeOutCounter+=1      
            if self.timeOutCounter>2:
                return None
      
        if DEBUG:
            print "DOOR: %s, CELL: %s, CMD: %s" % (self.door,domain,cmd)
         
        self.queryId=self.MyDomainEventListener._sendObject(domain,cmd)

        while not self.myStore.check(self.queryId):
            if DEBUG: print "wait for %d" % (self.queryId)
            pass
     
        if DEBUG:
            print "Got answer: %s" % (type(self.myStore.retrieve(self.queryId)))
            
        return self.myStore.retrieve(self.queryId)                
                
            
    def _startCellQuery(self):

        def timeout_handler(signum, frame):
                raise SystemExit

        old_handler=signal.signal(signal.SIGALRM, timeout_handler)
        signal.alarm(2) 
                
        try:
                if DEBUG: print "Start connection ..."
                self.connection.go()
        except SshAuthenticationException, e :
                print "Authentication Failed ...",e.getMessage()
        finally:
                signal.signal(signal.SIGALRM, old_handler) 
                signal.alarm(0)

        System.exit(1)