def update_geonode(self, layer_name, title="", description="", category=None, bounds=None, store=None, extra_keywords=None): """ Update a layer and it's title in GeoNode :param layer_name: Name of the layer :param title: Title for layer :param description: Description for layer :param bounds: Bounds for layer :param store: Store for layer """ # Update the layer in GeoNode ulc = UpdateLayersCommand() ulc.handle(verbosity=1, filter=layer_name, store=store, workspace=DEFAULT_WORKSPACE) if title: from geonode.layers.models import Layer lyr = Layer.objects.get(typename='geonode:{}'.format(layer_name)) lyr.title = title lyr.abstract = description if category: lyr.category = category lyr.save() if bounds: from geonode.layers.models import Layer res = lyr.gs_resource res.native_bbox = bounds _user, _password = ogc_server_settings.credentials url = ogc_server_settings.rest gs_catalog = Catalog(url, _user, _password) gs_catalog.save(res) if extra_keywords: assert isinstance(extra_keywords, list) # Append extra keywords to the default ones res = lyr.gs_resource keywords = res.keywords + extra_keywords res.keywords = keywords _user, _password = ogc_server_settings.credentials url = ogc_server_settings.rest gs_catalog = Catalog(url, _user, _password) gs_catalog.save(res)
def add_new_sld_to_layer(self, formatted_sld_object): """ (3) Add new SLD to Layer """ # get the catalog geoserver_catalog = Catalog(settings.GEOSERVER_BASE_URL + "rest",\ settings.GEOSERVER_CREDENTIALS[0],\ settings.GEOSERVER_CREDENTIALS[1]) # pull the layer the_layer = geoserver_catalog.get_layer(self.layer_name) # set the new style the_layer.default_style.update_body(formatted_sld_object.formatted_sld_xml) # save it try: server_resp = geoserver_catalog.save(the_layer) print ('------server_resp----\n', server_resp) except FailedRequestError as fail_obj: # Attempt to restore previous SLD self.restore_old_sld(the_layer) # self.add_err_msg("Failed to add a new style. Error: %s" % fail_obj.message) return False except: # Attempt to restore previous SLD self.restore_old_sld(the_layer) # err_msg = "Unexpected error: %s" % sys.exc_info()[0] self.add_err_msg("Failed to add the new style. Error: %s" % err_msg) return False self.layer_metadata = LayerMetadata.create_metadata_using_layer_name(self.layer_name) return True
def buildOverviews(): try: image=os.path.join(uploadfiles[0],'chaneltransformRPC.tif') gdal.AllRegister() TransformDS = gdal.Open(image.encode('utf-8').decode(), gdal.GA_ReadOnly) Width = TransformDS.RasterXSize Heigh = TransformDS.RasterYSize PixelNum = Width * Heigh TopNum = 4096 CurNum = PixelNum / 4 anLevels = [] nLevelCount = 0 while (CurNum > TopNum): anLevels.append(pow(2, nLevelCount + 2)) nLevelCount += 1 CurNum /= 4 TransformDS.BuildOverviews(overviewlist=anLevels) cat = Catalog(map_url,'admin', 'geoserver') wkspce = cat.get_workspace('Map') cat.create_coveragestore_external_geotiff(name=id, data='file://' + image.encode('utf-8').decode('utf-8'), workspace=wkspce) cat.reload() TransformDS = None except Exception as e: return Exception("上传失败,建立金字塔出错"+str(e))
def reload_config(instances): """Perform requests against GeoServer REST API to reload configurations on slaves Optional environment variables: GS_RELOAD_INTERVAL: time in seconds to delay between slave instance reloads GS_PROTOCOL: protocol prefix, should be set to 'HTTP' or 'HTTPS' GS_RELATIVE_URL: relative URL to GeoServer REST API :param instances: list of hostname:port requests :return: """ logging.info('Sending reload requests separated by %s second delay' % RELOAD_INTERVAL) for instance in instances: url = '%s://%s%s' % (PROTOCOL, instance, RELATIVE_URL) logging.info('Performing GeoServer configuration reload at: %s' % url) catalog = Catalog(url) result = catalog.reload() if result and result[0]: if 200 <= result[0].status < 300: logging.info('Successful configuration reload.') else: raise Exception( 'Failure processing reload with status %s and reason: %s' % (result[0].status, result[0].reason)) else: logging.error('No result received from reload request!') sleep(RELOAD_INTERVAL)
def delete_map(request): map_id = request.POST.get('map_id', False) cat = Catalog(map_url, 'admin', 'geoserver') if cat.get_layer('Map:' + map_id): cat.delete(cat.get_layer('Map:' + map_id)) cat.reload() for label_type in range(1, 8): if cat.get_layer('Mask:' + map_id + '_' + str(label_type)): cat.delete(cat.get_layer('Mask:' + map_id + '_' + str(label_type))) cat.reload() try: if cat.get_store(map_id): st = cat.get_store(map_id) cat.delete(st) cat.reload() except Exception: pass if Bmap.objects.filter(id=map_id): map_name = Bmap.objects.get(id=map_id).name dir_root = os.path.join(MAPBASEPATH, map_name) delete_files = (map_id + ".jpg", 'chaneltransform.tif', 'chaneltransform_rpc.txt', 'chaneltransformRPC.txt', 'chaneltransformRPC.tif.ovr', 'label.tif', 'label_rpc.txt', 'labelRPC.tif') for file in delete_files: if os.path.exists(file): os.remove(os.path.join(dir_root, file)) Bmap.objects.filter(id=map_id).delete() return HttpResponse("success")
def publishRasters(folder): # publish adaptation output files (tifs) as wms geoserver_api = settings.GEOSERVER_URL + '/rest' cat = Catalog(geoserver_api, settings.GEOSERVER_USER, settings.GEOSERVER_PASS) out_dir = settings.DATA_DIR + folder _files = os.listdir(out_dir) wms_layers = [] for file in _files: if fnmatch.fnmatch(file, '*.tif'): # unique store/layer name with timestamp tif_ext = datetime.now().strftime('%Y%m%d%H%M%S%f') _tif_ext = '_' + tif_ext + '.tif' _file = file.replace('.tif', _tif_ext) # publish to geoserver tiff = out_dir + '/' + file cat.create_coveragestore(_file, tiff) wms_layers.append(_file) return wms_layers
def main(): parser = argparse.ArgumentParser( description="OWS12 Sentinel harvest granules script.") parser.add_argument('-c', '--catalog', nargs=3, help='Geoserver REST URL and authentication', default=('http://localhost:8080/geoserver/rest', 'admin', 'geoserver')) parser.add_argument( '-s', '--store', nargs=1, help='The store name to retrieve coverages with workspace name ' '(ows12:landsat)') parser.add_argument( '-i', '--insert', action="store_true", default=False, help='Harvest (insert) new granule on a given mosaic store') parser.add_argument('-d', '--delete', nargs=1, type=int, help='Delete granules older than given months value.') parser.add_argument('granules', help='Path to ingestion file.') args = parser.parse_args() sentinel = SentinelSat() # Before we proceed, check if we retrieved any files during previous processing step if not os.path.exists( os.path.join(args.granules, sentinel.processed_granules)): logger.info( 'Missing file from previous download job.\nPlease run this job first!' ) sys.exit(1) num_lines = sum(1 for l in open( os.path.join(args.granules, sentinel.processed_granules))) if num_lines == 0: logger.info('Skipping processing step. No files to process found!') sys.exit(0) catalog = Catalog(service_url=args.catalog[0], username=args.catalog[1], password=args.catalog[2]) store = catalog.get_store(args.store[0].split(':')[1], args.store[0].split(':')[0]) coverages = catalog.mosaic_coverages(store) # Harvest granules if args.insert: sentinel.insert_granules(args.granules, catalog, coverages, store) # Delete granules if args.delete: sentinel.delete_granules(catalog, coverages, store, args.delete)
def __init__(self, url=None, user=None, pw=None): """ :param url: example: http://localhost:8080/geoserver/rest/ :param user: :param pw: """ self.cat = Catalog(url, username=user, password=pw)
def create_geogig_datastore(store_name): """ Args: store_name: name of geogig repo Returns: None """ ogc_server = get_ogc_server() url = "{}/rest".format(ogc_server.get('LOCATION').rstrip('/')) workspace_name = "geonode" workspace_uri = "http://www.geonode.org/" cat = Catalog(url) # Check if local workspace exists and if not create it workspace = cat.get_workspace(workspace_name) if workspace is None: cat.create_workspace(workspace_name, workspace_uri) print "Workspace " + workspace_name + " created." # Get list of datastores datastores = cat.get_stores() datastore = None # Check if remote datastore exists on local system for ds in datastores: if ds.name.lower() == store_name.lower(): datastore = ds if not datastore: datastore = cat.create_datastore(store_name, workspace_name) datastore.connection_parameters.update(geogig_repository=os.path.join( ogc_server.get('GEOGIG_DATASTORE_DIR'), store_name)) cat.save(datastore)
def addCatalog(self, explorer): dlg = DefineCatalogDialog(explorer) dlg.exec_() if dlg.ok: try: cat = Catalog(dlg.url, dlg.username, dlg.password) v = cat.gsversion() supported = v.startswith("2.3") or v.startswith("2.4") if not supported: ret = QtGui.QMessageBox.warning( explorer, "GeoServer catalog definition", "The specified catalog seems to be running an older version of GeoServer\n" "That might cause unexpected behaviour.\nDo you want to add the catalog anyway?", QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No) if ret == QtGui.QMessageBox.No: return self.catalogs[dlg.name] = cat self.catalog = cat self.comboBox.addItem(dlg.name, cat) self.layersAction.setEnabled(True) self.workspacesAction.setEnabled(True) self.stylesAction.setEnabled(True) self.groupsAction.setEnabled(True) self.gwcAction.setEnabled(True) self.wpsAction.setEnabled(True) self.refreshButton.setEnabled(True) self.updateActionButtons() self.fillTree() self.layersAction.trigger() self.explorer.updateQgisContent() except Exception, e: explorer.setError(str(e)) return
def __init__( self, geoserver_name, username=username, password=password, easy=False ): if geoserver_name in list(REST.keys()): self.path = REST[geoserver_name] else: self.path = geoserver_name self.wms = self.path.replace("rest/", "wms") self.name = geoserver_name self.catalog = Catalog(self.path, username, password) if not easy: self.layers = [] self.layer_names = [] for layer in self.catalog.get_layers(): self.layers.append(layer) self.layer_names.append(layer.name) self.stores = [store for store in self.catalog.get_stores()] self.store_names = [store.name for store in self.stores] styles = [] self.workspaces = [] self.workspace_names = [] for workspace in self.catalog.get_workspaces(): styles = styles + self.catalog.get_styles(workspace) self.workspace_names.append(workspace._name) self.workspaces.append(workspace) self.styles = styles + [style for style in self.catalog.get_styles()] self.style_names = [style.name for style in self.styles]
def addLayersToGeoserver(self, options): cat = Catalog(self.geoserver_rest_url, options['geoserveradmin'], options['gpw']) try: ds = cat.get_store(options['alias']) except Exception as e: raise Exception('Erreur de récupération du workspace') layers = [] try: #connect to tables and create layers and correct urban styles for table in self.urb: try: style = self.urb[table] ft = cat.publish_featuretype(table, ds, 'EPSG:31370', srs='EPSG:31370') gs_style = cat.get_style(style) cat.save(ft) res_name = ft.dirty['name'] res_title = options['alias']+"_"+table cat.save(ft) layer_name = ds.workspace.name + ':' + res_name new_layer = cat.get_layer(layer_name) new_layer.default_style = gs_style cat.save(new_layer) layers.append({ 'res_name' : res_name, 'res_title' : res_title }) except Exception as e: # a verifier une fois un possesion des styles print(str(e)) except Exception as e: print(str(e)) raise Exception('Erreur lors de la récupération des couches depuis Geoserver') return layers
def setUpClass(cls): cls.explorer = OpenGeoExplorer(singletab = True) cls.cat = Catalog("http://boundless-test:8080/geoserver/rest", "admin", "geoserver") cls.catalogs = {"catalog": cls.cat} cleanCatalog(cls.cat) cls.cat.create_workspace(WORKSPACE, "http://test1.com") cls.cat.create_workspace(WORKSPACEB, "http://test2.com")
def setUp(self): # super(UploaderBase, self).setUp() # await startup cl = Client(GEONODE_URL, GEONODE_USER, GEONODE_PASSWD) for i in range(10): time.sleep(.2) try: cl.get_html('/', debug=False) break except BaseException: pass self.client = Client(GEONODE_URL, GEONODE_USER, GEONODE_PASSWD) self.catalog = Catalog(GEOSERVER_URL + 'rest', GEOSERVER_USER, GEOSERVER_PASSWD) self._tempfiles = [] # createlayer must use postgis as a datastore # set temporary settings to use a postgis datastore DB_HOST = settings.DATABASES['default']['HOST'] DB_PORT = settings.DATABASES['default']['PORT'] DB_NAME = settings.DATABASES['default']['NAME'] DB_USER = settings.DATABASES['default']['USER'] DB_PASSWORD = settings.DATABASES['default']['PASSWORD'] settings.DATASTORE_URL = 'postgis://{}:{}@{}:{}/{}'.format( DB_USER, DB_PASSWORD, DB_HOST, DB_PORT, DB_NAME) postgis_db = dj_database_url.parse(settings.DATASTORE_URL, conn_max_age=600) settings.DATABASES['datastore'] = postgis_db settings.OGC_SERVER['default']['DATASTORE'] = 'datastore'
def cleanupProjects(ignore): """[Deleting workspaces at geoserver, which haven't a frontend Directory with the same name] Returns: [array] -- [List of projects that do exist] """ error, geoserver_url = checkConnection(cfg['geoserver']['url'] + "/rest/", cfg['geoserver']['user'], cfg['geoserver']['password']) projects = [] if error: logging.warning( "Could not establish connection to Geoserver, projectHandling may not working" ) return projects cat = Catalog(geoserver_url, "admin", "geoserver") workspaces = [o.name for o in cat.get_workspaces()] dirs = getFrontendDirs() for d in dirs: if d not in workspaces and d not in ignore: shutil.rmtree(cfg['frontend']['path'] + '/projects/' + d) logging.info("Deleted Frontend Folder for Project " + d) else: projects.append(d) return projects
def setUp(self): # await startup self.wait_for_progress_cnt = 0 cl = Client( GEONODE_URL, GEONODE_USER, GEONODE_PASSWD ) for i in range(10): time.sleep(.2) try: cl.get_html('/', debug=False) break except Exception: pass self.client = Client( GEONODE_URL, GEONODE_USER, GEONODE_PASSWD ) self.catalog = Catalog( GEOSERVER_URL + 'rest', GEOSERVER_USER, GEOSERVER_PASSWD, retries=ogc_server_settings.MAX_RETRIES, backoff_factor=ogc_server_settings.BACKOFF_FACTOR ) settings.DATABASES['default']['NAME'] = DB_NAME connections['default'].settings_dict['ATOMIC_REQUESTS'] = False connections['default'].connect() self._tempfiles = []
def main(): catalog = Catalog("http://localhost:8082/geoserver/rest", "admin", "geoserver") layer_style = LayerStyle(catalog, 'cite', 'netcdf_wind') sld_name = os.path.join(SLD_SRC, 'nmefc_wind_vect.sld') layer_style.create_style('nmefc_wind_vect', sld_name) pass
def updateStyle(): url = getTrackingInfo(layer) catalog = Catalog(url) wrapper = CatalogWrapper(catalog) wrapper.publishStyle(layer) iface.messageBar().popWidget() _resetCurrentMessageBarLayer()
def __init__(self, geoserverUrl="", geoserverUserName="", geoserverPW="", geoserverWorkSpace="", postgreIP="", postgreUserName="", postgrePW=""): """use the constructor given arguments if used""" self.geoserverUrl = geoserverUrl if geoserverUrl != "" else GEOSERVERURL self.geoserverUserName = geoserverUserName if geoserverUserName != "" else GEOSERVERUSERNAME self.geoserverPW = geoserverPW if geoserverPW != "" else GEOSERVERPW self.geoserverWorkSpace = geoserverWorkSpace if geoserverWorkSpace != "" else "crc" self.postgreIP = postgreIP if postgreIP != "" else POSTGREIP self.postgreUserName = postgreUserName if postgreUserName != "" else POSTGREUSERNAME self.postgrePW = postgrePW if postgrePW != "" else POSTGREPW if self.geoserverUrl[-1] != '/': raise Exception("GeoserverUrl must end with a slash ('/')") self.catalog = Catalog(self.geoserverUrl + "rest/") self.catalog.http.add_credentials(self.geoserverUserName, self.geoserverPW) try: workspaces = self.catalog.get_workspaces() except: e = sys.exc_info()[0] print e self.cWorkSpace = self.catalog.get_workspace(self.geoserverWorkSpace)
def __init__(self, workspace=None, catalog=None): if not catalog: from geoserver.catalog import Catalog catalog = Catalog() self.catalog = catalog self._nsinfo = None if isinstance(workspace, WorkspaceInfo): self._info = workspace elif isinstance(workspace, (str, unicode)): ws = catalog._catalog.getWorkspaceByName(workspace) if not ws: ws = catalog._catalog.getFactory().createWorkspace() ws.setName(workspace) ns = catalog._catalog.getFactory().createNamespace() ns.setPrefix(workspace) ns.setURI(workspace) self._nsinfo = ns self._info = ws else: if not workspace: self._info = catalog._catalog.getDefaultWorkspace() else: self._info = workspace if not self._nsinfo: self._nsinfo = catalog._catalog.getNamespaceByPrefix( self._info.name)
def wrapper(self, *args, **kwargs): workspace_name = 'geonode' django_datastore = db.connections['datastore'] catalog = Catalog(ogc_server_settings.internal_rest, *ogc_server_settings.credentials) # Set up workspace/datastore as appropriate ws = catalog.get_workspace(workspace_name) delete_ws = False if ws is None: ws = catalog.create_workspace(workspace_name, 'http://www.geonode.org/') delete_ws = True datastore = create_datastore(workspace_name, django_datastore, catalog) # test method called here try: ret = wrapped_func(self, *args, **kwargs) finally: # Tear down workspace/datastore as appropriate if delete_ws: catalog.delete(ws, recurse=True) else: catalog.delete(datastore, recurse=True) return ret
def config_styles(self, sld_path='files/slds/glri/*.sld'): """ Create SLDs within GeoServer. :param str sld_path: path to sld files relative to the project directory :return: list of strings reporting post/overwrite statuses :rtype: list """ catalog = Catalog(self.host, self.user, self.password, True) sld_path = os.path.join(self.abs_path, sld_path) norm_sld_path = os.path.normpath(sld_path) sld_files = glob.glob(norm_sld_path) configured_styles = [] for sld_file in sld_files: with open(sld_file, 'r') as sld: sld_filename = os.path.basename(sld_file) sld_name = os.path.splitext(sld_filename)[0] sld_content = sld.read() if catalog.get_style(sld_name) is None: catalog.create_style(sld_name, sld_content) created_sld_str = 'Created {0}\n'.format(sld_name) print(created_sld_str) configured_styles.append(created_sld_str) else: catalog.create_style(sld_name, sld_content, overwrite=True) overwrite_sld_str = 'Overwrote {0}\n'.format(sld_name) print(overwrite_sld_str) configured_styles.append(overwrite_sld_str) return configured_styles
def _unpublish_from_geoserver(resource, geoserver_context, logger): '''Contact Geoserver and unpublish a layer previously created as an ingested resource. ''' from geoserver.catalog import Catalog, FailedRequestError layer_name = None if resource['format'] == WMSResource.FORMAT: layer_name = resource['wms_layer'] else: layer_name = resource['wfs_layer'] try: api_url = geoserver_context['api_url'] cat = Catalog(api_url + '/rest', username=geoserver_context['username'], password=geoserver_context['password']) layer = cat.get_layer(resource['parent_resource_id'].lower()) cat.delete(layer) cat.reload() logger.info('Unpublished layer %s from Geoserver' % (layer_name)) except AttributeError as ex: logger.error('Failed to unpublish layer %s: %s' % (layer_name, ex)) except FailedRequestError as ex: logger.error('Failed to unpublish layer %s: %s' % (layer_name, ex))
def layer_group(self): """ Returns layer group name from local OWS for this map instance. """ cat = Catalog(ogc_server_settings.rest, _user, _password) lg_name = '%s_%d' % (slugify(self.title), self.id) return cat.get_layergroup(lg_name)
def _unpublish_from_geoserver(resource_id, geoserver_context): geoserver_url = geoserver_context['url'] cat = Catalog(geoserver_url.rstrip('/') + '/rest', username=geoserver_context['username'], password=geoserver_context['password']) layer = cat.get_layer(resource_id.lower()) cat.delete(layer) cat.reload()
def _get_layer_style(self,resource_id): geoserver_url=config['ckanext-vectorstorer.geoserver_url'] cat = Catalog(geoserver_url+"/rest") layer = cat.get_layer(c.layer_id) default_style=layer._get_default_style() xml = minidom.parseString(default_style.sld_body) return xml.toprettyxml()
def __init__(self, geoserver_rest_url, gs_user, gs_password, imagemosaic_storename, mosaic_path, index, *args, **kwargs): self.catalog = Catalog(geoserver_rest_url, gs_user, gs_password) self.store_name = imagemosaic_storename self.mosaic_path = mosaic_path self.index = index log.info('--------------------GDAL_PLUGIN Add granule------------') super(GSAddMosaicGranule, self).__init__(*args, **kwargs)
def get_geoserver_layers(geoserver_url, geoserver_username, geoserver_password): """ returns an iterable of GeoServer layers """ geoserver_rest_url = geoserver_url + 'rest' eprint("retrieving GeoServer layer info via {}".format(geoserver_rest_url)) cat = Catalog(geoserver_rest_url, username=geoserver_username, password=geoserver_password) all_layers = cat.get_layers() return all_layers
def get_philgrid(context): cat = Catalog(settings.OGC_SERVER['default']['LOCATION'] + 'rest', username=settings.OGC_SERVER['default']['USER'], password=settings.OGC_SERVER['default']['PASSWORD']) philgrid = Layer.objects.get(name__icontains="philgrid") # resource = philgrid.resource gs_layer = cat.get_layer(philgrid.name) resource = gs_layer.resource return resource
def setUp(self): self.admin_user = self.create_user('admin', 'admin', is_superuser=True) self.non_admin_user = self.create_user('non_admin', 'non_admin') self.catalog = Catalog(ogc_server_settings.internal_rest, *ogc_server_settings.credentials) if self.catalog.get_workspace('geonode') is None: self.catalog.create_workspace('geonode', 'http://www.geonode.org/') self.workspace = 'geonode' self.datastoreNames = []