Ejemplo n.º 1
0
    def create_style(self, name, sld, overwrite=False):
        style = self.get_style(name)
        if not overwrite:
            if style is not None:
                raise ConflictingDataError(
                    "There is already a style named %s" % name)

        headers = {
            "Content-type": "application/vnd.ogc.sld+xml",
            "Accept": "application/xml"
        }

        if overwrite and style is not None:
            style_url = url(self.service_url, ["styles", name + ".sld"])
            headers, response = self.http.request(style_url, "PUT", sld,
                                                  headers)
            if headers.status < 200 or headers.status > 299:
                raise UploadError(response)
        else:
            style_url = url(self.service_url, ["styles"], dict(name=name))
            headers, response = self.http.request(style_url, "POST", sld,
                                                  headers)

        self._cache.clear()
        if headers.status < 200 or headers.status > 299:
            raise UploadError(response)
Ejemplo n.º 2
0
    def create_style(self, name, sld, overwrite = False):
        style = self.get_style(name)
        if not overwrite:            
            if style is not None:
                raise ConflictingDataError("There is already a style named %s" % name)        

        
        if not overwrite or style is None:
            headers = {
                "Content-type": "application/xml",
                "Accept": "application/xml"
            }    
            xml = "<style><name>{0}</name><filename>{0}.sld</filename></style>".format(name)    
            style_url = url(self.service_url, ["styles"], dict(name=name))            
            headers, response = self.http.request(style_url, "POST", xml, headers)
            if headers.status < 200 or headers.status > 299: raise UploadError(response) 
            
        headers = {
            "Content-type": "application/vnd.ogc.sld+xml",
            "Accept": "application/xml"
        }
        style_url = url(self.service_url, ["styles", name + ".sld"])
        headers, response = self.http.request(style_url, "PUT", sld, headers)

        self._cache.clear()
        if headers.status < 200 or headers.status > 299: raise UploadError(response)                   
Ejemplo n.º 3
0
 def href(self):
     if self.workspace is not None:
         return url(self.catalog.service_url, [
             "workspaces", self.workspace.name, "styles", self.name + ".xml"
         ])
     else:
         return url(self.catalog.service_url,
                    ["styles", self.name + ".xml"])
Ejemplo n.º 4
0
 def get_layergroup(self, name=None):
     try: 
         group_url = url(self.service_url, ["layergroups", name + ".xml"])
         group = self.get_xml(group_url)
         return LayerGroup(self, group.find("name").text)
     except FailedRequestError:
         return None
Ejemplo n.º 5
0
    def create_pg_featuretype(self,
                              name,
                              store,
                              workspace=None,
                              srs="EPSG:4326"):

        if workspace is None:
            workspace = self.get_default_workspace()

        params = dict()
        workspace = util.name(workspace)
        store = util.name(store)
        ds_url = url(
            self.service_url,
            ["workspaces", workspace, "datastores", store, "featuretypes.xml"],
            params)

        #create the datastore
        headers = {"Content-type": "text/xml"}
        xml = ("<featureType>\n"
               "<enabled>true</enabled>\n"
               "<metadata />\n"
               "<keywords><string>KEYWORD</string></keywords>\n"
               "<projectionPolicy>REPROJECT_TO_DECLARED</projectionPolicy>\n"
               "<title>" + name + "</title>\n"
               "<name>" + name + "</name>\n"
               "<srs>" + srs + "</srs>"
               "</featureType>")

        headers, response = self.http.request(ds_url, "POST", xml, headers)

        if headers.status != 201 and headers.status != 200:
            raise UploadError(response)
