def get_engine(self):
"""
Retrives GeoServer engine
"""
return GeoServerSpatialDatasetEngine(endpoint=self.endpoint,
username=self.username,
password=self.password)
def region_delete(request):
"""
Controller for deleting a region.
"""
if request.is_ajax() and request.method == 'POST':
# get/check information from AJAX request
post_info = request.POST
region_id = post_info.get('region_id')
# initialize session
Session = Grace.get_persistent_store_database('main_db',
as_sessionmaker=True)
session = Session()
try:
# delete region
try:
region = session.query(Region).get(region_id)
except ObjectDeletedError:
session.close()
return JsonResponse(
{'error': "The geoserver to delete does not exist."})
display_name = region.display_name
region_store = ''.join(display_name.split()).lower()
geoserver_id = region.geoserver_id
geoserver = session.query(Geoserver).get(geoserver_id)
geoserver_url = geoserver.url
uname = geoserver.username
pwd = geoserver.password
spatial_dataset_engine = GeoServerSpatialDatasetEngine(
endpoint=geoserver_url, username=uname, password=pwd)
stores = spatial_dataset_engine.list_stores()
for store in stores['result']:
if store.endswith(region_store):
spatial_dataset_engine.delete_store(store,
purge=True,
recurse=True)
FILE_DIR = os.path.join(GRACE_NETCDF_DIR, '')
region_dir = os.path.join(FILE_DIR + region_store, '')
session.delete(region)
session.commit()
session.close()
except IntegrityError:
session.close()
return JsonResponse({
'error':
"This geoserver is connected with a watershed! Must remove connection to delete."
})
finally:
# Delete the temporary directory once the geojson string is created
if region_dir is not None:
if os.path.exists(region_dir):
shutil.rmtree(region_dir)
return JsonResponse({'success': "Region sucessfully deleted!"})
return JsonResponse({'error': "A problem with your request exists."})
def upload_tiff(dir, region, geoserver_rest_url, workspace, uname, pwd):
headers = {
'Content-type': 'image/tiff',
}
spatial_data_engine = GeoServerSpatialDatasetEngine(
endpoint=geoserver_rest_url, username=uname, password=pwd)
#Check if workspace exists
ws_name = workspace
geoserver_uri = 'www.google.com'
response = spatial_data_engine.list_workspaces()
if response['success']:
workspaces = response['result']
if ws_name not in workspaces:
spatial_data_engine.create_workspace(workspace_id=ws_name,
uri=geoserver_uri)
for file in os.listdir(
dir): #Looping through all the files in the given directory
if file is None:
print "No files. Please check directory and try again."
sys.exit()
data = open(dir + file, 'rb').read() #Read the file
store_name = file.split(
'.')[0] + '_' + region #Creating the store name dynamically
request_url = '{0}workspaces/{1}/coveragestores/{2}/file.geotiff'.format(
geoserver_rest_url, ws_name, store_name) #Creating the rest url
requests.put(request_url,
headers=headers,
data=data,
auth=(uname,
pwd)) #Creating the resource on the geoserver
def setUp(self):
# Globals
self.debug = False
# Files
self.tests_root = os.path.abspath(os.path.dirname(__file__))
self.files_root = os.path.join(self.tests_root, 'files')
self.shapefile_name = 'test'
self.shapefile_base = os.path.join(self.files_root, 'shapefile',
self.shapefile_name)
# Create Test Engine
self.engine = GeoServerSpatialDatasetEngine(
endpoint=TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT'],
username=TEST_GEOSERVER_DATASET_SERVICE['USERNAME'],
password=TEST_GEOSERVER_DATASET_SERVICE['PASSWORD'])
# Create Test Workspaces
# self.test_resource_workspace = random_string_generator(10)
self.test_resource_workspace = random_string_generator(10)
self.engine.create_workspace(workspace_id=self.test_resource_workspace,
uri=random_string_generator(5))
# Create Test Stores/Resources/Layers
## Shapefile
# Store name
self.test_resource_store = random_string_generator(10)
# Resource and Layer will take the name of the file
self.test_resource_name = self.test_resource_store
self.test_layer_name = self.test_resource_store
# Identifiers of the form 'workspace:item'
self.test_store_identifier = '{0}:{1}'.format(
self.test_resource_workspace, self.test_resource_store)
self.test_resource_identifier = '{0}:{1}'.format(
self.test_resource_workspace, self.test_resource_name)
# Do create shapefile
self.engine.create_shapefile_resource(
self.test_store_identifier,
shapefile_base=self.shapefile_base,
overwrite=True)
## Coverage
# Create Test Style
self.test_style_name = 'point'
# Create Test Layer Groups
self.test_layer_group_name = random_string_generator(10)
self.engine.create_layer_group(
layer_group_id=self.test_layer_group_name,
layers=(self.test_layer_name, ),
styles=(self.test_style_name, ))
# Pause
pause(10)
def upload_files_to_geoserver(filepaths, geoserver_uri,
geoserver_rest_endpoint_url, workspace, username,
password):
if type(geoserver_uri) is unicode:
geoserver_uri = str(geoserver_uri)
if type(geoserver_rest_endpoint_url) is unicode:
geoserver_rest_endpoint_url = str(geoserver_rest_endpoint_url)
if type(workspace) is unicode:
workspace = str(workspace)
if type(username) is unicode:
username = str(username)
if type(password) is unicode:
password = str(password)
geoserver_engine = GeoServerSpatialDatasetEngine(
endpoint=geoserver_rest_endpoint_url,
username=username,
password=password)
#create workspace
response = geoserver_engine.list_workspaces()
if response['success']:
workspaces = response['result']
if workspace not in workspaces:
print "I did something"
response = geoserver_engine.create_workspace(workspace_id=workspace,
uri=geoserver_uri)
#upload to geoserver
for filename in filepaths:
store = filename.split("\\")[-1]
store_id = workspace + ':' + store
print 'uploading ' + filename + ' to store ' + store_id + '...'
response = geoserver_engine.create_coverage_resource(
store_id=store_id,
coverage_file=filename,
coverage_type='worldimage',
overwrite=True,
debug=True)
return
def setUp(self):
# Files
self.tests_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
self.files_root = os.path.join(self.tests_root, 'files')
# GeoServer
self.gs_endpoint = TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT']
self.gs_username = TEST_GEOSERVER_DATASET_SERVICE['USERNAME']
self.gs_password = TEST_GEOSERVER_DATASET_SERVICE['PASSWORD']
self.catalog = GeoServerCatalog(self.gs_endpoint, username=self.gs_username, password=self.gs_password)
# Postgis
self.pg_username = TEST_POSTGIS_SERVICE['USERNAME']
self.pg_password = TEST_POSTGIS_SERVICE['PASSWORD']
self.pg_database = TEST_POSTGIS_SERVICE['DATABASE']
self.pg_table_name = 'points'
self.pg_host = TEST_POSTGIS_SERVICE['HOST']
self.pg_port = TEST_POSTGIS_SERVICE['PORT']
self.pg_url = TEST_POSTGIS_SERVICE['URL']
self.pg_public_url = TEST_POSTGIS_SERVICE['PUBLIC_URL']
# Setup a testing workspace
self.workspace_name = random_string_generator(10)
self.workspace_uri = 'http://www.tethysplatform.org/{}'.format(self.workspace_name)
retries = 5
while retries > 0:
try:
self.catalog.create_workspace(self.workspace_name, self.workspace_uri)
break
except AssertionError as e:
if 'Error persisting' in str(e) and retries > 0:
print("WARNING: FAILED TO PERSIST WORKSPACE.")
retries -= 1
else:
raise
# Setup Postgis database connection
self.public_engine = create_engine(self.pg_public_url)
self.connection = self.public_engine.connect()
self.transaction = self.connection.begin()
# Create GeoServer Engine
self.endpoint = TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT']
self.geoserver_engine = GeoServerSpatialDatasetEngine(endpoint=self.endpoint,
username=TEST_GEOSERVER_DATASET_SERVICE['USERNAME'],
password=TEST_GEOSERVER_DATASET_SERVICE['PASSWORD'])
self.geometry_column = 'geometry'
self.geometry_type = 'Point'
self.srid = 4326
def geoserver_update(request):
"""
Controller for updating a geoserver.
"""
if request.is_ajax() and request.method == 'POST':
# get/check information from AJAX request
post_info = request.POST
geoserver_id = post_info.get('geoserver_id')
geoserver_name = post_info.get('geoserver_name')
geoserver_url = post_info.get('geoserver_url')
geoserver_username = post_info.get('geoserver_username')
geoserver_password = post_info.get('geoserver_password')
# check data
if not geoserver_id or not geoserver_name or not geoserver_url or not \
geoserver_username or not geoserver_password:
return JsonResponse({'error': "Missing input data."})
# make sure id is id
try:
int(geoserver_id)
except ValueError:
return JsonResponse({'error': 'Geoserver id is faulty.'})
Session = Grace.get_persistent_store_database('main_db',
as_sessionmaker=True)
session = Session()
geoserver = session.query(Geoserver).get(geoserver_id)
try:
spatial_dataset_engine = GeoServerSpatialDatasetEngine(
endpoint=geoserver_url,
username=geoserver_username,
password=geoserver_password)
layer_list = spatial_dataset_engine.list_layers(debug=True)
if layer_list:
geoserver.geoserver_name = geoserver_name
geoserver.geoserver_url = geoserver_url
geoserver.geoserver_username = geoserver_username
geoserver.geoserver_password = geoserver_password
session.commit()
session.close()
return JsonResponse(
{'success': "Geoserver sucessfully updated!"})
except:
return JsonResponse(
{'error': "A problem with your request exists."})
def get_engine(self):
"""
Retrieves spatial dataset engine
"""
engine = None
if self.engine == self.GEOSERVER:
engine = GeoServerSpatialDatasetEngine(endpoint=self.endpoint,
username=self.username,
password=self.password)
engine.public_endpoint = self.public_endpoint
elif self.engine == self.THREDDS:
if self.username and self.password:
session_manager.set_session_options(auth=(str(self.username),
str(self.password)))
catalog_endpoint = str(self.endpoint).rstrip('/') + '/catalog.xml'
engine = TDSCatalog(str(catalog_endpoint))
return engine
def delete(request):
list = {}
session = SessionMaker()
# Query DB for hydroservers
if request.is_ajax() and request.method == 'POST':
title = request.POST['server']
geo_url = geo_url_base + "/geoserver/rest/"
spatial_dataset_engine = GeoServerSpatialDatasetEngine(
endpoint=geo_url, username=geo_user, password=geo_pw)
store_string = "catalog" + ":" + str(title)
spatial_dataset_engine.delete_layer(layer_id=store_string, purge=True)
spatial_dataset_engine.delete_store(store_id=store_string, purge=True)
hydroservers = session.query(Catalog).filter(
Catalog.title == title).delete(synchronize_session='evaluate')
session.commit()
session.close()
# spatial_dataset_engine.delete_store(title,purge=True,debug=True)
list["title"] = title
return JsonResponse(list)
def addZippedShapefile2Geoserver(geosvr_url_base, uname, upwd, ws_name,
store_name, zippedTif_full_path, res_url):
try:
geosvr_url_full = geosvr_url_base + "/geoserver/rest/"
logger.debug("GeoServer REST Full URL: " + geosvr_url_full)
coverage_file = zippedTif_full_path
logger.debug("Connect to Geoserver")
spatial_dataset_engine = GeoServerSpatialDatasetEngine(
endpoint=geosvr_url_full, username=uname, password=upwd)
logger.debug("Connected")
response = None
result = spatial_dataset_engine.create_workspace(workspace_id=ws_name,
uri=res_url)
if result['success']:
logger.debug("Create workspace " + ws_name + " successfully")
else:
logger.debug("Create workspace " + ws_name + " failed")
logger.debug(result)
store_id = ws_name + ":" + store_name
result = None
result = spatial_dataset_engine.create_shapefile_resource(
store_id=store_id, shapefile_zip=coverage_file)
if result['success']:
logger.debug("Create store " + store_name + " successfully")
else:
logger.debug("Create store " + store_name + " failed")
logger.debug(result)
spatial_dataset_engine.list_layers(debug=True)
return True
except:
logger.exception("addZippedTif2Geoserver() error")
return False
def delete_old_watershed_geoserver_files(watershed):
"""
Removes old watershed geoserver files from system
"""
engine = GeoServerSpatialDatasetEngine(
endpoint="%s/rest" % watershed.geoserver.url,
username=watershed.geoserver.username,
password=watershed.geoserver.password)
if watershed.geoserver_drainage_line_uploaded:
purge_remove_geoserver_layer(watershed.geoserver_drainage_line_layer,
engine)
if watershed.geoserver_catchment_uploaded:
purge_remove_geoserver_layer(watershed.geoserver_catchment_layer,
engine)
if watershed.geoserver_gage_uploaded:
purge_remove_geoserver_layer(watershed.geoserver_gage_layer, engine)
if watershed.geoserver_ahps_station_uploaded:
purge_remove_geoserver_layer(watershed.geoserver_ahps_station_layer,
engine)
def geoserver_add(request):
response = {}
if request.is_ajax() and request.method == 'POST':
info = request.POST
geoserver_name = info.get('geoserver_name')
geoserver_url = info.get('geoserver_url')
geoserver_username = info.get('geoserver_username')
geoserver_password = info.get('geoserver_password')
try:
spatial_dataset_engine = GeoServerSpatialDatasetEngine(
endpoint=geoserver_url,
username=geoserver_username,
password=geoserver_password)
layer_list = spatial_dataset_engine.list_layers(debug=True)
if layer_list:
Session = Grace.get_persistent_store_database(
'main_db', as_sessionmaker=True)
session = Session()
geoserver = Geoserver(name=geoserver_name,
url=geoserver_url,
username=geoserver_username,
password=geoserver_password)
session.add(geoserver)
session.commit()
session.close()
response = {"data": geoserver_name, "success": "Success"}
except:
response = {
"error":
"Error processing the Geoserver URL. Please check the url,username and password."
}
return JsonResponse(response)
#-------------------------------------------------------------------------------
# Name: module1
# Purpose:
#
# Author: mscott90
#
# Created: 21/02/2014
# Copyright: (c) mscott90 2014
# Licence: <your licence>
#-------------------------------------------------------------------------------
import shutil, sys, re, subprocess, time, os
from tethys_dataset_services.engines import GeoServerSpatialDatasetEngine
from zipfile import ZipFile
geoserver_engine = GeoServerSpatialDatasetEngine(endpoint='http://ciwmap.chpc.utah.edu:8080/geoserver/rest', username='******', password='******')
GSSHA_EXE = 'gssha.exe'
def main(prj, job_id):
os.chdir('gssha_provo_flood')
runGSSHA(prj)
reformat(prj, job_id)
zip_floodmap(job_id)
upload_to_geoserver(job_id)
os.chdir('..')
def runGSSHA(prjFile):
#outFile = "run.out"
#out = open(outFile, 'w')
process = subprocess.Popen([GSSHA_EXE, prjFile])
process.wait()
def genShapeFile(input,title,geo_url,username,password,hs_url):
try:
file_name = 'hs_sites'
temp_dir = tempfile.mkdtemp()
file_location = temp_dir+"/"+file_name
w = sf.Writer(sf.POINT)
w.field('sitename')
w.field('sitecode')
w.field('network')
w.field('service')
w.field('url','C',200)
# w.field('elevation')
for item in input:
w.point(float(item['longitude']),float(item['latitude']))
site_name = item['sitename']
site_name.decode("utf-8")
w.record(item['sitename'],item['sitecode'],item['network'],item['service'],hs_url, 'Point')
w.save(file_location)
prj = open("%s.prj" % file_location, "w")
epsg = 'GEOGCS["WGS84",DATUM["WGS_1984",SPHEROID["WGS84",6378137,298.257223563,AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]]'
prj.write(epsg)
prj.close()
file_list = os.listdir(temp_dir)
zip_file_full_path = temp_dir + "/" + "shapefile.zip"
with zipfile.ZipFile(zip_file_full_path, 'a') as myzip:
for fn in file_list:
shapefile_fp = temp_dir + "/"+ fn # tif full path
new_file_name = title + os.path.splitext(fn)[1]
myzip.write(shapefile_fp, arcname=new_file_name)
#Connecting to geoserver
spatial_dataset_engine = GeoServerSpatialDatasetEngine(endpoint=geo_url, username=username, password=password)
layer_metadata = {}
response = None
ws_name = "catalog"
result = spatial_dataset_engine.create_workspace(workspace_id=ws_name, uri="www.servir.org")
if result['success']:
print "Created workspace " + ws_name + " successfully"
else:
print "Creating workspace " + ws_name + " failed"
#print result
store_id = ws_name + ":" + title
result = None
result = spatial_dataset_engine.create_shapefile_resource(store_id=store_id, shapefile_zip=zip_file_full_path)
if result['success']:
print "Created store " + title + " successfully"
else:
print "Creating store " + title + " failed"
#find the bbox area
wms_rest_url = '{}workspaces/{}/datastores/{}/featuretypes/{}.json'.format(geo_url,ws_name,title,title)
print wms_rest_url
r = requests.get(wms_rest_url, auth=(username,password))
if r.status_code != 200:
print 'The Geoserver appears to be down.'
else:
json = r.json()
extents = json['featureType']['latLonBoundingBox']
# wms_response = urllib2.urlopen(wms_rest_url)
# wms_data = wms_response.read()
# print wms_data
layer_metadata["layer"] = store_id
layer_metadata["extents"] = extents
return layer_metadata
except:
return False
finally:
if temp_dir is not None:
if os.path.exists(temp_dir):
shutil.rmtree(temp_dir)
