def test_get_valid_user(self):
# Verify it accepts an admin user
adminuser = User.objects.get(is_superuser=True)
valid_user = get_valid_user(adminuser)
msg = ('Passed in a valid admin user "%s" but got "%s" in return'
% (adminuser, valid_user))
assert valid_user.id == adminuser.id, msg
# Verify it returns a valid user after receiving None
valid_user = get_valid_user(None)
msg = ('Expected valid user after passing None, got "%s"' % valid_user)
assert isinstance(valid_user, User), msg
newuser = User.objects.create(username='******')
valid_user = get_valid_user(newuser)
msg = ('Passed in a valid user "%s" but got "%s" in return'
% (newuser, valid_user))
assert valid_user.id == newuser.id, msg
valid_user = get_valid_user('arieluser')
msg = ('Passed in a valid user by username "%s" but got'
' "%s" in return' % ('arieluser', valid_user))
assert valid_user.username == 'arieluser', msg
nn = AnonymousUser()
self.assertRaises(GeoNodeException, get_valid_user, nn)
def test_get_valid_user(self):
# Verify it accepts an admin user
adminuser = User.objects.get(is_superuser=True)
valid_user = get_valid_user(adminuser)
msg = ('Passed in a valid admin user "%s" but got "%s" in return' %
(adminuser, valid_user))
assert valid_user.id == adminuser.id, msg
# Verify it returns a valid user after receiving None
valid_user = get_valid_user(None)
msg = ('Expected valid user after passing None, got "%s"' % valid_user)
assert isinstance(valid_user, User), msg
newuser = User.objects.create(username='******')
valid_user = get_valid_user(newuser)
msg = ('Passed in a valid user "%s" but got "%s" in return' %
(newuser, valid_user))
assert valid_user.id == newuser.id, msg
valid_user = get_valid_user('arieluser')
msg = ('Passed in a valid user by username "%s" but got'
' "%s" in return' % ('arieluser', valid_user))
assert valid_user.username == 'arieluser', msg
nn = AnonymousUser()
self.assertRaises(GeoNodeException, get_valid_user, nn)
def handle(self, **options):
ignore_errors = options.get('ignore_errors')
verbosity = int(options.get('verbosity'))
user = options.get('user')
owner = get_valid_user(user)
start = datetime.datetime.now()
output = Layer.objects.slurp(ignore_errors, verbosity=verbosity, owner=owner)
updated = [dict_['name'] for dict_ in output if dict_['status']=='updated']
created = [dict_['name'] for dict_ in output if dict_['status']=='created']
failed = [dict_['name'] for dict_ in output if dict_['status']=='failed']
finish = datetime.datetime.now()
td = finish - start
duration = td.microseconds / 1000000 + td.seconds + td.days * 24 * 3600
duration_rounded = round(duration, 2)
if verbosity > 1:
print "\nDetailed report of failures:"
for dict_ in output:
if dict_['status'] == 'failed':
print "\n\n", dict_['name'], "\n================"
traceback.print_exception(dict_['exception_type'],
dict_['error'],
dict_['traceback'])
if verbosity > 0:
print "\n\nFinished processing %d layers in %s seconds.\n" % (
len(output), duration_rounded)
print "%d Created layers" % len(created)
print "%d Updated layers" % len(updated)
print "%d Failed layers" % len(failed)
if len(output) > 0:
print "%f seconds per layer" % (duration * 1.0 / len(output))
def handle(self, *lnames, **options):
ignore_errors = options.get('ignore_errors')
verbosity = int(options.get('verbosity'))
user = options.get('user')
owner = get_valid_user(user)
new_only = options.get('new_only')
workspace = options.get('workspace')
if len(lnames) == 0:
lnames = None
start = datetime.datetime.now()
output = Layer.objects.slurp(ignore_errors,
verbosity=verbosity,
owner=owner,
new_only=new_only,
lnames=lnames,
workspace=workspace)
updated = [
dict_['name'] for dict_ in output if dict_['status'] == 'updated'
]
created = [
dict_['name'] for dict_ in output if dict_['status'] == 'created'
]
failed = [
dict_['name'] for dict_ in output if dict_['status'] == 'failed'
]
finish = datetime.datetime.now()
td = finish - start
duration = td.microseconds / 1000000 + td.seconds + td.days * 24 * 3600
duration_rounded = round(duration, 2)
if verbosity > 1:
print "\nDetailed report of failures:"
for dict_ in output:
if dict_['status'] == 'failed':
print "\n\n", dict_['name'], "\n================"
traceback.print_exception(dict_['exception_type'],
dict_['error'],
dict_['traceback'])
if verbosity > 0:
print "\n\nFinished processing %d layers in %s seconds.\n" % (
len(output), duration_rounded)
print "%d Created layers" % len(created)
print "%d Updated layers" % len(updated)
print "%d Failed layers" % len(failed)
if len(output) > 0:
print "%f seconds per layer" % (duration * 1.0 / len(output))
def get_servers(user):
""" Gets the list of servers for a given user
"""
if user.is_anonymous():
theuser = get_valid_user()
else:
theuser = user
try:
workspace = Workspace.objects.get(user=theuser)
except Workspace.DoesNotExist:
workspace = Workspace.objects.get(user__username='******')
servers = workspace.servers.all()
geoservers = [{'url': settings.GEOSERVER_BASE_URL + 'ows',
'name': 'Local Geoserver',
'version': '1.0.0', 'id':0}]
for server in servers:
# TODO for the moment assume version 1.0.0
geoservers.append({'url': server.url,
'name': server.name,
'id': server.id,
'version': '1.0.0'})
return geoservers
def get_servers(user):
""" Gets the list of servers for a given user
"""
if user.is_anonymous():
theuser = get_valid_user()
else:
theuser = user
try:
workspace = Workspace.objects.get(user=theuser)
except Workspace.DoesNotExist:
workspace = Workspace.objects.get(user__username='******')
servers = workspace.servers.all()
geoservers = [{'url': settings.GEOSERVER_BASE_URL + 'ows',
'name': 'Local Geoserver',
'version': '1.0.0', 'id':0}]
for server in servers:
# TODO for the moment assume version 1.0.0
geoservers.append({'url': server.url,
'name': server.name,
'id': server.id,
'version': '1.0.0'})
return geoservers
def calculate(request, save_output=save_to_geonode):
start = datetime.datetime.now()
if request.method == 'GET':
# FIXME: Add a basic form here to be able to generate the POST request.
return HttpResponse('This should be accessed by robots, not humans.'
'In other words using HTTP POST instead of GET.')
elif request.method == 'POST':
data = request.POST
impact_function_name = data['impact_function']
hazard_server = data['hazard_server']
hazard_layer = data['hazard']
exposure_server = data['exposure_server']
exposure_layer = data['exposure']
bbox = data['bbox']
keywords = data['keywords']
if request.user.is_anonymous():
theuser = get_valid_user()
else:
theuser = request.user
# Create entry in database
calculation = Calculation(user=theuser,
run_date=start,
hazard_server=hazard_server,
hazard_layer=hazard_layer,
exposure_server=exposure_server,
exposure_layer=exposure_layer,
impact_function=impact_function_name,
success=False)
try:
# Input checks
msg = 'This cannot happen :-)'
assert isinstance(bbox, basestring), msg
check_bbox_string(bbox)
# Find the intersection of bounding boxes for viewport,
# hazard and exposure.
vpt_bbox = bboxstring2list(bbox)
haz_bbox = get_metadata(hazard_server,
hazard_layer)['bounding_box']
exp_bbox = get_metadata(exposure_server,
exposure_layer)['bounding_box']
# Impose minimum bounding box size (as per issue #101).
# FIXME (Ole): This will need to be revisited in conjunction with
# raster resolutions at some point.
min_res = 0.00833334
eps = 1.0e-1
vpt_bbox = minimal_bounding_box(vpt_bbox, min_res, eps=eps)
haz_bbox = minimal_bounding_box(haz_bbox, min_res, eps=eps)
exp_bbox = minimal_bounding_box(exp_bbox, min_res, eps=eps)
# New bounding box for data common to hazard, exposure and viewport
# Download only data within this intersection
intersection = bbox_intersection(vpt_bbox, haz_bbox, exp_bbox)
if intersection is None:
# Bounding boxes did not overlap
msg = ('Bounding boxes of hazard data, exposure data and '
'viewport did not overlap, so no computation was '
'done. Please try again.')
logger.info(msg)
raise Exception(msg)
bbox = bboxlist2string(intersection)
plugin_list = get_plugins(impact_function_name)
_, impact_function = plugin_list[0].items()[0]
impact_function_source = inspect.getsource(impact_function)
calculation.impact_function_source = impact_function_source
calculation.bbox = bbox
calculation.save()
msg = 'Performing requested calculation'
logger.info(msg)
# Download selected layer objects
msg = ('- Downloading hazard layer %s from %s' % (hazard_layer,
hazard_server))
logger.info(msg)
H = download(hazard_server, hazard_layer, bbox)
msg = ('- Downloading exposure layer %s from %s' % (exposure_layer,
exposure_server))
logger.info(msg)
E = download(exposure_server, exposure_layer, bbox)
# Calculate result using specified impact function
msg = ('- Calculating impact using %s' % impact_function)
logger.info(msg)
impact_filename = calculate_impact(layers=[H, E],
impact_fcn=impact_function)
# Upload result to internal GeoServer
msg = ('- Uploading impact layer %s' % impact_filename)
logger.info(msg)
result = save_output(impact_filename,
title='output_%s' % start.isoformat(),
user=theuser)
except Exception, e:
#FIXME: Reimplement error saving for calculation
logger.error(e)
errors = e.__str__()
trace = exception_format(e)
calculation.errors = errors
calculation.stacktrace = trace
calculation.save()
jsondata = json.dumps({'errors': errors, 'stacktrace': trace})
return HttpResponse(jsondata, mimetype='application/json')
def setUp(self):
"""Create valid superuser
"""
self.user = get_valid_user()
def setUp(self):
"""Check geonode and create valid superuser
"""
check_geonode_is_up()
self.user = get_valid_user()
def setUp(self):
"""Create valid superuser
"""
self.user = get_valid_user()
def calculate(request, save_output=save_to_geonode):
start = datetime.datetime.now()
if request.method == 'GET':
# FIXME: Add a basic form here to be able to generate the POST request.
return HttpResponse('This should be accessed by robots, not humans.'
'In other words using HTTP POST instead of GET.')
elif request.method == 'POST':
data = request.POST
impact_function_name = data['impact_function']
hazard_server = data['hazard_server']
hazard_layer = data['hazard']
exposure_server = data['exposure_server']
exposure_layer = data['exposure']
requested_bbox = data['bbox']
keywords = data['keywords']
if request.user.is_anonymous():
theuser = get_valid_user()
else:
theuser = request.user
# Create entry in database
calculation = Calculation(user=theuser,
run_date=start,
hazard_server=hazard_server,
hazard_layer=hazard_layer,
exposure_server=exposure_server,
exposure_layer=exposure_layer,
impact_function=impact_function_name,
success=False)
# Wrap main computation loop in try except to catch and present
# messages and stack traces in the application
try:
# Get metadata
haz_metadata = get_metadata(hazard_server, hazard_layer)
exp_metadata = get_metadata(exposure_server, exposure_layer)
# Determine common resolution in case of raster layers
raster_resolution = get_common_resolution(haz_metadata, exp_metadata)
# Get reconciled bounding boxes
haz_bbox, exp_bbox, imp_bbox = get_bounding_boxes(haz_metadata,
exp_metadata,
requested_bbox)
# Record layers to download
download_layers = [(hazard_server, hazard_layer, haz_bbox),
(exposure_server, exposure_layer, exp_bbox)]
# Add linked layers if any FIXME: STILL TODO!
# Get selected impact function
impact_function = get_plugin(impact_function_name)
impact_function_source = inspect.getsource(impact_function)
# Record information calculation object and save it
calculation.impact_function_source = impact_function_source
calculation.bbox = bboxlist2string(imp_bbox)
calculation.save()
# Start computation
msg = 'Performing requested calculation'
logger.info(msg)
# Download selected layer objects
layers = []
for server, layer_name, bbox in download_layers:
msg = ('- Downloading layer %s from %s'
% (layer_name, server))
logger.info(msg)
L = download(server, layer_name, bbox, raster_resolution)
layers.append(L)
# Calculate result using specified impact function
msg = ('- Calculating impact using %s' % impact_function)
logger.info(msg)
impact_filename = calculate_impact(layers=layers,
impact_fcn=impact_function)
# Upload result to internal GeoServer
msg = ('- Uploading impact layer %s' % impact_filename)
logger.info(msg)
result = save_output(impact_filename,
title='output_%s' % start.isoformat(),
user=theuser)
except Exception, e:
# FIXME: Reimplement error saving for calculation.
# FIXME (Ole): Why should we reimplement?
# This is dangerous. Try to raise an exception
# e.g. in get_metadata_from_layer. Things will silently fail.
# See issue #170
logger.error(e)
errors = e.__str__()
trace = exception_format(e)
calculation.errors = errors
calculation.stacktrace = trace
calculation.save()
jsondata = json.dumps({'errors': errors, 'stacktrace': trace})
return HttpResponse(jsondata, mimetype='application/json')
def handle(self, url, name, type, method, console=sys.stdout, **options):
user = options.get('user')
owner = get_valid_user(user)
register_layers = options.get('registerlayers')
username = options.get('username')
password = options.get('password')
perm_spec = options.get('permspec')
register_service = True
# First Check if this service already exists based on the URL
base_url = url
try:
service = Service.objects.get(base_url=base_url)
except Service.DoesNotExist:
service = None
if service is not None:
print "This is an existing Service"
register_service = False
# Then Check that the name is Unique
try:
service = Service.objects.get(name=name)
except Service.DoesNotExist:
service = None
if service is not None:
print "This is an existing service using this name.\nPlease specify a different name."
if register_service:
if method == 'C':
response = _register_cascaded_service(type, url, name, username, password, owner=owner, verbosity=True)
elif method == 'I':
response = _register_indexed_service(type, url, name, username, password, owner=owner, verbosity=True)
elif method == 'H':
response = _register_harvested_service(url, name, username, password, owner=owner, verbosity=True)
elif method == 'X':
print 'Not Implemented (Yet)'
elif method == 'L':
print 'Local Services not configurable via API'
else:
print 'Invalid method'
json_response = json.loads(response.content)
if "id" in json_response:
print "Service created with id of %d" % json_response["id"]
service = Service.objects.get(id=json_response["id"])
else:
print "Something went wrong: %s" % response.content
return
print service.id
print register_layers
if service and register_layers:
layers=[]
for layer in service.servicelayer_set.all():
layers.append(layer.typename)
if service.method == 'C':
response = _register_cascaded_layers(user, service, layers, perm_spec)
elif service.method == 'I':
response = _register_indexed_layers(user, service, layers, perm_spec)
elif service.method == 'X':
print 'Not Implemented (Yet)'
elif service.method == 'L':
print 'Local Services not configurable via API'
else:
print('Invalid Service Type')
print response.content