Ejemplo n.º 6
0
    def create_pg_featuretype(self, name, store, workspace=None, srs = "EPSG:4326"):
        
        if workspace is None:
            workspace = self.get_default_workspace()
            
        params = dict()
        workspace = util.name(workspace)
        store = util.name(store)
        ds_url = url(self.service_url,
            ["workspaces", workspace, "datastores", store, "featuretypes.xml"], params)

        #create the datastore
        headers = {
            "Content-type": "text/xml"
        }
        xml = ("<featureType>\n" 
        "<enabled>true</enabled>\n" 
        "<metadata />\n" 
        "<keywords><string>KEYWORD</string></keywords>\n" 
        "<projectionPolicy>REPROJECT_TO_DECLARED</projectionPolicy>\n" 
        "<title>" + name + "</title>\n" 
        "<name>" + name +"</name>\n"         
        "<srs>" + srs +"</srs>" 
        "</featureType>")
        
        headers, response = self.http.request(ds_url, "POST", xml, headers)
               
        if headers.status != 201 and headers.status != 200:            
            raise UploadError(response)
Ejemplo n.º 7
0
    def add_data_to_store(self, store, name, data, workspace=None, overwrite = False, charset = None):
        if isinstance(store, basestring):
            store = self.get_store(store, workspace=workspace)
        if workspace is not None:
            workspace = util.name(workspace)
            assert store.workspace.name == workspace, "Specified store (%s) is not in specified workspace (%s)!" % (store, workspace)
        else:
            workspace = store.workspace.name
        store = store.name

        if isinstance(data, dict):
            bundle = prepare_upload_bundle(name, data)
        else:
            bundle = data

        params = dict()
        if overwrite:
            params["update"] = "overwrite"
        if charset is not None:
            params["charset"] = charset

        message = open(bundle)
        headers = { 'Content-Type': 'application/zip', 'Accept': 'application/xml' }
        upload_url = url(self.service_url, 
            ["workspaces", workspace, "datastores", store, "file.shp"], params) 

        try:
            headers, response = self.http.request(upload_url, "PUT", message, headers)
            self._cache.clear()
            if headers.status != 201:
                raise UploadError(response)
        finally:
            unlink(bundle)
Ejemplo n.º 8
0
    def update(self, settings):
        root = ET.Element('global')
        for section in settings:
            params = settings[section]
            element = ET.SubElement(root, section)
            for name, value in params:
                if '/' in name:
                    name, subname = name.split('/')
                    subelement = element.find(name)
                    if subelement is None:
                        subelement = ET.SubElement(element, name)
                    subsubelement = ET.SubElement(subelement, subname)
                    subsubelement.text = unicode(value)
                else:
                    subelement = ET.SubElement(element, name)
                    subelement.text = unicode(value)

        xml = ET.tostring(root)
        settings_url = url(self.catalog.service_url, ['settings.xml'])
        headers = {'Content-type': 'text/xml'}
        headers, response = self.http.request(settings_url,
                                              'PUT',
                                              xml,
                                              headers=headers)
        if headers.status != 200:
            raise Exception('Settings update failed - %s, %s' %
                            (headers, response))
Ejemplo n.º 9
0
 def get_layergroup(self, name=None):
     try:
         group_url = url(self.service_url, ["layergroups", name + ".xml"])
         group = self.get_xml(group_url)
         return LayerGroup(self, group.find("name").text)
     except FailedRequestError:
         return None
Ejemplo n.º 10
0
 def get_styles(self):
     styles_url = url(self.service_url, ["styles.xml"])
     description = self.get_xml(styles_url)
     return [
         Style(self,
               s.find('name').text) for s in description.findall("style")
     ]
Ejemplo n.º 11
0
    def get_resources(self):
        res_url = url(self.catalog.service_url,
            ["workspaces", self.workspace.name, "coveragestores", self.name, "coverages.xml"])

        xml = self.catalog.get_xml(res_url)
           
        def cov_from_node(node):
            return coverage_from_index(self.catalog, self.workspace, self, node)

        return [cov_from_node(node) for node in xml.findall("coverage")]
Ejemplo n.º 12
0
    def get_resources(self):
        res_url = url(self.catalog.service_url,
            ["workspaces", self.workspace.name, "datastores", self.name, "featuretypes.xml"])
        
        xml = self.catalog.get_xml(res_url)

        def ft_from_node(node):
            return featuretype_from_index(self.catalog, self.workspace, self, node)

        return [ft_from_node(node) for node in xml.findall("featureType")]
