예제 #1
0
    def __init__(self, waEnviron, service=None, loadjson=True):
        waResourceAdmin.__init__(self, waEnviron, loadjson)
        if service is None:
            i = self.pathinfo.index("services")
            if i > 0 and i < len(self.pathinfo) - 1:
                self.service = self.pathinfo[i + 1]
            else:
                self.service = None
        else:
            self.service = service

        self.checkAuthorization()

        #set default config path
        if not os.path.isdir(self.waconf.paths["services"]):
            raise Exception(
                "servicespath is not configured in the wa.cfg file [%s]." %
                self.waconf.paths["services"])

        defaultCFGpath = os.path.join(self.waconf.paths["services"],
                                      "default.cfg")
        if not os.path.isfile(defaultCFGpath):
            raise Exception(
                "istsos [default] configuration file not found in %s." %
                (defaultCFGpath))

        if not (self.service is None or self.service == 'default'):
            serviceCFGpath = os.path.join(self.waconf.paths["services"],
                                          "%s" % self.service,
                                          "%s.cfg" % self.service)
            if not os.path.isfile(serviceCFGpath):
                raise ServiceNotFound(
                    "istsos [%s] configuration file not found in %s." %
                    (self.service, serviceCFGpath), self.service)
            self.servicepath = os.path.join(self.waconf.paths["services"],
                                            "%s" % self.service)

            sensormlpath = os.path.join(self.waconf.paths["services"],
                                        "%s" % self.service, "sml")
            if not os.path.isdir(sensormlpath):
                raise Exception(
                    "istsos [%s] sensorML folder not found in %s." %
                    (self.service, sensormlpath))
            self.sensormlpath = sensormlpath

            virtualpath = os.path.join(self.waconf.paths["services"],
                                       "%s" % self.service, "virtual")
            if not os.path.isdir(virtualpath):
                raise Exception(
                    "istsos [%s] virtual procedures folder not found in %s." %
                    (self.service, virtualpath))
            self.virtualpath = virtualpath

        if self.service == None or self.service == 'default':
            self.serviceconf = configManager.waServiceConfig(defaultCFGpath)
        else:
            self.serviceconf = configManager.waServiceConfig(
                defaultCFGpath, serviceCFGpath)
예제 #2
0
    def __init__(self):
        """

        """
        defaultCFGpath = path.join(
            path.dirname(path.split(path.abspath(__file__))[0]),
            "services/default.cfg")
        self.serviceconf = configManager.waServiceConfig(defaultCFGpath)
        now = datetime.datetime.now().replace(tzinfo=timezone(time.tzname[0]))
        self.__setDate(now)
예제 #3
0
    def __init__(self, waEnviron, service=None, loadjson=True):
        waResourceAdmin.__init__(self, waEnviron, loadjson)

        if service == None:
            i = self.pathinfo.index("services")
            if i > 0 and i < len(self.pathinfo) - 1:
                self.service = self.pathinfo[i + 1]
            else:
                self.service = None

        else:
            self.service = service

        # set default config path
        if not os.path.isdir(self.waconf.paths["services"]):
            raise Exception("servicespath is not configured in the wa.cfg file [%s]." % self.waconf.paths["services"])

        defaultCFGpath = os.path.join(self.waconf.paths["services"], "default.cfg")
        if not os.path.isfile(defaultCFGpath):
            raise Exception("istsos [default] configuration file not found in %s." % (defaultCFGpath))

        if not (self.service == None or self.service == "default"):
            serviceCFGpath = os.path.join(self.waconf.paths["services"], "%s" % self.service, "%s.cfg" % self.service)
            if not os.path.isfile(serviceCFGpath):
                raise Exception("istsos [%s] configuration file not found in %s." % (self.service, serviceCFGpath))
            self.servicepath = os.path.join(self.waconf.paths["services"], "%s" % self.service)

            sensormlpath = os.path.join(self.waconf.paths["services"], "%s" % self.service, "sml")
            if not os.path.isdir(sensormlpath):
                raise Exception("istsos [%s] sensorML folder not found in %s." % (self.service, sensormlpath))
            self.sensormlpath = sensormlpath

            virtualpath = os.path.join(self.waconf.paths["services"], "%s" % self.service, "virtual")
            if not os.path.isdir(virtualpath):
                raise Exception("istsos [%s] virtual procedures folder not found in %s." % (self.service, virtualpath))
            self.virtualpath = virtualpath

        if self.service == None or self.service == "default":
            self.serviceconf = configManager.waServiceConfig(defaultCFGpath)
        else:
            self.serviceconf = configManager.waServiceConfig(defaultCFGpath, serviceCFGpath)
