X-Git-Url: https://gerrit.akraino.org/r/gitweb?a=blobdiff_plain;f=bluval%2Fbluval.py;h=1580a40346cc8dfb93a83cfb01b99976486ab6a1;hb=fb63aa36ea17d40af4d0684d768d5e6cc3f80e31;hp=c0c16de7d9ce71dc3dbc986be122f4e358d480fe;hpb=64dc32d39f2f1541ecc1e55f38db1aed6f00d34b;p=validation.git

diff --git a/bluval/bluval.py b/bluval/bluval.py
index c0c16de..1580a40 100644
--- a/bluval/bluval.py
+++ b/bluval/bluval.py
@@ -15,48 +15,149 @@
 # See the License for the specific language governing permissions and        #
 # limitations under the License.                                             #
 ##############################################################################
-"""This module parses yaml file, reads sections, testcases and executes each
+"""This module parses yaml file, reads layers, testcases and executes each
 testcase
 """
 
 import subprocess
+from pathlib import Path
 import sys
+import traceback
+import click
 import yaml
 
+class BluvalError(Exception):
+    """Base class for exceptions in this module."""
+    pass
+
+
+class ShowStopperError(Exception):
+    """Showstopper test case failed"""
+    pass
+
+
 def run_testcase(testcase):
     """Runs a single testcase
     """
-    show_stopper = testcase.get('show_stopper', False)
+    name = testcase.get('name')
+    skip = testcase.get('skip', "False")
+    if skip.lower() == "true":
+        # skip is mentioned and true.
+        print('Skipping {}'.format(name))
+        return
+    show_stopper = testcase.get('show_stopper', "False")
+    what = testcase.get('what')
+    mypath = Path(__file__).absolute()
+    results_path = mypath.parents[2].joinpath("results/"+testcase.get('layer')+"/"+what)
+    test_path = mypath.parents[1].joinpath("tests/"+testcase.get('layer')+"/"+what)
+
+    # add to the variables file the path to where to sotre the logs
+    variables_file = mypath.parents[1].joinpath("tests/variables.yaml")
+    variables_dict = yaml.safe_load(variables_file.open())
+    variables_dict['log_path'] = str(results_path)
+    variables_file.write_text(str(variables_dict))
 
-    print('Executing testcase {}'.format(testcase['name']))
-    print('          show_stopper {}'.format(show_stopper))
-    cmd = 'robot {}'.format(testcase['what'])
-    print('Invoking {}'.format(cmd))
+    # run the test
+    args = ["robot", "-V", str(variables_file), "-d", str(results_path), str(test_path)]
+
+    print('Executing testcase {}'.format(name))
+    print('show_stopper {}'.format(show_stopper))
+    print('Invoking {}'.format(args))
     try:
-        status = subprocess.call(cmd, shell=True)
-        if status != 0 and show_stopper:
-            print('Show stopper testcase failed')
-            return status
+        status = subprocess.call(args, shell=False)
+        if status != 0 and show_stopper.lower() == "true":
+            raise ShowStopperError(name)
     except OSError:
-        print('Error while executing {}'.format(cmd))
-        return -1
-    return status
+        #print('Error while executing {}'.format(args))
+        raise BluvalError(OSError)
+
+def validate_layer(blueprint, layer):
+    """validates a layer by validating all testcases under that layer
+    """
+    print('## Layer {}'.format(layer))
+    for testcase in blueprint[layer]:
+        testcase['layer'] = layer
+        run_testcase(testcase)
 
 
-def parse_yaml(testcase_loc):
-    """Parse yaml file and do tasks on each testcase
+def validate_blueprint(yaml_loc, layer):
+    """Parse yaml file and validates given layer. If no layer given all layers
+    validated
     """
-    with open(testcase_loc) as testcase_file:
-        testcases = yaml.safe_load(testcase_file)
-    blueprint = testcases['blueprint']
-    for section in blueprint['sections']:
-        print('## Section {}'.format(section))
-        for testcase in blueprint[section]:
-            run_testcase(testcase)
+    with open(str(yaml_loc)) as yaml_file:
+        yamldoc = yaml.safe_load(yaml_file)
+    blueprint = yamldoc['blueprint']
+    if layer is None or layer == "all":
+        for each_layer in blueprint['layers']:
+            validate_layer(blueprint, each_layer)
+    else:
+        validate_layer(blueprint, layer)
 
 
+def invoke_docker(bluprint, layer):
+    """Start docker container for given layer
+    """
+    cmd = ("docker run"
+           " -v $HOME/.ssh:/root/.ssh"
+           " -v $HOME/.kube/config:/root/.kube/config"
+           " -v $VALIDATION_HOME/tests/variables.yaml:"
+           "/opt/akraino/validation/tests/variables.yaml"
+           " -v $AKRAINO_HOME/results:/opt/akraino/results"
+           " akraino/validation:{0}-latest"
+           " bin/sh -c"
+           " 'cd /opt/akraino/validation "
+           "&& python bluval/bluval.py -l {0} {1}'").format(layer, bluprint)
+    args = [cmd]
+    try:
+        print('Invoking {}'.format(args))
+        subprocess.call(args, shell=True)
+    except OSError:
+        #print('Error while executing {}'.format(args))
+        raise BluvalError(OSError)
+
+
+def invoke_dockers(yaml_loc, layer, blueprint_name):
+    """Parses yaml file and starts docker container for one/all layers
+    """
+    with open(str(yaml_loc)) as yaml_file:
+        yamldoc = yaml.safe_load(yaml_file)
+    blueprint = yamldoc['blueprint']
+    if layer is None or layer == "all":
+        for each_layer in blueprint['layers']:
+            invoke_docker(blueprint_name, each_layer)
+    else:
+        invoke_docker(blueprint_name, layer)
+
+
+@click.command()
+@click.argument('blueprint')
+@click.option('--layer', '-l')
+@click.option('--delegate', '-d', is_flag=True)
+def main(blueprint, layer, delegate):
+    """Takes blueprint name and optional layer. Validates inputs and derives
+    yaml location from blueprint name. Invokes validate on blue print.
+    """
+    mypath = Path(__file__).absolute()
+    yaml_loc = mypath.parents[0].joinpath('bluval-{}.yaml'.format(blueprint))
+    if layer is not None:
+        layer = layer.lower()
+    try:
+        if delegate is not None:
+            invoke_dockers(yaml_loc, layer, blueprint)
+        else:
+            validate_blueprint(yaml_loc, layer)
+    except ShowStopperError as err:
+        print('ShowStopperError:', err)
+    except BluvalError as err:
+        print('Unexpected BluvalError', err)
+        raise
+    except:
+        print("Exception in user code:")
+        print("-"*60)
+        traceback.print_exc(file=sys.stdout)
+        print("-"*60)
+        raise
+
 if __name__ == "__main__":
-    if len(sys.argv) != 2:
-        print('usage: bluval.py <testcase.yaml>')
-        sys.exit(1)
-    parse_yaml(sys.argv[1])
+    # pylint: disable=no-value-for-parameter
+    main()