Ejemplo n.º 13
0
 def get_layers(self, resource=None):
     if isinstance(resource, basestring):
         resource = self.get_resource(resource)
     layers_url = url(self.service_url, ["layers.xml"])
     description = self.get_xml(layers_url)
     #dump(description)
     lyrs = [Layer(self, l.find("name").text) for l in description.findall("layer")]
     if resource is not None:
         lyrs = [l for l in lyrs if l.resource.href == resource.href]
     # TODO: Filter by style
     return lyrs
Ejemplo n.º 14
0
 def get_style(self, name, workspace = None):
     if workspace is not None:
         style_url = url(self.service_url, ["workspaces", workspace.name, "styles", name + ".xml"]) 
         try:
             dom = self.get_xml(style_url)
             return Style(self, name, workspace)
         except:
             return None           
     else:            
         style_url = url(self.service_url, ["styles", name + ".xml"])
         try:
             dom = self.get_xml(style_url)
             return Style(self, name)#dom.find("name").text)
         except:
             pass 
         for ws in self.get_workspaces():
             style = self.get_style(name, workspace=ws)
             if style is not None:
                 return style
         return None
Ejemplo n.º 15
0
    def create_shp_featurestore(self,
                                name,
                                data,
                                workspace=None,
                                overwrite=False,
                                charset=None):
        '''creates a shapefile-based datastore'''
        if workspace is None:
            workspace = self.get_default_workspace()
        if not overwrite:
            try:
                store = self.get_store(name, workspace)
                msg = "There is already a store named " + name
                if workspace:
                    msg += " in " + str(workspace)
                raise ConflictingDataError(msg)
            except FailedRequestError:
                # we don't really expect that every layer name will be taken
                pass

        workspace = util.name(workspace)
        params = dict()
        if charset is not None:
            params['charset'] = charset
        ds_url = url(self.service_url,
                     ["workspaces", workspace, "datastores", name, "file.shp"],
                     params)

        # PUT /workspaces/<ws>/datastores/<ds>/file.shp
        headers = {
            "Content-type": "application/zip",
            "Accept": "application/xml"
        }
        if isinstance(data, dict):
            logger.debug('Data is NOT a zipfile')
            archive = prepare_upload_bundle(name, data)
        else:
            logger.debug('Data is a zipfile')
            archive = data
        message = open(archive)
        try:
            headers, response = self.http.request(ds_url, "PUT", message,
                                                  headers)
            self._cache.clear()
            if headers.status != 201:
                raise UploadError(response)
        finally:
            try:
                unlink(archive)
            except WindowsError:
                #FIXME: handle this better
                pass
Ejemplo n.º 16
0
    def get_resources(self):
        res_url = url(self.catalog.service_url, [
            "workspaces", self.workspace.name, "datastores", self.name,
            "featuretypes.xml"
        ])

        xml = self.catalog.get_xml(res_url)

        def ft_from_node(node):
            return featuretype_from_index(self.catalog, self.workspace, self,
                                          node)

        return [ft_from_node(node) for node in xml.findall("featureType")]
Ejemplo n.º 17
0
    def get_resources(self):
        res_url = url(self.catalog.service_url, [
            "workspaces", self.workspace.name, "coveragestores", self.name,
            "coverages.xml"
        ])

        xml = self.catalog.get_xml(res_url)

        def cov_from_node(node):
            return coverage_from_index(self.catalog, self.workspace, self,
                                       node)

        return [cov_from_node(node) for node in xml.findall("coverage")]
Ejemplo n.º 18
0
 def get_style(self, name, workspace=None):
     if workspace is not None:
         style_url = url(
             self.service_url,
             ["workspaces", workspace.name, "styles", name + ".xml"])
         try:
             dom = self.get_xml(style_url)
             return Style(self, name, workspace)
         except:
             return None
     else:
         style_url = url(self.service_url, ["styles", name + ".xml"])
         try:
             dom = self.get_xml(style_url)
             return Style(self, name)  #dom.find("name").text)
         except:
             pass
         for ws in self.get_workspaces():
             style = self.get_style(name, workspace=ws)
             if style is not None:
                 return style
         return None