예제 #4
0
    def __init__(self, conf=None):
        """ Initialize the MQTTMediator class
        conf
        """
        self.lock = threading.Lock()
        self.conf = conf
        self.broker = {}
        self.services = {}
        defaultCfg = os.path.join(config.services_path, "default.cfg")
        instances = utils.getServiceList(config.services_path, listonly=False)
        for instance in instances:
            sc = configManager.waServiceConfig(defaultCfg, instance['path'])
            conn = databaseManager.PgDB(sc.connection["user"],
                                        sc.connection["password"],
                                        sc.connection["dbname"],
                                        sc.connection["host"],
                                        sc.connection["port"])
            self.services[instance['service']] = {"config": sc, "conn": conn}
            # Get mqtt configurations
            rows = conn.select("""
                SELECT id_prc, mqtt_prc, name_prc FROM %s.procedures""" %
                               (instance['service']))

            for row in rows:
                if row[1] is not None and row[1] != '':
                    mqttConf = json.loads(row[1])
                    if 'broker_port' in mqttConf and (
                            mqttConf['broker_port'] is not None
                            and mqttConf['broker_port'] != ''):
                        broker_url = "%s:%s" % (mqttConf['broker_url'],
                                                mqttConf['broker_port'])

                    else:
                        broker_url = "%s:1883" % (mqttConf['broker_url'])

                    topic = mqttConf['broker_topic']
                    if broker_url not in self.broker:
                        self.broker[broker_url] = {}

                    self.broker[broker_url][topic] = {
                        "id": row[0],
                        "name": row[2],
                        "instance": instance['service']
                    }
예제 #5
0
    def __init__(self, wnsEnviron, loadjson=True):
        """
        Initialize resource object
        @param wnsEnviron: wnsEnviron variable see L(wa)
        @type wnsEnviron: C{dictionary}
        """
        self.response = {
            "success": True,
            "message": ""
        }
        self.wnsEnviron = wnsEnviron
        self.method = wnsEnviron['method']
        self.pathinfo = wnsEnviron['pathinfo']
        self.json = None
        self.postRequest = None
        if self.method in ["POST", "PUT"] and loadjson:
            import json
            self.json = ut.encodeobject(json.loads(wnsEnviron['wsgi_input']))

        defaultCFGpath = os.path.join(wnsEnviron["services_path"],
                                                    "default.cfg")
        self.serviceconf = configManager.waServiceConfig(defaultCFGpath)
예제 #6
0
파일: operation.py 프로젝트: rom1Bv/istsos2
    def __init__(self, wnsEnviron, loadjson=True):
        """
        Initialize resource object
        
        parameters:
            wnsEnviron (dict): wnsEnviron variable see L(wa)
        """
        self.response = {
            "success": True,
            "message": ""
        }
        self.wnsEnviron = wnsEnviron
        self.method = wnsEnviron['method']
        self.pathinfo = wnsEnviron['pathinfo']
        self.json = None
        self.postRequest = None
        if self.method in ["POST", "PUT"] and loadjson:
            import json
            self.json = ut.encodeobject(json.loads(wnsEnviron['wsgi_input']))

        defaultCFGpath = os.path.join(wnsEnviron["services_path"],
                                                    "default.cfg")
        self.serviceconf = configManager.waServiceConfig(defaultCFGpath)
예제 #7
0
 def executeGet(self):
     try:
         os.path.isdir(self.waconf.paths["istsos"])
     except:
         error = "istsos lib not found at path %s" % self.waconf.paths["istsos"]
         print >> sys.stderr, error
     try:
         os.path.isdir(self.waconf.paths["services"])
     except:
         error = "services lib not found at path %s" % self.waconf.paths["services"]
         print >> sys.stderr, error
     defaultcfgpath = os.path.join(self.waconf.paths["services"],"default.cfg")
     try:
         os.path.isfile(defaultcfgpath)
     except:
         error = "default service configuration file at path %s" % defaultcfgpath
         print >> sys.stderr, error
     config = configManager.waServiceConfig(defaultcfgpath)
 
     self.setData({"level" : config.initialization["level"]})
     if int(config.initialization["level"]) == 0:
         self.setMessage("Your istsos has not been initializated jet")
     else:
         self.setMessage("Your istsos has been initializated")
예제 #8
0
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
#
#===============================================================================
from os import path
from walib import configManager
import os
import sys

import config

defaultCFGpath = path.join(config.services_path, "default.cfg")
serviceconf = configManager.waServiceConfig(defaultCFGpath)
services_path = path.join(config.wns_path, "notifications.aps")
wns_script_path = path.join(config.wns_path, "scripts")


def delNotification(name):
    """Delete selected notification

    remove notification from notification.aps, data-base and
    remove the function file

    Args:
        name (str): Name of the notification

    """
    aps_file = open(services_path, 'r')
