288 lines
11 KiB
Python
Executable File
288 lines
11 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
# Copyright (c) 2017 OpenStack Foundation
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
"""
|
|
Test result update & verify script for the local refstack database.
|
|
"""
|
|
|
|
import argparse
|
|
import datetime
|
|
import json
|
|
import jwt
|
|
import os
|
|
import requests
|
|
import sys
|
|
|
|
from collections import namedtuple
|
|
|
|
|
|
def generate_token(keyfile, _id):
|
|
# get private key in string format
|
|
with open(keyfile) as pemfile:
|
|
secret = pemfile.read().rstrip()
|
|
exp = datetime.timedelta(seconds=100500)
|
|
payload =\
|
|
{
|
|
"user_openid": _id,
|
|
"exp": datetime.datetime.now() + exp
|
|
}
|
|
token = jwt.encode(payload, secret, algorithm="RS256")
|
|
with open("./token", "w+") as tokenfile:
|
|
tokenfile.write(str(token))
|
|
print("token stored in the current working directory.")
|
|
|
|
|
|
def testAuth(link, tokenfile):
|
|
auth_test_url = link.split("/v1")[0] + "/#/profile"
|
|
with open(tokenfile) as tokenfile:
|
|
token = tokenfile.read().strip()
|
|
headers = {"Authorization": "Bearer " + token}
|
|
response = requests.get(auth_test_url, headers)
|
|
if response.status_code == 200:
|
|
return True, token
|
|
else:
|
|
print("token auth failed. status code = %d" % (response.status_code))
|
|
print("auth failure detail: %s" % (response.text))
|
|
return False, None
|
|
|
|
|
|
def getData(entry):
|
|
guidelines = ["2015.03", "2015.04", "2015.05", "2015.07", "2016.01",
|
|
"2016.08", "2017.01", "2017.09"]
|
|
# NOTE: Storage is an alias of Object
|
|
components = ["platform", "compute", "storage", "object"]
|
|
if len(entry) < 10:
|
|
return None, None, None
|
|
refstackLink = entry[9].strip()
|
|
guideline = entry[4].strip()
|
|
target = entry[5].lower().strip()
|
|
if refstackLink:
|
|
testId = refstackLink.split("/")[-1]
|
|
else:
|
|
refstackLink = None
|
|
testId = None
|
|
if guideline not in guidelines:
|
|
guideline = None
|
|
if target not in components:
|
|
target = None
|
|
elif target == "storage":
|
|
target = "object"
|
|
return testId, guideline, target
|
|
|
|
|
|
def linkChk(link, token):
|
|
"""Check existence of and access to api result link"""
|
|
print("checking result with a test ID of: %s" % (link.split("/")[-1]))
|
|
if not link:
|
|
return False
|
|
try:
|
|
if " " in link:
|
|
return False
|
|
headers = {"Authorization": "Bearer " + token}
|
|
response = requests.get(link, headers)
|
|
if response.status_code == 200:
|
|
return json.loads(response.text)
|
|
elif response.status_code == 401 or response.status_code == 403:
|
|
print("Authentication Failed. link check response code: %d" %
|
|
(response.status_code))
|
|
return False
|
|
elif response.status_code == 400:
|
|
print("Malformed Request. link response code: %d" %
|
|
(response.status_code))
|
|
return False
|
|
else:
|
|
print("Link check response_status_code = %d" %
|
|
(response.status_code))
|
|
print("Link check response detail: %s" % (response.text))
|
|
return False
|
|
except requests.exceptions as err:
|
|
print(err)
|
|
return False
|
|
|
|
|
|
def updateField(header, apiLink, raw_data):
|
|
"""Update a given metadata field"""
|
|
valid_keytype = ["shared", "guideline", "target"]
|
|
keytype = raw_data.type
|
|
keyval = raw_data.value
|
|
if keytype not in valid_keytype or not keyval:
|
|
updresult = "%s keypair does not exist" % (keytype)
|
|
return updresult, False
|
|
link = apiLink.strip() + "/meta/" + keytype
|
|
response = requests.post(link, data=keyval, headers=header)
|
|
if response.status_code != 201:
|
|
print("update response status code=%d" %
|
|
(response.status_code))
|
|
print("update response text=%s" % (response.text))
|
|
updresult = ("%s field update failed. reason: %s" %
|
|
(keytype, response.text.replace(",", " ")))
|
|
return updresult, False
|
|
else:
|
|
updresult = ("%s field update successful," % (keytype))
|
|
return updresult, True
|
|
|
|
|
|
def updateResult(apiLink, target, guideline, token, record):
|
|
"""Update metadata for result and verify if all updates are a success"""
|
|
MetadataField = namedtuple("MetadataField", ["type", "value"])
|
|
success = []
|
|
header = {"Authorization": "Bearer " + token}
|
|
with open(record, "a") as r:
|
|
r.write(str(datetime.datetime.now()) + "," + apiLink + ",")
|
|
# update the shared field
|
|
data = MetadataField("shared", "true")
|
|
shared_result, shared_status = updateField(header, apiLink, data)
|
|
r.write(shared_result)
|
|
success.append(shared_status)
|
|
# update the target field
|
|
data = MetadataField("target", target)
|
|
target_result, target_status = updateField(header, apiLink, data)
|
|
r.write(target_result)
|
|
success.append(target_status)
|
|
# update the guideline field
|
|
data = MetadataField("guideline", guideline + ".json")
|
|
gl_result, gl_status = updateField(header, apiLink, data)
|
|
r.write(gl_result)
|
|
success.append(gl_status)
|
|
if not all(success):
|
|
r.write("unable to verify.\n")
|
|
return False
|
|
# if there were no update failures, we can verify the result
|
|
# this is the operation most likely to fail, so extra checks are
|
|
# in order
|
|
print("Test Result updated successfully. Attempting verification.")
|
|
try:
|
|
response = requests.put(apiLink,
|
|
json={"verification_status": 1},
|
|
headers=header)
|
|
except Exception as ex:
|
|
print("Exception raised while verifying test result: %s" %
|
|
(str(ex)))
|
|
r.write("verification failed: %s\n" % (str(ex)))
|
|
return False
|
|
updated = verification_chk(apiLink, header)
|
|
if response.status_code not in (200, 201):
|
|
print("verification failure status code=%d" %
|
|
(response.status_code))
|
|
print("verification failure detail=%s" %
|
|
(response.text))
|
|
r.write("verification unsuccessful: detail: %s\n" %
|
|
(response.text))
|
|
return False
|
|
elif not updated:
|
|
print("verification_status field failed to update")
|
|
r.write("verification status update failed. detail: %s\n" %
|
|
(response.text))
|
|
return False
|
|
else:
|
|
print("Test result verified!\n")
|
|
r.write("Test result successfully verified\n")
|
|
return True
|
|
|
|
|
|
def verification_chk(link, header):
|
|
try:
|
|
response = requests.get(link, header)
|
|
status = int(response.json()["verification_status"])
|
|
if status == 1:
|
|
return True
|
|
else:
|
|
return False
|
|
except Exception as ex:
|
|
print(
|
|
"Exception raised while ensuring verification status update: %s" %
|
|
str(ex))
|
|
return False
|
|
|
|
|
|
def main():
|
|
linect = 0
|
|
parser = argparse.ArgumentParser(
|
|
"Update the internal RefStack db using a csv file")
|
|
# token handling options- we either need the path of a working token,
|
|
# or the data to generate a new token
|
|
token_flags = parser.add_mutually_exclusive_group(required=True)
|
|
token_flags.add_argument("--tokenfile", type=str, action="store",
|
|
help=("Absolute path to a json web token to "
|
|
"use to auth to the RefStack API"))
|
|
token_flags.add_argument("--generate", nargs=2,
|
|
metavar=("ssh-key", "openstack-id"),
|
|
help=("data needed to create a new auth token "
|
|
"ssh - key should be an absolute path to "
|
|
"a rsa ssh key. openstack - id indicates "
|
|
"an openstackid url to use for auth. "
|
|
"example: "
|
|
"https://openstackid.org/<your id >"))
|
|
# non token-related flags
|
|
parser.add_argument("--file", "-f", metavar="f", type=str, action="store",
|
|
required=True,
|
|
help="csv source for the data to use in updates")
|
|
parser.add_argument(
|
|
"--endpoint", "-e", metavar="e",
|
|
type=str, action="store", required=True,
|
|
help="the base URL of the endpoint. ex: http://examplerefstack.com/v1")
|
|
parser.add_argument("--record", "-r", metavar="r", type=str,
|
|
action="store", default="verification_results.csv",
|
|
help=("name of file to output update & verification "
|
|
"run record data into"))
|
|
args = parser.parse_args()
|
|
infile = args.file
|
|
record = args.record
|
|
endpoint = args.endpoint
|
|
if args.generate:
|
|
keypath = args.generate[0]
|
|
_id = args.generate[1]
|
|
generate_token(keypath, _id)
|
|
tokenfile = "./token"
|
|
else:
|
|
tokenfile = args.tokenfile
|
|
auth_success, token = testAuth(endpoint, tokenfile)
|
|
if not auth_success:
|
|
print(("Please enter either a valid token or an openstackid and the "
|
|
"absolute path to an rsa ssh key."))
|
|
sys.exit(1)
|
|
with open(infile) as f:
|
|
for line in f:
|
|
linect = linect + 1
|
|
entry = line.split(",")
|
|
testId, guideline, target = getData(entry)
|
|
if None in (testId, guideline, target):
|
|
print(("entry found at line %d cannot be updated and "
|
|
"verified: entry incomplete.\n") % (linect))
|
|
else:
|
|
apiLink = os.path.join(endpoint, "results", testId)
|
|
testResult = linkChk(apiLink, token)
|
|
if testResult:
|
|
if testResult.get("verification_status"):
|
|
print("Result has been verified.\n")
|
|
else:
|
|
print(
|
|
"Result link is valid. Updating result with ID %s"
|
|
% (testId))
|
|
success = updateResult(apiLink, target, guideline,
|
|
token, record)
|
|
if not success:
|
|
print(("update of the results with the ID %s "
|
|
"failed. please recheck your spreadsheet "
|
|
"and try again" % (testId)))
|
|
else:
|
|
print(("the test result: % s cannot be updated or "
|
|
"verified due to a broken result link." % (testId)))
|
|
|
|
|
|
main()
|