Ejemplo n.º 19
0
 def get_layers(self, resource=None):
     if isinstance(resource, basestring):
         resource = self.get_resource(resource)
     layers_url = url(self.service_url, ["layers.xml"])
     description = self.get_xml(layers_url)
     #dump(description)
     lyrs = [
         Layer(self,
               l.find("name").text) for l in description.findall("layer")
     ]
     if resource is not None:
         lyrs = [l for l in lyrs if l.resource.href == resource.href]
     # TODO: Filter by style
     return lyrs
Ejemplo n.º 20
0
    def create_coveragestore(self,
                             name,
                             data,
                             workspace=None,
                             overwrite=False):

        if workspace is None:
            workspace = self.get_default_workspace()

        if not overwrite:
            try:
                store = self.get_store(name, workspace)
                msg = "There is already a store named " + name
                if workspace:
                    msg += " in " + str(workspace)
                raise ConflictingDataError(msg)
            except FailedRequestError:
                # we don't really expect that every layer name will be taken
                pass

        headers = {"Content-type": "image/tiff", "Accept": "application/xml"}

        archive = None
        ext = "geotiff"

        if isinstance(data, dict):
            archive = prepare_upload_bundle(name, data)
            message = open(archive)
            if "tfw" in data:
                headers['Content-type'] = 'application/archive'
                ext = "worldimage"
        elif isinstance(data, basestring):
            message = open(data)
        else:
            message = data

        cs_url = url(self.service_url, [
            "workspaces", workspace.name, "coveragestores", name, "file." + ext
        ])

        try:
            headers, response = self.http.request(cs_url, "PUT", message,
                                                  headers)
            self._cache.clear()
            if headers.status != 201:
                raise UploadError(response)
        finally:
            if archive is not None:
                unlink(archive)
Ejemplo n.º 21
0
    def create_coveragestore(self, name, data, workspace=None, overwrite=False):
        
        if workspace is None:
            workspace = self.get_default_workspace()
            
        if not overwrite:
            try:
                store = self.get_store(name, workspace)
                msg = "There is already a store named " + name
                if workspace:
                    msg += " in " + str(workspace)
                raise ConflictingDataError(msg)
            except FailedRequestError:
                # we don't really expect that every layer name will be taken
                pass
        
        headers = {
            "Content-type": "image/tiff",
            "Accept": "application/xml"
        }

        archive = None
        ext = "geotiff"

        if isinstance(data, dict):
            archive = prepare_upload_bundle(name, data)
            message = open(archive)
            if "tfw" in data:
                headers['Content-type'] = 'application/archive'
                ext = "worldimage"
        elif isinstance(data, basestring):
            message = open(data)
        else:
            message = data

        cs_url = url(self.service_url,
            ["workspaces", workspace.name, "coveragestores", name, "file." + ext])

        try:
            headers, response = self.http.request(cs_url, "PUT", message, headers)
            self._cache.clear()
            if headers.status != 201:
                raise UploadError(response)
        finally:
            if archive is not None:
                unlink(archive)
Ejemplo n.º 22
0
    def add_data_to_store(self,
                          store,
                          name,
                          data,
                          workspace=None,
                          overwrite=False,
                          charset=None):
        if isinstance(store, basestring):
            store = self.get_store(store, workspace=workspace)
        if workspace is not None:
            workspace = util.name(workspace)
            assert store.workspace.name == workspace, "Specified store (%s) is not in specified workspace (%s)!" % (
                store, workspace)
        else:
            workspace = store.workspace.name
        store = store.name

        if isinstance(data, dict):
            bundle = prepare_upload_bundle(name, data)
        else:
            bundle = data

        params = dict()
        if overwrite:
            params["update"] = "overwrite"
        if charset is not None:
            params["charset"] = charset

        message = open(bundle)
        headers = {
            'Content-Type': 'application/zip',
            'Accept': 'application/xml'
        }
        upload_url = url(
            self.service_url,
            ["workspaces", workspace, "datastores", store, "file.shp"], params)

        try:
            headers, response = self.http.request(upload_url, "PUT", message,
                                                  headers)
            self._cache.clear()
            if headers.status != 201:
                raise UploadError(response)
        finally:
            unlink(bundle)
