Esempio n. 1
0
 def create_tmp_dir(self):
     """
         Create a temp directory for parallel execution test
     """
     path = file_Utils.createDir(file_Utils.getDirName(self.logsdir), "tmp")
     return True, {
         "parallel_exec_tmp_dir":
         os.path.join(file_Utils.getDirName(self.logsdir), "tmp")
     } if path else False
 def verify_json(self, incoming_json, respond_obj, file=False):
     """
         Verify the incoming_json data with either
         a. whole json file
         b. key value pairs
         :param:
             incoming_json: a json string/json obj
             respond_obj: contains the verification detail from datafile
             file: indicate if comparing whole file or just pairs
         :return:
             True if whole file match/all pairs match
             False if not match
     """
     if isinstance(incoming_json, str):
         incoming_json = json.loads(incoming_json)
     if file:
         for expect_json_file in respond_obj["request_verify_data"]:
             expect_json_file = getAbsPath(expect_json_file,
                                           getDirName(self.datafile))
             expect_json = json.load(open(expect_json_file))
             if sorted(incoming_json.items()) == sorted(
                     expect_json.items()):
                 return True
         return False
     else:
         for json_pair in respond_obj["request_verify"]:
             json_keys = json_pair.split(",")[0][4:].split("[")
             # Since datafile is xml and it only have string
             # must have a way to process different object type in json
             json_value = literal_eval(json_pair.split(",")[1][6:])
             # travesing to get the child element value
             incoming_json_index = incoming_json
             for json_key in json_keys:
                 json_key = json_key.replace("]", "")
                 if json_key not in incoming_json_index:
                     return False
                 else:
                     incoming_json_index = incoming_json_index[json_key]
             if incoming_json_index != json_value:
                 return False
     return True
    def verify_xml(self, incoming_xml, respond_obj, file=False):
        """
            Verify the incoming_xml data with either
            a. whole xml file
            b. tag text pairs
            :param:
                incoming_xml: an xml string
                respond_obj: contains the verification detail from datafile
                file: indicate if comparing whole file or just pairs
            :return:
                True if whole file match/all pairs match
                False if not match
        """
        if file:
            status = False
            for expect_xml_file in respond_obj["request_verify_data"]:
                expect_xml_file = getAbsPath(expect_xml_file,
                                             getDirName(self.datafile))
                status, _, _, _ = compare_xml(incoming_xml,
                                              expect_xml_file,
                                              output_file=False,
                                              sorted_json=False,
                                              remove_namespaces=True)
            return status
        else:
            incoming_xml = ET.fromstring(incoming_xml,
                                         parser=ET.XMLParser(encoding="utf-8"))
            for element_pair in respond_obj["request_verify"]:
                xpath = element_pair.split(",")[0][4:]
                value = element_pair.split(",")[1][6:]
                incoming_value = getChildElementWithSpecificXpath(
                    incoming_xml, xpath)
                if incoming_value is None or value != incoming_value.text:
                    return False

        return True
    def sftp_from_remotehost(cls, session_object, ip_type, sftp_operation, port,
                             filepath, prompt, dest_address, username,
                             password, filepath_dest):
        """sftp(test both put and get).This keyword can be used to transfer
        file from source _system to destination system or vice versa.
        It checks the size after transfer in both get and put.

        :Arguments:
            1. session_object(string)  = name of the Linux machine on which\
                                      to execute
            2. ip_type(string) = iptype of the dest system through \
                                 which it needs to be connected.
                                 needs to be one of \
                                 (ip/ipv4/dns/lmp_ip/lmp_ipv6).It has to be \
                                 present in the input data file.
            3. sftp_operation(string) = get/put/both
            4. port(string) = source port
            5. filepath(string) = file with filepath in source\
                                  system(used for put)
            6. prompt(string)  = prompt of the source system
            7. dest_address(string) = ipv4 address or defaulted to lcn ip
            8. username(string) = username of the dest system
            9. password(string) = password of the dest system
            9. filepath_dest(string) = file with filepath in destination\
                               system(used for get)
        :Returns:
            1. bool (True/False)

        """
        put = True if ("put" in sftp_operation or "both" in sftp_operation) \
            else False
        get = True if ("get" in sftp_operation or "both" in sftp_operation) \
            else False

        status_get = False if get else True
        status_put = False if put else True

        filedir, filename = (file_Utils.getDirName(filepath),
                             file_Utils.getFileName(filepath))
        filedir_dest, filename_dest = (file_Utils.getDirName(filepath_dest),
                                       file_Utils.getFileName(filepath_dest))

        sftp_cmd = "sftp"
        if ip_type == "ipv6":
            sftp_cmd = "sftp6"

        # move into the path
        session_object.send_command(".*", prompt, "cd {}".format(filedir))
        command = sftp_cmd + "  -oPort={0} {1}@{2}".format(port, username,
                                                           dest_address)

        # check whether file is available
        putfilepresent = cls.file_exists_on_remote(session_object, prompt,
                                                   filename)
        if putfilepresent:
            # check the put file size
            put_file_size = cls.get_file_size(session_object, prompt, filename)

        else:
            pNote("Specified put file:{} not found".format(filename), "error")

        # Starting the sftp connection
        status = cls.start_sftp_on_remote(session_object, command,
                                          password, prompt)
        if status:
            session_object.send_command(".*", ">", "cd {}".format(filedir_dest))

            if putfilepresent and put:
                status_put = cls.sftp_put_from_remote(session_object,
                                                      filename, filedir)
                put_file_size_transf = cls.get_file_size(session_object, ">",
                                                         filename,
                                                         session="sftp")
                if status_put:
                    pNote("Actual put file size:{0} Transferred put file size"
                          ":{1}".format(str(put_file_size), str(put_file_size_transf)))
                    if str(put_file_size) == str(put_file_size_transf):
                        status_put = True
                        pNote("Transferred put file size matches the origin")
                    else:
                        status_put = False
                        pNote("Transferred put file size does not"
                              "match the origin")

            if get:
                # check whether file is available
                getfilepresent = cls.file_exists_on_remote(session_object, ">",
                                                           filename_dest)

                if getfilepresent:
                    gfile_size = cls.get_file_size(session_object, ">",
                                                   filename_dest,
                                                   session="sftp")
                    status_get = cls.sftp_get_from_remote(session_object,
                                                          filename_dest,
                                                          filedir_dest)

                    # exiting the sftp terminal
                    session_object.send_command(".*", prompt, "exit")

                    if status_get:
                        # check the get file size after transfer
                        gfile_size_transf = cls.get_file_size(session_object,
                                                              prompt,
                                                              filename_dest)

                        pNote("Actual get file size:{0} Transferred get file"
                              "size:{1}".format(str(gfile_size), str(gfile_size_transf)))
                        if str(gfile_size) == str(gfile_size_transf):
                            status_get = True
                            pNote("Transferred get file size matches the origin")
                        else:
                            status_get = False
                            pNote("Transferred get file size matches the origin")
                else:
                    pNote("Specified get file:{} not found".format(filename_dest),
                          "error")

            else:
                session_object.send_command(".*", prompt, "exit")

            status = status_get and status_put
        else:
            status = False
        return status
    def build_server(self, datafile, system_name):
        """
            Take in a system and read all its routes
            Load the routes into Bottle server object
            Start a thread with the bottle server

            return the bottle server adapter and server thread
        """
        app = Bottle()
        # Get system and routes
        system_data = data_Utils.get_credentials(datafile, system_name)
        self.datafile = datafile

        route_file = system_data['mapping_file']
        if route_file:
            route_file = getAbsPath(route_file, getDirName(datafile))
        # Loop through each route
        for route in data_Utils.get_all_system_or_subsystem(route_file):
            route_name = route.get('name')
            if route_name[0] != '/':
                route_name = '/' + route_name

            # Group request condition with the same method together
            route_methods = {}
            for request in route:
                request_method = request.find('request_method').text.upper()
                if request_method not in route_methods:
                    route_methods[request_method] = [request]
                else:
                    route_methods[request_method].append(request)

            # Build route with the grouped conditions
            for method_type, same_type_methods in list(route_methods.items()):
                # A route can have general response and conditional response
                specific_res = []
                general_res = {}

                for method in same_type_methods:
                    dict_of_info = {}
                    method_req = {}
                    method_res = {}

                    # Get all info from the condition
                    for info in iter(method):
                        if info.tag in dict_of_info:
                            dict_of_info[info.tag].append(info.text)
                        else:
                            dict_of_info[info.tag] = [info.text]

                    # Extract request/response related info
                    for key, value in list(dict_of_info.items()):
                        if key in request_verify_list:
                            method_req = {key: value}
                        elif key in response_list:
                            method_res[key] = value

                    if any([
                            key in request_verify_list
                            for key in list(dict_of_info.keys())
                    ]):
                        # this condition has request/response pair
                        method_combine = method_req
                        method_combine.update(method_res)
                        specific_res.append(method_req)
                        # this ensure when all verification fail and no general response given
                        # there will be some responses
                        if any([
                                key in on_fail_response_list
                                for key in list(dict_of_info.keys())
                        ]):
                            general_res.update(method_res)
                    else:
                        # this condition only has general response
                        general_res.update(method_res)

                app.route(
                    route_name, method_type,
                    self.build_route(route_name, method_type, specific_res,
                                     general_res))

        # Build a class to hold the server so it can be closed easily
        port = 5000 if "port" not in system_data else int(system_data["port"])
        server = ServerHandler(host="0.0.0.0", port=port)
        server_thread = threading.Thread(target=run,
                                         kwargs={
                                             "app": app,
                                             "server": server,
                                             "debug": True
                                         })
        server_thread.daemon = True
        server_thread.start()
        sleep(2)

        if server_thread.is_alive():
            return True, {"server": server, "server_thread": server_thread}
        else:
            return False, {}