예제 #9
0
파일: istsos.py 프로젝트: rom1Bv/istsos2
    def executeGet(self):
        """
        Execute GET request investigating set-up services

        @note: This method creates a C{self.data} object in the form of a
        list of dictionaries as below:

        >>> template = {
                "service" : None,
                "offerings" : None,
                "procedures" : None,
                "observedProperties" : None,
                "featuresOfInterest" : None,
                "getCapabilities" : None,
                "describeSensor" : None,
                "getObservations" : None,
                "registerSensor" : None,
                "insertObservation" : None,
                "getFeatureOfInterest" : None,
                "availability" : "up"
            }
        """
        services = utils.getServiceList(
            self.waconf.paths["services"],
            listonly=True)

        if self.user and not self.user.isAdmin():
            servicesAllowed = []
            for item in services:
                if self.user.allowedService(item):
                    servicesAllowed.append(item)
            services = servicesAllowed

        data = []
        for service in services:
            srv = {}
            srv["service"] = service

            # get service configuration
            defaultcfgpath = os.path.join(
                self.waconf.paths["services"],
                "default.cfg")

            servicecfgpath = "%s.cfg" % os.path.join(
                self.waconf.paths["services"],
                service, service)

            config = configManager.waServiceConfig(
                defaultcfgpath, servicecfgpath)

            # test if service is active (check answer to GetCapabilities)
            if config.serviceurl["default"] is True:
                urlget = config.serviceurl["url"] + "/" + service
            else:
                urlget = config.serviceurl["url"]

            request = ("?request=getCapabilities&"
                       "section=serviceidentification&service=SOS")

            srv["availability"] = utils.verifyxmlservice(
                urlget+request, self.waEnviron)

            # test if connection is valid
            connection = config.get("connection")

            try:
                servicedb = databaseManager.PgDB(
                    connection['user'],
                    connection['password'],
                    connection['dbname'],
                    connection['host'],
                    connection['port']
                )
                srv["database"] = "active"

            except:
                srv["database"] = "not connectable"
                srv["offerings"] = None
                srv["procedures"] = None
                srv["observedProperties"] = None
                srv["featuresOfInterest"] = None

            try:
                #count offerings
                srv["offerings"] = len(
                    utils.getOfferingNamesList(servicedb, service))
            except:
                srv["offerings"] = None

            try:
                #count procedures
                srv["procedures"] = len(
                    utils.getProcedureNamesList(
                        servicedb, service, offering=None))
            except:
                srv["procedures"] = None

            try:
                #count observed properties
                srv["observedProperties"] = len(
                    utils.getObsPropNamesList(
                        servicedb, service, offering=None))
            except:
                srv["observedProperties"] = None

            try:
                #count features of interest
                srv["featuresOfInterest"] = len(
                    utils.getFoiNamesList(servicedb, service, offering=None))
            except:
                srv["featuresOfInterest"] = None

            #get available requests
            requests_ON = config.parameters["requests"].split(",")
            for operation in [
                    "getcapabilities", "describesensor", "getobservation",
                    "getfeatureofinterest", "insertobservation",
                    "registersensor"]:

                if operation in requests_ON:
                    srv[operation] = True
                else:
                    srv[operation] = False
            data.append(srv)

        self.setData(data)
        self.setMessage("Serverstatus request successfully executed")
예제 #10
0
    def executeGet(self):
        """
        Method for executing a GET requests that rename a SOS service

            .. note::  This method renames:
                1. service folder,
                2. service configuration file
                3. the databse schema

            The POST must be in Json format with mandatory service key

            >>> {
                    "service" : "service_name"
                }
        """
        #check to be at service level without serviceID provided in url
        if self.urlservicename is None:
            try:
                serviceslist = utils.getServiceList(
                    self.waEnviron["services_path"], listonly=False)

                if self.user and not self.user.isAdmin():
                    servicesAllowed = []
                    for item in serviceslist:
                        if self.user.allowedService(item['service']):
                            servicesAllowed.append(item)
                    serviceslist = servicesAllowed

            except Exception as ex:
                print >> sys.stderr, traceback.print_exc()
                raise ex

            self.setData(serviceslist)
            self.setMessage(
                "Services list successfully retrived: found [%s] services" %
                (len(serviceslist)))

        else:
            try:
                serviceslist = utils.getServiceList(
                    self.waEnviron["services_path"], listonly=True)

                if not (self.urlservicename in serviceslist):
                    raise Exception("")

            except Exception as ex:
                print >> sys.stderr, traceback.print_exc()
                raise ex

            #get database connection and initialize it
            defaultcfgpath = os.path.join(self.waEnviron["services_path"],
                                          "default.cfg")

            servicecfgpath = "%s.cfg" % os.path.join(
                self.waEnviron["services_path"], self.urlservicename,
                self.urlservicename)

            config = configManager.waServiceConfig(defaultcfgpath,
                                                   servicecfgpath)

            connection = config.get("connection")

            #test if connection is valid
            servicedb = databaseManager.PgDB(connection['user'],
                                             connection['password'],
                                             connection['dbname'],
                                             connection['host'],
                                             connection['port'])
            self.setData({
                "service": self.urlservicename,
                "user": connection['user'],
                #"password" : connection['password'],
                "password": "******",
                "dbname": connection['dbname'],
                "host": connection['host'],
                "port": connection['port']
            })
            self.setMessage(
                "Informations of service <%s> successfully retrived" %
                (self.urlservicename))