Ejemplo n.º 23
0
    def create_shp_featurestore(self, name, data, workspace=None, overwrite=False, charset=None):
        '''creates a shapefile-based datastore'''
        if workspace is None:
            workspace = self.get_default_workspace()
        if not overwrite:
            try:
                store = self.get_store(name, workspace)
                msg = "There is already a store named " + name
                if workspace:
                    msg += " in " + str(workspace)
                raise ConflictingDataError(msg)
            except FailedRequestError:
                # we don't really expect that every layer name will be taken
                pass
        
        workspace = util.name(workspace)
        params = dict()
        if charset is not None:
            params['charset'] = charset
        ds_url = url(self.service_url,
            ["workspaces", workspace, "datastores", name, "file.shp"], params)

        # PUT /workspaces/<ws>/datastores/<ds>/file.shp
        headers = {
            "Content-type": "application/zip",
            "Accept": "application/xml"
        }
        if isinstance(data,dict):
            logger.debug('Data is NOT a zipfile')
            archive = prepare_upload_bundle(name, data)
        else:
            logger.debug('Data is a zipfile')
            archive = data
        message = open(archive)
        try:
            headers, response = self.http.request(ds_url, "PUT", message, headers)
            self._cache.clear()
            if headers.status != 201:
                raise UploadError(response)
        finally:
            try:
                unlink(archive)
            except WindowsError:
                #FIXME: handle this better
                pass
Ejemplo n.º 24
0
 def settings(self):
     settings = {}     
     settings_url = url(self.catalog.service_url, ['settings.xml'])                            
     headers, response = self.http.request(settings_url, 'GET')
     if headers.status != 200: raise Exception('Settings listing failed - %s, %s' %
                                              (headers,response))        
     dom = XML(response)        
     sections = ['settings', 'jai','coverageAccess']
     for section in sections:
         params = []
         node = dom.find(section)
         if node is not None: #it will be none if the catalog does not support this operation
             for entry in node:
                 if len(entry) == 0:
                     params.append((entry.tag, entry.text))
                 else:
                     for subentry in entry:
                         params.append((entry.tag + '/' + subentry.tag, subentry.text))
             settings[section] = params       
             
     return settings
Ejemplo n.º 25
0
    def settings(self):
        settings = {}
        settings_url = url(self.catalog.service_url, ['settings.xml'])
        headers, response = self.http.request(settings_url, 'GET')
        if headers.status != 200:
            raise Exception('Settings listing failed - %s, %s' %
                            (headers, response))
        dom = XML(response)
        sections = ['settings', 'jai', 'coverageAccess']
        for section in sections:
            params = []
            node = dom.find(section)
            if node is not None:  #it will be none if the catalog does not support this operation
                for entry in node:
                    if len(entry) == 0:
                        params.append((entry.tag, entry.text))
                    else:
                        for subentry in entry:
                            params.append((entry.tag + '/' + subentry.tag,
                                           subentry.text))
                settings[section] = params

        return settings
Ejemplo n.º 26
0
 def update(self, settings):
     root = ET.Element('global')
     for section in settings:
         params = settings[section]
         element = ET.SubElement(root, section)
         for name, value in params:
             if '/' in name:
                 name, subname = name.split('/')
                 subelement = element.find(name)
                 if subelement is None:
                     subelement = ET.SubElement(element, name)
                 subsubelement = ET.SubElement(subelement, subname)
                 subsubelement.text = unicode(value)
             else:
                 subelement = ET.SubElement(element, name)
                 subelement.text = unicode(value)
     
     xml = ET.tostring(root)        
     settings_url = url(self.catalog.service_url, ['settings.xml'])  
     headers = {'Content-type': 'text/xml'}                          
     headers, response = self.http.request(settings_url, 'PUT', xml, headers = headers)
     if headers.status != 200: raise Exception('Settings update failed - %s, %s' %
                                              (headers,response))  
     
