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 = []