예제 #11
0
    def executePost(self,db=True):
        """
        Method for executing a POST requests that initialize a new SOS service
                      
        .. note::  This method creates:
            1. service folder, 
            2. service configuration file
            3. C{sensorML} folder
            4. C{virtual procedures} folder
            5. a new schema with the same name of your service
            6. istSOS tables and relations in the new schema
        
        The POST must be in Json format with mandatory service key, if databease keys 
        are not provided the server default connection are used:
                
        >>> {
                "service" : "service_name", 
                "user" : "pinco"
                "password" : "pallino"
                "dbname" : "sos_db"
                "host" : "10.7.5.3"
                "port" : "5432"
            } 
        """
        
        #check to be at service level without serviceID provided in url
        if not self.urlservicename == None and db==True:
            raise Exception("POST action with url service name not supported")
            
        #check that service name was provided
        if not "service" in self.json:
            raise Exception("PUT action require the new service name sent within request body")
        
        #validate schemaname against injection
        utils.preventInjection(self.json["service"])
        
        #validate db connection
        #-------------------------------------
        jsoncount = 0
        dbkeys = ["user","password","dbname","host","port"]
        for key in dbkeys:
            if key in self.json :
                jsoncount += 1
        
        
        defaultcfgpath = os.path.join(self.waEnviron["services_path"],"default.cfg")
        defaultconfig = configManager.waServiceConfig(defaultcfgpath)
        
        if jsoncount == 5:
            servicedb = databaseManager.PgDB(
                self.json["user"],
                self.json["password"],
                self.json["dbname"],
                self.json["host"],
                self.json["port"])
        
        elif jsoncount == 0:
            defaultconnection = defaultconfig.get("connection")
            servicedb = databaseManager.PgDB(
                defaultconnection['user'],
                defaultconnection['password'],
                defaultconnection['dbname'],
                defaultconnection['host'],
                defaultconnection['port'])
                
        else:
            raise Exception("db parameters [service,user,password,dbname,host,port] must be all or none provided")
        
        #verify that the schema does not exist
        #-------------------------------------
        sql = "SELECT count(*) from pg_namespace WHERE nspname = %s"
        par = (self.json["service"],)
        res = servicedb.select(sql,par)
        if len(res)==1:
            pass
        else:
            raise Exception("a schema '%s' already exist" % self.json["service"])
        
        #check if service folder does not exist: in case create it
        #-------------------------------------------------------------------        
        newservicepath = os.path.join( self.waEnviron["services_path"],self.json["service"] )
        try:
            os.makedirs(newservicepath)
        except OSError as exc:
            if exc.errno == errno.EEXIST:
                raise Exception("Service %s already exist" %(self.json["service"]) )
            else:
                raise exc
      
        #create configuration file
        #-------------------------------------------------------------------
        configfile = os.path.join(self.waEnviron["services_path"],self.json["service"],self.json["service"])+".cfg"
        open(configfile, 'w').close()
        #--set EPSGdefault
        
        #create sensorML folder
        #-------------------------------------------------------------------
        smldir = os.path.join(self.waEnviron["services_path"],self.json["service"],"sml")
        os.makedirs(smldir)
        
        #create virtual procedure path
        #-------------------------------------------------------------------
        virtualdir = os.path.join(self.waEnviron["services_path"],self.json["service"],"virtual")
        os.makedirs(virtualdir)
        
        if db==True:
            try:
                
                #create schema
                #-------------------------------------------------------------------
                sql = "CREATE SCHEMA %s" % self.json["service"]
                servicedb.executeInTransaction(sql)
                
                #set db path
                #-------------------------------------------------------------------
                sql = "SET search_path = %s, public, pg_catalog" % self.json["service"]
                servicedb.executeInTransaction(sql,par)
                
                #create tableas and relations
                #-------------------------------------------------------------------
                from walib import sqlschema
                defaultepsg = defaultconfig.get("geo")['istsosepsg']
                import sys
                if not "epsg" in self.json:
                    sql = sqlschema.createsqlschema.replace("$SRID",defaultepsg).replace("$schema",self.json["service"])
                else:
                    sql = sqlschema.createsqlschema.replace("$SRID",self.json['epsg'])
                    
                    #set correct default EPSG of the new service
                    #-------------------------------------------------------------------
                    newconfig = configManager.waServiceConfig(defaultcfgpath,configfile)
                    allowed = newconfig.get('geo')['allowedEPSG'].split(",")
                    if self.json['epsg'] in allowed:
                        newallowedepsg = ",".join([x for x in allowed if x != self.json['epsg']])
                        newconfig.put('geo','allowedEPSG',newallowedepsg)
                        newconfig.save() 
                    newconfig.put('geo','istsosepsg',self.json['epsg'])
                    newconfig.save()
                servicedb.executeInTransaction(sql)
            
                servicedb.commitTransaction()
            except:
                servicedb.rollbackTransaction()
                raise
        




        
        # Setting proxy configuration
        from walib.istsos.services.configsections import serviceurl
        surl = configManager.waServiceConfig(defaultcfgpath, configfile)
        
        url = ''
        if self.waEnviron['server_port'] == '80':
            url = 'http://'
        else:
            url = 'https://'
        
        url = "%s%s%s/%s" % (url, self.waEnviron['server_name'], self.waEnviron['script_name'], self.json["service"])
        
        surl.put("serviceurl", "url", url)
        surl.save()




        
        self.setMessage( "New service <%s> correctly created" % str(self.json["service"]) )