Ejemplo n.º 27
0
 def href(self):
     return url(self.catalog.service_url, [
         "workspaces", self.workspace.name, "datastores", self.store.name,
         "featuretypes", self.name + ".xml"
     ])
Ejemplo n.º 28
0
 def href(self):
     return url(self.catalog.service_url, [
         "workspaces", self.workspace.name, "coveragestores",
         self.store.name, "coverages", self.name + ".xml"
     ])
Ejemplo n.º 29
0
 def href(self):
     if self.workspace is not None:            
         return url(self.catalog.service_url, ["workspaces", self.workspace.name, "styles", self.name + ".xml"]) 
     else:
         return  url(self.catalog.service_url, ["styles", self.name + ".xml"])
Ejemplo n.º 30
0
 def href(self):
     return url(
         self.catalog.service_url,
         ["workspaces", self.workspace.name, "datastores", self.store.name, "featuretypes", self.name + ".xml"],
     )
Ejemplo n.º 31
0
 def href(self):
     return url(self.catalog.service_url,
         ["workspaces", self.workspace.name, "coveragestores", self.name + ".xml"])
Ejemplo n.º 32
0
 def href(self):
     return url(self.catalog.service_url, ["layers", self.name + ".xml"])
Ejemplo n.º 33
0
 def datastore_url(self):
     return url(self.catalog.service_url, ["workspaces", self.name, "datastores.xml"])
Ejemplo n.º 34
0
 def reload(self):
     reload_url = url(self.service_url, ['reload'])
     response = self.http.request(reload_url, "POST")
     self._cache.clear()
     return response
Ejemplo n.º 35
0
 def datastore_url(self):
     return url(self.catalog.service_url,
                ["workspaces", self.name, "datastores.xml"])
Ejemplo n.º 36
0
 def reload(self):
     reload_url = url(self.service_url, ['reload'])
     response = self.http.request(reload_url, "POST")
     self._cache.clear()
     return response
Ejemplo n.º 37
0
 def coveragestore_url(self):
     return url(self.catalog.service_url,
                ["workspaces", self.name, "coveragestores.xml"])
Ejemplo n.º 38
0
 def href(self):
     return url(self.catalog.service_url,
                ["workspaces", self.name + ".xml"])
Ejemplo n.º 39
0
 def href(self):
     return url(self.catalog.service_url,
         ["workspaces", self.workspace.name, "coveragestores"], dict(name=self.name))
Ejemplo n.º 40
0
 def get_styles(self):
     styles_url = url(self.service_url, ["styles.xml"])
     description = self.get_xml(styles_url)
     return [Style(self, s.find('name').text) for s in description.findall("style")]
Ejemplo n.º 41
0
    def create_pg_featurestore(self, name, workspace=None, overwrite=False, 
                               host="localhost", port = 5432 , database="db", schema="public", user="******", passwd=""):
        '''creates a postgis-based datastore'''
        
        if user == "" and passwd == "":
            raise Exception("Both username and password are empty strings. Use a different user/passwd combination")
        
        if workspace is None:
            workspace = self.get_default_workspace()
        try:
            store = self.get_store(name, workspace)
        except FailedRequestError:
            store = None
            
        if store is not None:              
            if overwrite:
                #if the existing store is the same we are trying to add, we do nothing
                params = store.connection_parameters                                
                if (str(params['port']) == str(port) and params['database'] == database and params['host'] == host
                        and params['user'] == user):
                    print "db connection already exists"
                    return
            else:                          
                msg = "There is already a store named " + name
                if workspace:
                    msg += " in " + str(workspace)
                raise ConflictingDataError(msg)            
            
        workspace = util.name(workspace)
        params = dict()
        

        #create the datastore
        headers = {
            "Content-type": "text/xml"
        }

        if user is None:
            raise Exception("Undefined user")
        
        xml = ("<dataStore>\n"
                "<name>" + name + "</name>\n"
                "<connectionParameters>"
                "<host>" + host + "</host>\n"
                "<port>" + str(port) + "</port>\n"
                "<database>" + database + "</database>\n"
                "<schema>" + schema + "</schema>\n"
                "<user>" + user + "</user>\n"
                "<passwd>" + passwd + "</passwd>\n"
                "<dbtype>postgis</dbtype>\n"
                "</connectionParameters>\n"
                "</dataStore>")
        
        if store is not None:
            ds_url = url(self.service_url,
                         ["workspaces", workspace, "datastores", name], params)
            headers, response = self.http.request(ds_url, "PUT", xml, headers)
        else:
            ds_url = url(self.service_url,
                         ["workspaces", workspace, "datastores.xml"], params)
            headers, response = self.http.request(ds_url, "POST", xml, headers)

        self._cache.clear()
        if headers.status != 201 and headers.status != 200:            
            raise UploadError(response)
