def get_db_statistics_payload(self, ifo, req_method, full_uri): # Instantiate objects. dao = DAO.DAOHandle() # Define expected payload. d = { "results": { "earliest_known_segment_start_time": dao.get_segment_boundaries('known', False, ifo, req_method, full_uri), "latest_known_segment_stop_time": dao.get_segment_boundaries('known', True, ifo, req_method, full_uri), "total_known_segments": dao.get_segment_totals('known', ifo, req_method, full_uri), "earliest_active_segment_start_time": dao.get_segment_boundaries('active', False, ifo, req_method, full_uri), "latest_active_segment_stop_time": dao.get_segment_boundaries('active', True, ifo, req_method, full_uri), "total_active_segments": dao.get_segment_totals('active', ifo, req_method, full_uri), "total_flags": dao.get_flag_totals(ifo, req_method, full_uri), "total_versions": dao.get_flag_version_totals(ifo, req_method, full_uri), "last_segment_insert_time": dao.get_last_segment_insert_time(ifo, req_method, full_uri) } } # Return. return d
def get_available_resources(self, req_method, full_uri): # Instantiate. dao = DAO.DAOHandle(); # Set resource array. d = {"results" : ['/report/flags', '/report/coverage', '/report/known', '/report/active', '/report/all', '/report/db', '/report/process']} # Get IFO array. ifos = dao.get_value_list(1, req_method, full_uri) # Loop IFO array. for ifo in ifos['Ifos']: # Append resource to list. d['results'].append('/report/db/' + ifo) # Return. return d
def check_simple_connection(self, run_id): # Init. l = 'Failure' n = 'simple connection check' m = '' r = 1 # Log event. log.info('Starting ' + n) # Instantiate. constant = Constants.ConstantsHandle() dao = DAO.DAOHandle() util = Utils.UtilHandle() # Set call URI. uri = constant.dqsegdb_host + '/dq' # Attempt to open url and convert JSON payload to dictionary.. try: reply = util.convert_uri_json_response_to_dict(n, uri) except: # Log event. m = 'Unable to convert payload returned by ' + n + ': ' + uri + ' to dictionary' log.error(m) else: # If payload reply is not good. if not reply['r'] == True: # Log event. m = 'Problem in payload conversion ' + n + ': ' + uri + ' to dictionary' log.error(m) else: m = reply['m'] d = reply['d'] # If the Ifos key is not available in the dictionary. if not 'Ifos' in d: # Log event. m = 'Ifos key not available in payload returned by ' + n + ': ' + uri + ' to dictionary' log.error(m) # Otherwise, if key exists. else: # Log event. m = n + ' completed successfully. Resource returned ' + str( d['Ifos']) log.info(m) # Set. l = 'Success' r = 0 # Write result to database. dao.insert_test_result(run_id, n, l, m) # Return. return r
def run_test_suite(self): # Init. failures = 0 # Instantiate. constant = Constants.ConstantsHandle() dao = DAO.DAOHandle() # If connection established. if dao.connect_to_db(): # Set time. t_start = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) # Insert test run to database. run_id = dao.insert_test_run(constant.dqsegdb_host, t_start) # If no run ID returned. if run_id == 0: # Log event. log.error('Unable to write test run to DB.') else: # Check simple connection. failures += self.check_simple_connection(run_id) # Check flag versions. failures += self.check_flag_versions(run_id) # Check active flag-version coverage. failures += self.check_flag_version_coverage(run_id, 'active') # Check known flag-version coverage. failures += self.check_flag_version_coverage(run_id, 'known') # Check flag version active segment boundaries. failures += self.check_flag_version_boundaries( run_id, 'active') # Check flag version known segment boundaries. failures += self.check_flag_version_boundaries(run_id, 'known') # Set time. t_stop = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) # Close test run in database. dao.close_test_run(run_id, t_stop, failures) # Close database connection. dao.close_db_connection() # Otherwise, problem with database connection. stop everything. else: # Log event. log.critical('No database connection available.')
def get_user_id(self, u, req_method, full_uri): # Instantiate objects. dao = DAO.DAOHandle() # Init. i = 0 # Attempt to get ID. try: i = dao.get_value_details(2, u, req_method, full_uri) except: pass # If ID has not been found. if i == None or i == 0: # Attempt username insert. try: dao.insert_user(u, req_method, full_uri) except: pass else: # Retrieve ID. i = dao.get_value_details(2, u, req_method, full_uri) # Return. return i
def serve_put_or_patch_uri(self, req_method, full_uri, script_url, qs, j): # Init. r = {} e = [] request_array = [] # Instantiate objects. admin = Admin.AdminHandle() dao = DAO.DAOHandle() # If trailing slash found. if admin.check_for_last_str_char(full_uri, '/'): # Set HTTP code and log. e = admin.log_and_set_http_code(400, 16, req_method, None, full_uri) # Otherwise, trailing slash not found at end of URI. else: # Load JSON to array. try: a = json.loads(j) except: # Set HTTP code and log. e = admin.log_and_set_http_code(400, 1, req_method, None, full_uri) else: # Check the payload. payload_check = admin.check_json_payload(a, req_method) # If problem found. if payload_check: # Set HTTP code and log. e = admin.log_and_set_http_code(400, 33, req_method, str(payload_check), full_uri) else: # Get server request timestamp. server_start_time = time.time() # Split the script URL to a list. o = script_url.split('/') # Filter out empty values. f = filter(None, o) # Get list size. l = len(f) # Start serving requests. if l > 2: ifo = f[1] ifo_id = dao.get_value_details(1, ifo, req_method, full_uri) # If IFO does not exist. if ifo_id == None: # Set HTTP code and log. e = admin.log_and_set_http_code( 404, 5, req_method, None, full_uri) else: flag = f[2] # Add query info to passed JSON. a.update( admin.add_query_info_to_flag_resource( full_uri, a, 0, 0, request_array, server_start_time)) # Put new flag. if l == 3: # If PUT. if req_method == 'PUT': e = dao.insert_flag( req_method, full_uri, ifo_id, ifo, flag, a) else: # Set HTTP code and log. e = admin.log_and_set_http_code( 400, 31, req_method, None, full_uri) # Otherwise, prepare more complex requests. if l > 3: # Set version. version = f[3] # Get flag ID. flag_id = dao.get_flag_id( ifo_id, flag, req_method, full_uri) # If flag ID does not exist. if flag_id == None: # Set HTTP code and log. e = admin.log_and_set_http_code( 404, 8, req_method, None, full_uri) else: # Insert version. if l == 4: # If PUT. if req_method == 'PUT': # Insert new version. e = dao.insert_flag_version( req_method, full_uri, ifo_id, ifo, flag_id, flag, version, a) # Get version ID. version_id = dao.get_flag_version_id( flag_id, version, req_method, full_uri) # If version does not exist. if version_id == None: # Set HTTP code and log. e = admin.log_and_set_http_code( 404, 10, req_method, None, full_uri) else: # If putting and this version already has Known segments associated to it. if req_method == 'PUT' and dao.get_flag_version_segment_total( 'known', version_id, req_method, full_uri) > 0: # Set HTTP code and log. e = admin.log_and_set_http_code( 400, 18, req_method, None, full_uri) else: # Put new 'known' segments. known_insert = dao.insert_segments( 'known', req_method, full_uri, ifo_id, ifo, flag_id, flag, version_id, version, a) # Set error info. e = known_insert['error_info'] # If no error code returned following known insert. if not e: # Put new 'active' segments. active_insert = dao.insert_segments( 'active', req_method, full_uri, ifo_id, ifo, flag_id, flag, version_id, version, a) # Set error info. e = active_insert[ 'error_info'] # If no error code returned following known insert and insert set to true. if not e and known_insert[ 'inserted']: # Update version segment global values. dao.update_segment_global_values( version_id, known_insert[ 'seg_tot'], known_insert[ 'seg_first_gps'], known_insert[ 'seg_last_gps'], active_insert[ 'seg_tot'], active_insert[ 'seg_first_gps'], active_insert[ 'seg_last_gps'], req_method, full_uri) # Insert process. dao.insert_process( a, version_id, known_insert[ 'uid'], known_insert[ 'seg_tot'], known_insert[ 'seg_first_gps'], known_insert[ 'seg_last_gps'], active_insert[ 'seg_tot'], active_insert[ 'seg_first_gps'], active_insert[ 'seg_last_gps'], req_method, full_uri) # Commit the transaction to the DB. dao.commit_transaction_to_db( ) else: admin.log_and_set_http_code( 500, 43, req_method, None, full_uri) # Otherwise, URI too long. elif l > 4: # Set HTTP code and log. e = admin.log_and_set_http_code( 414, 19, req_method, None, full_uri) # If errors have been found. if e: # Set the reply as an error. r = e # Otherwise, set as completed. else: # Set HTTP code and log. r = admin.log_and_set_http_code(200, 4, req_method, None, full_uri) # Return content. return r
def serve_get_uri(self, req_method, full_uri, script_url, qs): # Init. r = {} e = [] t1 = None t2 = None request_array = [] meta = [] a_segs = [] k_segs = [] i_hist = [] arg = [] # Instantiate objects. admin = Admin.AdminHandle() dao = DAO.DAOHandle() # If trailing slash found. if admin.check_for_last_str_char(full_uri, '/'): # Set HTTP code and log. e = admin.log_and_set_http_code(400, 16, req_method, None, full_uri) # Otherwise, trailing slash not found at end of URI. else: # Get server request timestamp. server_start_time = time.time() # Split the script URL to a list. o = script_url.split('/') # Filter out empty values. f = filter(None, o) # Get list size. l = len(f) # Start serving requests. if f[0] == 'dq': # Get ifo list. if l == 1: r = dao.get_value_list(1, req_method, full_uri) # If list not supplied. if not r: # Set HTTP code and log. e = admin.log_and_set_http_code( 200, 21, req_method, None, full_uri) # Otherwise, prepare more complex requests. elif l > 1: ifo = f[1] ifo_id = dao.get_value_details(1, ifo, req_method, full_uri) # Check IFO exists in database. if ifo_id == None: # Set HTTP code and log. e = admin.log_and_set_http_code( 404, 5, req_method, None, full_uri) else: # Get flag list. if l == 2: r = dao.get_flag_list(ifo, req_method, full_uri) # If list not supplied. if not r: # Set HTTP code and log. admin.log_and_set_http_code( 200, 22, req_method, None, full_uri) # Otherwise, prepare more complex requests. elif l > 2: flag = f[2] flag_id = dao.get_flag_id(ifo_id, flag, req_method, full_uri) # If flag does not exist in database. if flag_id == None: # Set HTTP code and log. e = admin.log_and_set_http_code( 404, 8, req_method, None, full_uri) else: # If three URI array elements supplied. if l == 3: # Get version list. v_l = dao.get_flag_version_list( ifo, flag, req_method, full_uri) # If list not supplied. if not v_l: # Set HTTP code and log. e = admin.log_and_set_http_code( 409, 38, req_method, None, full_uri) # Otherwise. else: # Put list into response dictionary. r = admin.put_version_list_into_dict( v_l) # Otherwise, get version and segment info. Ensuring URI is not ended with a trailing slash. elif l == 4: version = f[3] # If query string being passed. if qs: arg = parse_qs( urlparse(full_uri).query) # print 'Args as tuples: [%s]' % ', '.join(map(str, arg)) # If include exists. try: arg['include'] except: pass else: request_array = arg['include'][ 0].split(',') # Get t1 and t2. try: arg['s'][0] except: pass else: t1 = arg['s'][0] try: arg['e'][0] except: pass else: t2 = arg['e'][0] # Get version ID. version_id = dao.get_flag_version_id( flag_id, version, req_method, full_uri) # If version ID found. if version_id == None: # Set HTTP code and log. e = admin.log_and_set_http_code( 404, 10, req_method, None, full_uri) else: # If metadata or everything included. if 'metadata' in request_array or not request_array: # Get metadata. meta = dao.get_flag_version_metadata( 'metadata', ifo, flag, version, version_id, req_method, full_uri) # If metadata not built. if not meta: # Set HTTP code and log. e = admin.log_and_set_http_code( 404, 24, req_method, None, full_uri) # If 'active' segments or everything included. if 'active' in request_array or not request_array: # Get segments. a_segs = dao.get_flag_version_segments( 'active', version_id, t1, t2, req_method, full_uri) # If 'known' segments or everything included. if 'known' in request_array or not request_array: # Get segments. k_segs = dao.get_flag_version_segments( 'known', version_id, t1, t2, req_method, full_uri) # If insert history or everything included. if 'insert_history' in request_array or not request_array: # Get insert history. i_hist = dao.get_flag_version_insert_history( version_id, req_method, full_uri) # If insert history not built. if not i_hist: # Set HTTP code and log. e = admin.log_and_set_http_code( 404, 25, req_method, None, full_uri) # Set segments as result so far, with any insert history that has been set. r.update(meta) r.update(k_segs) r.update(a_segs) r.update(i_hist) # Otherwise, request is too long. elif l > 4: # Set HTTP code and log. e = admin.log_and_set_http_code( 414, 19, req_method, None, full_uri) # Reports. elif f[0] == 'report': # Get report options. if l == 1: r = admin.get_available_resources(req_method, full_uri) # If dictionary not supplied. if not r: # Set HTTP code and log. e = admin.log_and_set_http_code( 404, 26, req_method, None, full_uri) # Otherwise, prepare more complex requests. Ensuring URI is not ended with a trailing slash. elif l > 1: request = f[1] if l == 2: # If request is flags. if request == 'flags': # Get list of all flags. r = dao.get_flags_with_versions_for_report( req_method, full_uri) # If dictionary not supplied. if not r: # Set HTTP code and log. admin.log_and_set_http_code( 200, 27, req_method, None, full_uri) # If request is coverage. elif request == 'coverage': # Get list of all flags. r = dao.get_flag_version_coverage( req_method, full_uri) # If dictionary not supplied. if not r: # Set HTTP code and log. admin.log_and_set_http_code( 200, 42, req_method, None, full_uri) # If request is db. elif request == 'db': # Get DB-related statistics. r = admin.get_db_statistics_payload( None, req_method, full_uri) # If dictionary not supplied. if not r: # Set HTTP code and log. admin.log_and_set_http_code( 200, 39, req_method, None, full_uri) # If request within acceptable range, i.e. 'active', 'known', etc., get list of all flags over period requested by args. elif admin.check_request( 'seg', request) == False and not request == 'all': # Set HTTP code and log. e = admin.log_and_set_http_code( 404, 11, req_method, None, full_uri) # Otherwise, it must be 'known' or 'active'. else: # If query string being passed. if qs: arg = parse_qs(urlparse(full_uri).query) # If include exists. try: arg['include'] except: pass else: request_array = arg['include'][0].split( ',') # Get t1 and t2. try: arg['s'][0] except: pass else: t1 = arg['s'][0] try: arg['e'][0] except: pass else: t2 = arg['e'][0] # Get report segments. r = dao.get_report_segments( request, t1, t2, request_array, req_method, full_uri) # If no segments supplied. if not r: # Set HTTP code and log. admin.log_and_set_http_code( 200, 28, req_method, None, full_uri) # Otherwise, if handling DB-statistics request. elif l == 3: # Report error if not in report. if not request == 'db': # Set HTTP code and log. admin.log_and_set_http_code( 200, 13, req_method, None, full_uri) else: # Get IFO id. ifo = f[2] ifo_id = dao.get_value_details( 1, ifo, req_method, full_uri) # Check IFO exists in database. if ifo_id == None: # Set HTTP code and log. e = admin.log_and_set_http_code( 404, 5, req_method, None, full_uri) else: # Get DB-related statistics for this IFO. r = admin.get_db_statistics_payload( ifo_id, req_method, full_uri) # Otherwise, request is too long. elif l > 3: # Set HTTP code and log. e = admin.log_and_set_http_code( 414, 19, req_method, None, full_uri) # If results have been found and there are no errors. if r and not e: # Add query info to results. r.update( admin.add_query_info_to_flag_resource(full_uri, r, t1, t2, request_array, server_start_time)) # Encode final dictionary to JSON. r = json.dumps(r) # Incorporate into list to pass back to application. r = ['200 OK', r] # Set HTTP code and log. admin.log_and_set_http_code(200, 4, req_method, None, full_uri) # Otherwise, if errors have been found. elif e: # Set the reply as an error. r = e # Otherwise, complete error. else: # Set HTTP code and log. r = admin.log_and_set_http_code(404, 20, req_method, None, full_uri) # Return content. return r
def check_flag_version_boundaries(self, run_id, ak): # Init. l = 'Failure' n = ak + ' flag version boundary check' m = '' r = 1 defaut_earliest_boundary = 999999999999999 # Log event. log.info('Starting ' + n) # Instantiate. constant = Constants.ConstantsHandle() dao = DAO.DAOHandle() util = Utils.UtilHandle() # Set call URI. uri = constant.dqsegdb_host + '/report/coverage' # Attempt to open url and convert JSON payload to dictionary.. try: reply = util.convert_uri_json_response_to_dict(n, uri) except: # Log event. m = 'Unable to convert payload returned by ' + n + ' ' + uri + ' to dictionary' log.error(m) else: # If payload reply is not good. if not reply['r'] == True: # Log event. m = 'Problem in payload conversion ' + n + ' ' + uri + ' to dictionary' log.error(m) else: m = reply['m'] d = reply['d'] # If the Ifos key is not available in the dictionary. if not 'results' in d: # Log event. m = 'results key not available in payload returned by ' + n + ' ' + uri + ' to dictionary' log.error(m) # Otherwise, if key exists. else: # Set error list. l_error = [] # Loop through and get flags, versions and totals. for f_v, totals in d['results'].iteritems(): # Set flag-version URI. f_v_uri = constant.dqsegdb_host + f_v + '?include=' + ak # Check resource returns response. try: reply_b = util.convert_uri_json_response_to_dict( n, f_v_uri) except: # Log event. m = 'Unable to convert payload returned by ' + n + ' ' + f_v_uri + ' to dictionary' log.error(m) else: # If payload reply is not good. if not reply_b['r'] == True: # Append to error list. l_error.append( f_v_uri + ' - problem with returned payload') else: # Set first start/stop boundaries earliest_boundary = defaut_earliest_boundary latest_boundary = 0 # Loop through segments in list. for start, stop in reply_b['d'][ak]: # If start lower than earliest boundary set so far. if start < earliest_boundary: # Reset earliest boundary. earliest_boundary = start # If stop higher than latest boundary set so far. if stop < latest_boundary: # Reset earliest boundary. latest_boundary = stop # If the earliest boundary hasn't changed from when first set. if earliest_boundary == defaut_earliest_boundary: # Set the earliest boundary to zero. earliest_boundary = 0 # If earliest boundary different to coverage totals. if not earliest_boundary == totals[ 'earliest_' + ak + '_segment']: # Append to error list. l_error.append( f_v_uri + ' - ' + ak + ' boundaries are incongruent - DB: ' + str(totals['earliest_' + ak + '_segment']) + '; JSON: ' + str(earliest_boundary)) print f_v + ' - ' + ak + '; DB: ' + str( totals['earliest_' + ak + '_segment'] ) + '; JSON: ' + str(earliest_boundary) # If reply error messages have been set. if l_error: m = n + ' produced failures. Incorrect responses for following URI: ' + str( l_error) log.error(m) # Otherwise, error messages returned. else: # Log event. m = n + ' completed successfully.' log.info(m) # Set. l = 'Success' r = 0 # Write result to database. dao.insert_test_result(run_id, n, l, m) # Return. return r
def check_flag_version_coverage(self, run_id, ak): # Init. l = 'Failure' n = ak + ' flag version coverage check' m = '' r = 1 # Log event. log.info('Starting ' + n) # Instantiate. constant = Constants.ConstantsHandle() dao = DAO.DAOHandle() util = Utils.UtilHandle() # Set call URI. uri = constant.dqsegdb_host + '/report/coverage' # Attempt to open url and convert JSON payload to dictionary.. try: reply = util.convert_uri_json_response_to_dict(n, uri) except: # Log event. m = 'Unable to convert payload returned by ' + n + ' ' + uri + ' to dictionary' log.error(m) else: # If payload reply is not good. if not reply['r'] == True: # Log event. m = 'Problem in payload conversion ' + n + ' ' + uri + ' to dictionary' log.error(m) else: m = reply['m'] d = reply['d'] # If the Ifos key is not available in the dictionary. if not 'results' in d: # Log event. m = 'results key not available in payload returned by ' + n + ' ' + uri + ' to dictionary' log.error(m) # Otherwise, if key exists. else: # Set error list. l_error = [] # Loop through and get flags, versions and totals. for f_v, totals in d['results'].iteritems(): # Set flag-version URI. f_v_uri = constant.dqsegdb_host + f_v + '?include=' + ak # Check resource returns response. try: reply_b = util.convert_uri_json_response_to_dict( n, f_v_uri) except: # Log event. m = 'Unable to convert payload returned by ' + n + ' ' + f_v_uri + ' to dictionary' log.error(m) else: # If payload reply is not good. if not reply_b['r'] == True: # Append to error list. l_error.append( f_v_uri + ' - problem with returned payload') else: # Count active/known segments in payload. tot = len(reply_b['d'][ak]) # If counted active/known total different to coverage totals. if not tot == totals['total_' + ak + '_segments']: # Append to error list. l_error.append( f_v_uri + ' - ' + ak + ' totals are incongruent - DB: ' + str(totals['total_' + ak + '_segments']) + '; JSON: ' + str(tot)) print f_v + ' - ' + ak + '; DB: ' + str(totals[ 'total_' + ak + '_segments']) + '; JSON: ' + str(tot) # If reply error messages have been set. if l_error: m = n + ' produced failures. Incorrect responses for following URI: ' + str( l_error) log.error(m) # Otherwise, error messages returned. else: # Log event. m = n + ' completed successfully.' log.info(m) # Set. l = 'Success' r = 0 # Write result to database. dao.insert_test_result(run_id, n, l, m) # Return. return r
def check_flag_versions(self, run_id): # Init. l = 'Failure' n = 'flag version check' m = '' r = 1 # Log event. log.info('Starting ' + n) # Instantiate. constant = Constants.ConstantsHandle() dao = DAO.DAOHandle() util = Utils.UtilHandle() # Set call URI. uri = constant.dqsegdb_host + '/report/flags' # Attempt to open url and convert JSON payload to dictionary.. try: reply = util.convert_uri_json_response_to_dict(n, uri) except: # Log event. m = 'Unable to convert payload returned by ' + n + ': ' + uri + ' to dictionary' log.error(m) else: # If payload reply is not good. if not reply['r'] == True: # Log event. m = 'Problem in payload conversion ' + n + ': ' + uri + ' to dictionary' log.error(m) else: m = reply['m'] d = reply['d'] # If the Ifos key is not available in the dictionary. if not 'results' in d: # Log event. m = 'results key not available in payload returned by ' + n + ': ' + uri + ' to dictionary' log.error(m) # Otherwise, if key exists. else: # Set error list. l_error = [] # Loop through and get flags and versions. for f_v in d['results']: # Set flag-version URI. f_v_uri = constant.dqsegdb_host + f_v + '?include=metadata' # Check resource returns response. try: reply = util.convert_uri_json_response_to_dict( n, f_v_uri) except: # Log event. m = 'Unable to convert payload returned by ' + n + ': ' + f_v_uri + ' to dictionary' log.error(m) else: # If payload reply is not good. if not reply['r'] == True: # Set reply message l_error.append(f_v_uri) # If reply error messages have been set. if l_error: m = n + ' produced failures. Incorrect responses for following URI: ' + str( l_error) log.error(m) # Otherwise, error messages returned. else: # Log event. m = n + ' completed successfully. Resource returned ' + str( d['results']) log.info(m) # Set. l = 'Success' r = 0 # Write result to database. dao.insert_test_result(run_id, n, l, m) # Return. return r
def application(environ, start_response): # Instantiate logger. constant = Constants.ConstantsHandle() logging.basicConfig(filename=constant.log_file_location + time.strftime("%Y-%m-%d", time.localtime()) + '.log', format="%(asctime)s:%(levelname)s:%(message)s", level=logging.DEBUG) # Instantiate objects. admin = Admin.AdminHandle() dao = DAO.DAOHandle() reqhan = Request.RequestHandle() ldbdwauth = LDBDWAuth.GridmapAuthorization() # Set HTTP code and log. res = admin.log_and_set_http_code(400, 0, environ['REQUEST_METHOD'], None, environ['REQUEST_URI']) # Connect to DB. if dao.connect_to_db(environ['REQUEST_METHOD'], environ['REQUEST_URI']): # Respond to a GET request. if environ['REQUEST_METHOD'] == 'GET': # Authenticate. res = ldbdwauth.check_authorization_gridmap( environ, environ['REQUEST_METHOD'], environ['REQUEST_URI'], False) # If authentication successful. if res[0] == 200: # Get content for output. res = reqhan.serve_get_uri(environ['REQUEST_METHOD'], environ['REQUEST_URI'], environ['PATH_INFO'], environ['QUERY_STRING']) # Respond to a PUT request. elif environ['REQUEST_METHOD'] == 'PUT' or environ[ 'REQUEST_METHOD'] == 'PATCH': # Authorise. res = ldbdwauth.check_authorization_gridmap( environ, environ['REQUEST_METHOD'], environ['REQUEST_URI'], True) # If authorisation successful. if res[0] == 200: # Get the size of the requested JSON. try: request_body_size = int(environ.get('CONTENT_LENGTH', 0)) except: request_body_size = 0 # Process PUT or PATCH request. res = reqhan.serve_put_or_patch_uri( environ['REQUEST_METHOD'], environ['REQUEST_URI'], environ['PATH_INFO'], environ['QUERY_STRING'], environ['wsgi.input'].read(request_body_size)) # Check first character to check content is Python dictionary converted to JSON. if not res[1][:1] == '{': # Handle error. content_type = 'text/html' res[1] = admin.get_http_msg_for_display(res[0], res[1]) else: content_type = 'application/json' # Set headers. response_headers = [('Content-type', content_type), ('Content-Length', str(len(res[1])))] # Start response - Status / Headers. start_response(res[0], response_headers) # Return. return [res[1]]