예제 #12
0
 def executePut(self):
     """
     Method for executing a PUT requests that rename a SOS service
                       
         .. note:: This method renames:
             1. create a new service folder, 
             2. copy content from old to new service configuration file
             3. rename the databse schema
             4. delete old service files
         
         The POST must be in Json format with mandatory service key
                 
         >>> {
                 "service" : "service_name"
             } 
     """
     
     #check to be at service level without serviceID provided in url
     #-------------------------------------------------------------------        
     if self.urlservicename == None:
         raise Exception("PUT action with url service name not supported")
     
     #check that service name was provided
     #-------------------------------------------------------------------        
     if not "service" in self.json:
         raise Exception("PUT action require the new service name sent within request body")
     
     
     #create a new service with new name
     #-------------------------------------------------------------------        
     try:
         self.executePost(db=False)
     except:
         raise
     
     #copy configuration file to new configuration file name
     #-------------------------------------------------------------------        
     try:
         defaultcfgpath = os.path.join(self.waEnviron["services_path"],"default.cfg")
         servicecfgpath = os.path.join(self.waEnviron["services_path"],self.urlservicename,self.urlservicename)+".cfg"
         newservicecfgpath = os.path.join(self.waEnviron["services_path"],self.json["service"],self.json["service"])+".cfg"
         of = open(servicecfgpath, "r")
         content = of.read()
         of.close()
         nf = open(newservicecfgpath, 'w')
         nf.write(content)
         nf.close()
     except:
         #remove new files
         shutil.rmtree(os.path.join(self.waEnviron["services_path"],self.json["service"]))
         raise Exception("cannot copy configuration file content")
     
     #rename database schema to new service name
     #-------------------------------------------------------------------
     try:
         config = configManager.waServiceConfig(defaultcfgpath,servicecfgpath)
         connection = config.get("connection")
         servicedb = databaseManager.PgDB(connection['user'],
                                     connection['password'],
                                     connection['dbname'],
                                     connection['host'],
                                     connection['port']
         )
         sql = "ALTER SCHEMA %s RENAME TO %s" %(self.urlservicename,str(self.json["service"]))
         servicedb.executeInTransaction(sql)
     except:
         #remove new files
         shutil.rmtree(os.path.join(self.waEnviron["services_path"],self.json["service"]))
         raise #Exception("invalid alter schema sql")
     
     #remove service folder and subfolder contents
     #-------------------------------------------------------------------        
     try:
         shutil.rmtree(os.path.join(self.waEnviron["services_path"],self.urlservicename))
     except:
         servicedb.rollbackTransaction()
         
     servicedb.commitTransaction()
     self.setMessage("service <%s> successfully renamed to <%s>" %(self.urlservicename,str(self.json["service"])))
예제 #13
0
 def executeDelete(self):
     """
     Method for executing a DELETE requests that erase a SOS service
                       
         .. note::  This method delete:
             1. service folder, 
             2. service configuration file
             3. C{sensorML} folder
             4. C{virtual procedures} folder
             5. a new schema with the same name of your service
             6. istSOS tables and relations in the new schema
         
         The POST must be in Json format with mandatory service key
                 
         >>> {
                 "service" : "service_name"
             } 
     """
     #check schemaname input
     if self.urlservicename == None:
         raise Exception("DELETE action without url service name not supported")
     
     #validate schemaname against injection
     utils.preventInjection(self.urlservicename)
     
     #get database connection and initialize it
     defaultcfgpath = os.path.join(self.waEnviron["services_path"],"default.cfg")
     servicepath = os.path.join(self.waEnviron["services_path"],self.urlservicename)
     servicecfgpath = os.path.join(self.waEnviron["services_path"],self.urlservicename,self.urlservicename)+".cfg"
     
     if not os.path.isdir(servicepath):
         raise Exception("service [%s] does not exists." % self.urlservicename)
     if not os.path.isdir(os.path.join(self.waEnviron["services_path"],self.urlservicename,"virtual")):
         raise Exception("service [%s] misconfigured, missing <virtual> folder." % self.urlservicename)
     if not os.path.isdir(os.path.join(self.waEnviron["services_path"],self.urlservicename,"sml")):
         raise Exception("service [%s] misconfigured, missing <sml> folder." % self.urlservicename)
     if not os.path.isfile(servicecfgpath):
         raise Exception("service [%s] misconfigured, missing config file." % self.urlservicename)
   
     config = configManager.waServiceConfig(defaultcfgpath,servicecfgpath)
     connection = config.get("connection")
     servicedb = databaseManager.PgDB(connection['user'],
                                 connection['password'],
                                 connection['dbname'],
                                 connection['host'],
                                 connection['port']
     )
     #verify that the schema exist
     #-------------------------------------
     sql = "SELECT count(*) from pg_namespace WHERE nspname = %s"
     par = (self.urlservicename,)
     res = servicedb.select(sql,par)
     if len(res)==1:
         pass
     else:
         raise Exception("the db schema <<%s>> doesn't exist" % self.urlservicename)
     
     try:
         #drop schema
         #-------------------------------------------------------------------
         sql = "DROP SCHEMA %s CASCADE" % self.urlservicename
         servicedb.executeInTransaction(sql)
                 
         #remove service folder and subfolder contents
         #-------------------------------------------------------------------        
         shutil.rmtree(servicepath)
         
         servicedb.commitTransaction()
         
     except:
         servicedb.rollbackTransaction()
         raise
     self.setMessage("Service <%s> correctly deleted" % self.urlservicename)