Ejemplo n.º 42
0
    def create_pg_featurestore(self,
                               name,
                               workspace=None,
                               overwrite=False,
                               host="localhost",
                               port=5432,
                               database="db",
                               schema="public",
                               user="******",
                               passwd=""):
        '''creates a postgis-based datastore'''

        if user == "" and passwd == "":
            raise Exception(
                "Both username and password are empty strings. Use a different user/passwd combination"
            )

        if workspace is None:
            workspace = self.get_default_workspace()
        try:
            store = self.get_store(name, workspace)
        except FailedRequestError:
            store = None

        if store is not None:
            if overwrite:
                #if the existing store is the same we are trying to add, we do nothing
                params = store.connection_parameters
                if (str(params['port']) == str(port)
                        and params['database'] == database
                        and params['host'] == host and params['user'] == user):
                    print "db connection already exists"
                    return
            else:
                msg = "There is already a store named " + name
                if workspace:
                    msg += " in " + str(workspace)
                raise ConflictingDataError(msg)

        workspace = util.name(workspace)
        params = dict()

        #create the datastore
        headers = {"Content-type": "text/xml"}

        if user is None:
            raise Exception("Undefined user")

        xml = ("<dataStore>\n"
               "<name>" + name + "</name>\n"
               "<connectionParameters>"
               "<host>" + host + "</host>\n"
               "<port>" + str(port) + "</port>\n"
               "<database>" + database + "</database>\n"
               "<schema>" + schema + "</schema>\n"
               "<user>" + user + "</user>\n"
               "<passwd>" + passwd + "</passwd>\n"
               "<dbtype>postgis</dbtype>\n"
               "</connectionParameters>\n"
               "</dataStore>")

        if store is not None:
            ds_url = url(self.service_url,
                         ["workspaces", workspace, "datastores", name], params)
            headers, response = self.http.request(ds_url, "PUT", xml, headers)
        else:
            ds_url = url(self.service_url,
                         ["workspaces", workspace, "datastores.xml"], params)
            headers, response = self.http.request(ds_url, "POST", xml, headers)

        self._cache.clear()
        if headers.status != 201 and headers.status != 200:
            raise UploadError(response)
Ejemplo n.º 43
0
 def href(self):
     return url(self.catalog.service_url,
                ["workspaces", self.workspace.name, "coveragestores"],
                dict(name=self.name))
Ejemplo n.º 44
0
 def href(self):
     return url(self.catalog.service_url, ["layers", self.name + ".xml"])
Ejemplo n.º 45
0
 def href(self):
     path = [ "workspaces",
              self.workspace.name, "datastores"]
     query = dict(name=self.name)
     return url(self.catalog.service_url, path, query)
Ejemplo n.º 46
0
 def href(self):
     path = ["workspaces", self.workspace.name, "datastores"]
     query = dict(name=self.name)
     return url(self.catalog.service_url, path, query)
Ejemplo n.º 47
0
 def href(self):
     return url(self.catalog.service_url, ["workspaces", self.name + ".xml"])