예제 #14
0
 def executeGet(self):
     """
     Execute GET request investigating set-up services
                   
     @note: This method creates a C{self.data} object in the form of a list of
     dictionaries as below:
         
     >>> template = {"service" : None, 
                     "offerings" : None,
                     "procedures" : None,
                     "observedProperties" : None,
                     "featuresOfInterest" : None,
                     "getCapabilities" : None,
                     "describeSensor" : None,
                     "getObservations" : None,
                     "registerSensor" : None,
                     "insertObservation" : None,
                     "getFeatureOfInterest" : None,
                     "availability" : "up"
                     } 
     """
     services = utils.getServiceList(self.waconf.paths["services"],listonly=True)
     data = []
     for service in services:
         srv = {}
         srv["service"] = service
         
         #get service configuration
         #-------------------------------------------------------------------
         defaultcfgpath = os.path.join(self.waconf.paths["services"],"default.cfg")
         servicecfgpath = os.path.join(self.waconf.paths["services"],service,service)+".cfg"
         config = configManager.waServiceConfig(defaultcfgpath,servicecfgpath)
         
         #test if service is active (check answer to GetCapabilities)
         #-------------------------------------------------------------------
         if config.serviceurl["default"] == True:
             urlget = config.serviceurl["url"] + "/" + service
         else:
             urlget = config.serviceurl["url"]
         
         request = "?request=getCapabilities&section=serviceidentification&service=SOS"
                     
         srv["availability"] = utils.verifyxmlservice(urlget+request)
         
         #test if connection is valid
         #-------------------------------------------------------------------
         connection = config.get("connection")
         try:
             servicedb = databaseManager.PgDB(connection['user'],
                                         connection['password'],
                                         connection['dbname'],
                                         connection['host'],
                                         connection['port']
             )
             srv["database"] = "active"
         except:
             srv["database"] = "not connectable"
             srv["offerings"] = None
             srv["procedures"] = None
             srv["observedProperties"] = None
             srv["featuresOfInterest"] = None
         try:
             #count offerings
             #-------------------------------------------------------------------
             srv["offerings"] = len(utils.getOfferingNamesList(servicedb,service))
         except:
             srv["offerings"] = None
             
         try:
             #count procedures
             #-------------------------------------------------------------------
             srv["procedures"] = len(utils.getProcedureNamesList(servicedb,service,offering=None))
         except:
             srv["procedures"] = None
         
         try:
             #count observed properties
             #-------------------------------------------------------------------
             srv["observedProperties"] = len(utils.getObsPropNamesList(servicedb,service,offering=None))
         except:
             srv["observedProperties"] = None
             
         try:
             #count features of interest
             #-------------------------------------------------------------------
             srv["featuresOfInterest"] = len(utils.getFoiNamesList(servicedb,service,offering=None))
         except:
             srv["featuresOfInterest"] = None
         
         #get available requests
         #-------------------------------------------------------------------
         requests_ON = config.parameters["requests"].split(",")
         for operation in ["getcapabilities","describesensor","getobservation",
                             "getfeatureofinterest","insertobservation","registersensor"]:
             if operation in requests_ON:
                 srv[operation]=True
             else:
                 srv[operation]=False
         data.append(srv)
     self.setData(data)
     self.setMessage("Serverstatus request successfully executed")
예제 #15
0
 def executePut(self):
     defaultcfgpath = os.path.join(self.waconf.paths["services"],"default.cfg")
     config = configManager.waServiceConfig(defaultcfgpath)
     config.put("initialization","level",self.json["level"])
     config.save()
     self.setMessage("Initializatuion level successfully recorded")
예제 #16
0
    def executeDelete(self):
        """
        Method for executing a DELETE requests that erase a SOS service

            .. note::  This method delete:
                1. service folder,
                2. service configuration file
                3. C{sensorML} folder
                4. C{virtual procedures} folder
                5. a new schema with the same name of your service
                6. istSOS tables and relations in the new schema

            The POST must be in Json format with mandatory service key

            >>> {
                    "service" : "service_name"
                }
        """
        #check schemaname input
        if self.urlservicename is None:
            raise Exception("DELETE action without url service"
                            "name not supported")

        #validate schemaname against injection
        utils.preventInjection(self.urlservicename)

        #get database connection and initialize it
        defaultcfgpath = os.path.join(self.waEnviron["services_path"],
                                      "default.cfg")

        servicepath = os.path.join(self.waEnviron["services_path"],
                                   self.urlservicename)

        servicecfgpath = "%s.cfg" % os.path.join(
            self.waEnviron["services_path"], self.urlservicename,
            self.urlservicename)

        if not os.path.isdir(servicepath):
            raise Exception("service [%s] does not exists." %
                            self.urlservicename)

        if not os.path.isdir(
                os.path.join(self.waEnviron["services_path"],
                             self.urlservicename, "virtual")):
            raise Exception(
                "service [%s] misconfigured, missing <virtual> folder." %
                (self.urlservicename))

        if not os.path.isdir(
                os.path.join(self.waEnviron["services_path"],
                             self.urlservicename, "sml")):
            raise Exception(
                "service [%s] misconfigured, missing <sml> folder." %
                (self.urlservicename))

        if not os.path.isfile(servicecfgpath):
            raise Exception(
                "service [%s] misconfigured, missing config file." %
                (self.urlservicename))

        config = configManager.waServiceConfig(defaultcfgpath, servicecfgpath)
        connection = config.get("connection")
        servicedb = databaseManager.PgDB(connection['user'],
                                         connection['password'],
                                         connection['dbname'],
                                         connection['host'],
                                         connection['port'])
        #verify that the schema exist
        sql = "SELECT count(*) from pg_namespace WHERE nspname = %s"
        par = (self.urlservicename, )
        res = servicedb.select(sql, par)
        if len(res) == 1:
            pass

        else:
            raise Exception("the db schema <<%s>> doesn't exist" %
                            self.urlservicename)

        try:
            #drop schema
            sql = "DROP SCHEMA %s CASCADE" % self.urlservicename
            servicedb.executeInTransaction(sql)
            #remove service folder and subfolder contents
            shutil.rmtree(servicepath)
            servicedb.commitTransaction()

        except:
            servicedb.rollbackTransaction()
            raise

        self.setMessage("Service <%s> correctly deleted" % self.urlservicename)
예제 #17
0
    def executePut(self):
        """
        Method for executing a PUT requests that rename a SOS service

            .. note:: This method renames:
                1. create a new service folder,
                2. copy content from old to new service configuration file
                3. rename the databse schema
                4. delete old service files

            The POST must be in Json format with mandatory service key

            >>> {
                    "service" : "service_name"
                }
        """
        #check to be at service level without serviceID provided in url
        if self.urlservicename is None:
            raise Exception("PUT action with url service name not supported")

        #check that service name was provided
        if not "service" in self.json:
            raise Exception(
                "PUT action require the new service name sent within "
                "request body")

        #create a new service with new name
        try:
            self.executePost(db=False)
        except:
            raise

        #copy configuration file to new configuration file name
        try:
            defaultcfgpath = os.path.join(self.waEnviron["services_path"],
                                          "default.cfg")

            servicecfgpath = "%s.cfg" % os.path.join(
                self.waEnviron["services_path"], self.urlservicename,
                self.urlservicename)

            newservicecfgpath = "%s.cfg" % os.path.join(
                self.waEnviron["services_path"], self.json["service"],
                self.json["service"])

            of = open(servicecfgpath, "r")
            content = of.read()
            of.close()
            nf = open(newservicecfgpath, 'w')
            nf.write(content)
            nf.close()

        except:
            #remove new files
            shutil.rmtree(
                os.path.join(self.waEnviron["services_path"],
                             self.json["service"]))
            raise Exception("cannot copy configuration file content")

        #rename database schema to new service name
        try:
            config = configManager.waServiceConfig(defaultcfgpath,
                                                   servicecfgpath)
            connection = config.get("connection")
            servicedb = databaseManager.PgDB(connection['user'],
                                             connection['password'],
                                             connection['dbname'],
                                             connection['host'],
                                             connection['port'])
            sql = "ALTER SCHEMA %s RENAME TO %s" % (self.urlservicename,
                                                    str(self.json["service"]))
            servicedb.executeInTransaction(sql)

        except Exception as tex:
            #remove new files
            shutil.rmtree(
                os.path.join(self.waEnviron["services_path"],
                             self.json["service"]))
            raise tex

        #remove service folder and subfolder contents
        try:
            shutil.rmtree(
                os.path.join(self.waEnviron["services_path"],
                             self.urlservicename))
        except:
            servicedb.rollbackTransaction()

        servicedb.commitTransaction()
        self.setMessage("service <%s> successfully renamed to <%s>" %
                        (self.urlservicename, str(self.json["service"])))
예제 #18
0
 def executeGet(self):
     """
     Method for executing a GET requests that rename a SOS service
                       
         .. note::  This method renames:
             1. service folder, 
             2. service configuration file
             3. the databse schema
         
         The POST must be in Json format with mandatory service key
                 
         >>> {
                 "service" : "service_name"
             } 
     """
     #check to be at service level without serviceID provided in url
     #-------------------------------------------------------------------        
     if self.urlservicename == None:
         try:
             serviceslist = utils.getServiceList(self.waEnviron["services_path"],listonly=False)
         except Exception as ex:
             print >> sys.stderr, traceback.print_exc()
             raise ex
         self.setData(serviceslist)
         self.setMessage("Services list successfully retrived: found [%s] services" % len(serviceslist) )
         
     else:
         
         try:
             serviceslist = utils.getServiceList(self.waEnviron["services_path"],listonly=True)
             
             if not(self.urlservicename in serviceslist):
                 raise Exception("")
             
         except Exception as ex:
             print >> sys.stderr, traceback.print_exc()
             raise ex
         
         
         #get database connection and initialize it
         #-------------------------------------------------------------------
         defaultcfgpath = os.path.join(self.waEnviron["services_path"],"default.cfg")
         servicecfgpath = os.path.join(self.waEnviron["services_path"],self.urlservicename, self.urlservicename)+".cfg"
         config = configManager.waServiceConfig(defaultcfgpath,servicecfgpath)
         connection = config.get("connection")
         
         #test if connection is valid
         #-------------------------------------------------------------------
         servicedb = databaseManager.PgDB(connection['user'],
                                     connection['password'],
                                     connection['dbname'],
                                     connection['host'],
                                     connection['port']
         )
         self.setData({
             "service": self.urlservicename,
             "user" : connection['user'],
             "password" : connection['password'],
             "dbname" : connection['dbname'],
             "host" : connection['host'],
             "port" : connection['port']
         })
         self.setMessage("Informations of service <%s> successfully retrived" % self.urlservicename)
예제 #19
0
    def executePost(self, db=True):
        """Method for executing a POST requests that initialize a new
        SOS service

        .. note::  This method creates:
            1. service folder,
            2. service configuration file
            3. C{sensorML} folder
            4. C{virtual procedures} folder
            5. a new schema with the same name of your service
            6. istSOS tables and relations in the new schema

        The POST must be in Json format with mandatory service key, if
        databease keys are not provided the server default connection are used:

        >>> {
                "service" : "service_name",
                "user" : "pinco"
                "password" : "pallino"
                "dbname" : "sos_db"
                "host" : "10.7.5.3"
                "port" : "5432"
            }
        """

        # check to be at service level without serviceID provided in url
        if not self.urlservicename is None and db is True:
            raise Exception("POST action with url service name not supported")

        # check that service name was provided
        if not "service" in self.json:
            raise Exception("PUT action require the new service"
                            "name sent within request body")

        # validate schemaname against injection
        utils.preventInjection(self.json["service"])

        # validate db connection
        jsoncount = 0
        dbkeys = ["user", "password", "dbname", "host", "port"]
        for key in dbkeys:
            if key in self.json:
                jsoncount += 1

        defaultcfgpath = os.path.join(self.waEnviron["services_path"],
                                      "default.cfg")
        defaultconfig = configManager.waServiceConfig(defaultcfgpath)
        if jsoncount == 5:
            servicedb = databaseManager.PgDB(self.json["user"],
                                             self.json["password"],
                                             self.json["dbname"],
                                             self.json["host"],
                                             self.json["port"])

        elif jsoncount == 0:
            defaultconnection = defaultconfig.get("connection")
            servicedb = databaseManager.PgDB(defaultconnection['user'],
                                             defaultconnection['password'],
                                             defaultconnection['dbname'],
                                             defaultconnection['host'],
                                             defaultconnection['port'])

        else:
            raise Exception("db parameters [service, user, password, dbname, "
                            "host, port] must be all or none provided")

        # verify that the schema does not exist
        sql = "SELECT count(*) from pg_namespace WHERE nspname = %s"
        par = (self.json["service"], )
        res = servicedb.select(sql, par)
        if len(res) == 1:
            pass
        else:
            raise Exception("a schema '%s' already exist" %
                            self.json["service"])

        # check if service folder does not exist: in case create it
        newservicepath = os.path.join(self.waEnviron["services_path"],
                                      self.json["service"])
        try:
            os.makedirs(newservicepath)
        except OSError as exc:
            if exc.errno == errno.EEXIST:
                raise Exception("Service %s already exist" %
                                (self.json["service"]))
            else:
                raise exc

        # create configuration file
        configfile = "%s.cfg" % os.path.join(self.waEnviron["services_path"],
                                             self.json["service"],
                                             self.json["service"])

        open(configfile, 'w').close()
        # create sensorML folder
        smldir = os.path.join(self.waEnviron["services_path"],
                              self.json["service"], "sml")

        os.makedirs(smldir)
        # create virtual procedure path
        virtualdir = os.path.join(self.waEnviron["services_path"],
                                  self.json["service"], "virtual")

        os.makedirs(virtualdir)
        if db is True:
            try:
                #create schema
                sql = "CREATE SCHEMA %s" % self.json["service"]
                servicedb.executeInTransaction(sql)

                #set db path
                sql = "SET search_path = %s, public, pg_catalog" % (
                    self.json["service"])
                servicedb.executeInTransaction(sql, par)

                #create tableas and relations
                from walib import sqlschema
                defaultepsg = defaultconfig.get("geo")['istsosepsg']
                import sys
                if not "epsg" in self.json:
                    sql = sqlschema.createsqlschema.replace(
                        "$SRID", defaultepsg).replace("$schema",
                                                      self.json["service"])
                else:
                    sql = sqlschema.createsqlschema.replace(
                        "$SRID", self.json['epsg'])

                    #set correct default EPSG of the new service
                    newconfig = configManager.waServiceConfig(
                        defaultcfgpath, configfile)

                    allowed = newconfig.get('geo')['allowedEPSG'].split(",")
                    if self.json['epsg'] in allowed:
                        newallowedepsg = ",".join(
                            [x for x in allowed if x != self.json['epsg']])
                        newconfig.put('geo', 'allowedEPSG', newallowedepsg)
                        newconfig.save()

                    newconfig.put('geo', 'istsosepsg', self.json['epsg'])
                    newconfig.save()

                servicedb.executeInTransaction(sql)

                servicedb.commitTransaction()

            except:
                servicedb.rollbackTransaction()
                raise

        # Setting proxy configuration
        from walib.istsos.services.configsections import serviceurl
        surl = configManager.waServiceConfig(defaultcfgpath, configfile)

        url = ''
        if self.waEnviron['server_port'] == '80':
            url = 'http://'
        else:
            url = 'https://'

        url = "%s%s%s/%s" % (url, self.waEnviron['server_name'],
                             self.waEnviron['script_name'],
                             self.json["service"])

        surl.put("serviceurl", "url", url)
        surl.save()

        self.setMessage("New service <%s> correctly created" %
                        str(self.json["service"]))
예제 #20
0
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
#
# ===============================================================================
from os import path
from walib import configManager


defaultCFGpath = path.join(path.dirname(path.split(path.abspath(__file__))[0]),
                                         "services/default.cfg")
serviceconf = configManager.waServiceConfig(defaultCFGpath)
services_path = path.join(path.dirname(path.split(path.abspath(__file__))[0]),
                                             "services/notifications.aps")


def delNotification(name):

    aps_file = open(services_path, 'r')
    data = aps_file.readlines()
    aps_file.close()

    x = 0
    start = '### start ' + name + ' ###'
    end = '### end ' + name + ' ###'

    while not start in data[x]: