csit/libraries/KarafKeywords.robot

   1 *** Settings ***
   2 Documentation     Karaf library. General utility keywords for interacting with the karaf environment, such as the
   3 ...               karaf console, karaf.log, karaf features, and karaf config files.
   4 ...
   5 ...               This library is useful to deal with controller Karaf console for ssh sessions in cluster.
   6 ...               Running Setup_Karaf_Keywords is necessary. If SetupUtils initialization is called, this gets initialized as well.
   7 ...               If this gets initialized, ClusterManagement gets initialized as well.
   8 Library           SSHLibrary
   9 Library           OperatingSystem
  10 Resource          ${CURDIR}/ClusterManagement.robot
  11 Resource          ${CURDIR}/SSHKeywords.robot
  12 Variables         ${CURDIR}/../variables/Variables.py
  13
  14 *** Variables ***
  15 ${WORKSPACE}      /tmp
  16 ${connection_index_dict}    &{EMPTY}
  17
  18 *** Keywords ***
  19 Setup_Karaf_Keywords
  20     [Arguments]    ${http_timeout}=${DEFAULT_TIMEOUT_HTTP}
  21     [Documentation]    Initialize ClusterManagement. Open ssh karaf connections to each ODL.
  22     ClusterManagement.ClusterManagement_Setup    http_timeout=${http_timeout}
  23     BuiltIn.Comment    First connections to Karaf console may fail, so WUKS is used. TODO: Track as a Bug.
  24     : FOR    ${index}    IN    @{ClusterManagement__member_index_list}
  25     \    BuiltIn.Run_Keyword_And_Ignore_Error    BuiltIn.Wait_Until_Keyword_Succeeds    3s    1s    Open_Controller_Karaf_Console_On_Background    member_index=${index}
  26
  27 Verify_Feature_Is_Installed
  28     [Arguments]    ${feature_name}    ${controller}=${ODL_SYSTEM_IP}    ${karaf_port}=${KARAF_SHELL_PORT}
  29     [Documentation]    Will Succeed if the given ${feature_name} is found in the output of "feature:list -i"
  30     ${output} =    Issue_Command_On_Karaf_Console    feature:list -i | grep ${feature_name}    ${controller}    ${karaf_port}
  31     BuiltIn.Should_Contain    ${output}    ${feature_name}
  32     [Return]    ${output}
  33
  34 Issue_Command_On_Karaf_Console
  35     [Arguments]    ${cmd}    ${controller}=${ODL_SYSTEM_IP}    ${karaf_port}=${KARAF_SHELL_PORT}    ${timeout}=10    ${loglevel}=INFO
  36     [Documentation]    Will execute the given ${cmd} by ssh'ing to the karaf console running on ${controller}
  37     ...    Note that this keyword will open&close new SSH connection, without switching back to previously current session.
  38     SSHLibrary.Open_Connection    ${controller}    port=${karaf_port}    prompt=${KARAF_PROMPT_LOGIN}    timeout=${timeout}
  39     SSHLibrary.Login    ${KARAF_USER}    ${KARAF_PASSWORD}    loglevel=${loglevel}
  40     SSHLibrary.Write    ${cmd}
  41     ${output}    SSHLibrary.Read_Until_Regexp    ${KARAF_PROMPT}
  42     SSHLibrary.Close_Connection
  43     BuiltIn.Log    ${output}
  44     [Return]    ${output}
  45
  46 Safe_Issue_Command_On_Karaf_Console
  47     [Arguments]    ${cmd}    ${controller}=${ODL_SYSTEM_IP}    ${karaf_port}=${KARAF_SHELL_PORT}    ${timeout}=10    ${loglevel}=INFO
  48     [Documentation]    Run Issue_Command_On_Karaf_Console but restore previous connection afterwards.
  49     BuiltIn.Run_Keyword_And_Return    SSHKeywords.Run_Keyword_Preserve_Connection    Issue_Command_On_Karaf_Console    ${cmd}    ${controller}    ${karaf_port}    ${timeout}
  50     ...    ${loglevel}
  51
  52 Check For Elements On Karaf Command Output Message
  53     [Arguments]    ${cmd}    ${elements}    ${controller}=${ODL_SYSTEM_IP}    ${karaf_port}=${KARAF_SHELL_PORT}    ${timeout}=5
  54     [Documentation]    Will execute the command using Issue Command On Karaf Console then check for the given elements
  55     ...    in the command output message
  56     ${output}    Issue_Command_On_Karaf_Console    ${cmd}    ${controller}    ${karaf_port}    ${timeout}
  57     : FOR    ${i}    IN    @{elements}
  58     \    BuiltIn.Should_Contain    ${output}    ${i}
  59
  60 Verify_Bundle_Is_Installed
  61     [Arguments]    ${bundle_name}    ${controller}=${ODL_SYSTEM_IP}    ${karaf_port}=${KARAF_SHELL_PORT}
  62     [Documentation]    Will succeed if the given ${bundle name} is present in the output of "bundle:list -s "
  63     ${output} =    Issue_Command_On_Karaf_Console    bundle:list -s | grep ${bundle_name}    ${controller}    ${karaf_port}
  64     BuiltIn.Should_Contain    ${output}    ${bundle_name}
  65     [Return]    ${output}
  66
  67 Verify_Bundle_Is_Not_Installed
  68     [Arguments]    ${bundle_name}    ${controller}=${ODL_SYSTEM_IP}    ${karaf_port}=${KARAF_SHELL_PORT}
  69     [Documentation]    Will succeed if the given ${bundle_name} is NOT found in the output of "bundle:list -s"
  70     ${output} =    Issue_Command_On_Karaf_Console    bundle:list -i | grep ${bundle_name}    ${controller}    ${karaf_port}
  71     BuiltIn.Should_Not_Contain    ${output}    ${bundle_name}
  72     [Return]    ${output}
  73
  74 Check_Karaf_Log_Has_Messages
  75     [Arguments]    ${filter_string}    @{message_list}
  76     [Documentation]    Will succeed if the @{messages} are found in \ the output of "log:display"
  77     ${output} =    Issue_Command_On_Karaf_Console    log:display | grep ${filter_string}
  78     : FOR    ${message}    IN    @{message_list}
  79     \    BuiltIn.Should_Contain    ${output}    ${message}
  80     [Return]    ${output}
  81
  82 Install_A_Feature
  83     [Arguments]    ${feature_name}    ${controller}=${ODL_SYSTEM_IP}    ${karaf_port}=${KARAF_SHELL_PORT}    ${timeout}=180
  84     [Documentation]    Will Install the given ${feature_name}
  85     BuiltIn.Log    ${timeout}
  86     ${output} =    Issue_Command_On_Karaf_Console    feature:install ${feature_name}    ${controller}    ${karaf_port}    ${timeout}
  87     BuiltIn.Log    ${output}
  88     [Return]    ${output}
  89
  90 Install_A_Feature_Using_Active_Connection
  91     [Arguments]    ${feature_name}
  92     [Documentation]    Will Install the given ${feature_name} using active connection
  93     ${cmd} =    BuiltIn.Set_Variable    feature:install ${feature_name}
  94     SSHLibrary.Write    ${cmd}
  95     ${output}    SSHLibrary.Read_Until_Regexp    ${KARAF_PROMPT}
  96     BuiltIn.Log    ${output}
  97     [Return]    ${output}
  98
  99 Uninstall_A_Feature
 100     [Arguments]    ${feature_name}    ${controller}=${ODL_SYSTEM_IP}    ${karaf_port}=${KARAF_SHELL_PORT}    ${timeout}=180
 101     [Documentation]    Will UnInstall the given ${feature_name}
 102     ${output} =    Issue_Command_On_Karaf_Console    feature:uninstall ${feature_name}    ${controller}    ${karaf_port}    ${timeout}
 103     BuiltIn.Log    ${output}
 104     [Return]    ${output}
 105
 106 Open_Controller_Karaf_Console_On_Background
 107     [Arguments]    ${member_index}=${1}    ${timeout}=10    ${loglevel}=INFO
 108     [Documentation]    If there is a stored ssh connection index of connection to the controller's karaf console for ${member_index},
 109     ...    close the previous connection. In any case create a new connection
 110     ...    to karaf console for ${member_index}, set correct prompt set and login to karaf console.
 111     ...    Store connection index for ${member_index} and restore the previous active connection.
 112     ${current_ssh_connection_object}=    SSHLibrary.Get_Connection
 113     BuiltIn.Log    ${connection_index_dict}
 114     BuiltIn.Log    ${member_index}
 115     ${status}    ${old_connection_index} =    BuiltIn.Run_Keyword_And_Ignore_Error    Get From Dictionary    ${connection_index_dict}    ${member_index}
 116     BuiltIn.Run_Keyword_If    '${status}'=='PASS'    BuiltIn.Run_Keywords    SSHLibrary.Switch_Connection    ${old_connection_index}
 117     ...    AND    SSHLibrary.Close_Connection
 118     ${odl_ip} =    ClusterManagement.Resolve_IP_Address_For_Member    ${member_index}
 119     SSHLibrary.Open_Connection    ${odl_ip}    port=${KARAF_SHELL_PORT}    prompt=${KARAF_PROMPT_LOGIN}    timeout=${timeout}
 120     ${karaf_connection_object} =    SSHLibrary.Get_Connection
 121     Collections.Set_To_Dictionary    ${connection_index_dict}    ${member_index}    ${karaf_connection_object.index}
 122     SSHLibrary.Login    ${KARAF_USER}    ${KARAF_PASSWORD}    loglevel=${loglevel}
 123     [Teardown]    SSHKeywords.Restore_Current_Ssh_Connection_From_Index    ${current_ssh_connection_object.index}
 124
 125 Open_Controller_Karaf_Console_With_Timeout
 126     [Arguments]    ${member_index}=${1}    ${timeout}=3s
 127     [Documentation]    Open new connection to karaf console for member index with specified timeout.
 128     BuiltIn.Log    ${member_index}
 129     ${odl_ip} =    ClusterManagement.Resolve_IP_Address_For_Member    ${member_index}
 130     SSHLibrary.Open_Connection    ${odl_ip}    port=${KARAF_SHELL_PORT}    prompt=${KARAF_PROMPT_LOGIN}    timeout=${timeout}
 131     SSHLibrary.Login    ${KARAF_USER}    ${KARAF_PASSWORD}
 132
 133 Configure_Timeout_For_Karaf_Console
 134     [Arguments]    ${timeout}    ${member_index_list}=${EMPTY}
 135     [Documentation]    Configure a different timeout for each Karaf console.
 136     ${index_list} =    ClusterManagement.List_Indices_Or_All    given_list=${member_index_list}
 137     ${current_connection_object} =    SSHLibrary.Get_Connection
 138     : FOR    ${member_index}    IN    @{index_list}    # usually: 1, 2, 3
 139     \    ${karaf_connection_index} =    Collections.Get_From_Dictionary    ${connection_index_dict}    ${member_index}
 140     \    SSHLibrary.Switch_Connection    ${karaf_connection_index}
 141     \    SSHLibrary.Set_Client_Configuration    timeout=${timeout}
 142     [Teardown]    SSHKeywords.Restore_Current_Ssh_Connection_From_Index    ${current_connection_object.index}
 143
 144 Execute_Controller_Karaf_Command_On_Background
 145     [Arguments]    ${command}    ${member_index}=${1}
 146     [Documentation]    Send command to karaf without affecting current SSH connection. Read, log and return response.
 147     ${karaf_connection_index} =    Collections.Get_From_Dictionary    ${connection_index_dict}    ${member_index}
 148     ${current_connection_index} =    SSHLibrary.Switch_Connection    ${karaf_connection_index}
 149     ${status_write}    ${message_write} =    BuiltIn.Run_Keyword_And_Ignore_Error    SSHLibrary.Write    ${command}
 150     ${status_wait}    ${message_wait} =    BuiltIn.Run_Keyword_And_Ignore_Error    SSHLibrary.Read_Until_Regexp    ${KARAF_PROMPT}
 151     BuiltIn.Run Keyword If    '${status_write}' != 'PASS'    BuiltIn.Fail    Failed to send the command: ${command}
 152     BuiltIn.Log    ${message_wait}
 153     BuiltIn.Run_Keyword_If    '${status_wait}' != 'PASS'    BuiltIn.Fail    Failed to see prompt after sending the command: ${command}
 154     [Teardown]    SSHKeywords.Restore_Current_Ssh_Connection_From_Index    ${current_connection_index}
 155     [Return]    ${message_wait}
 156
 157 Execute_Controller_Karaf_Command_With_Retry_On_Background
 158     [Arguments]    ${command}    ${member_index}=${1}
 159     [Documentation]    Attemp to send command to karaf for ${member_index}, if fail then open connection and try again.
 160     ${status}    ${message} =    BuiltIn.Run_Keyword_And_Ignore_Error    Execute_Controller_Karaf_Command_On_Background    ${command}    ${member_index}
 161     BuiltIn.Return_From_Keyword_If    '${status}' == 'PASS'    ${message}
 162     # TODO: Verify this does not leak connections indices.
 163     Open_Controller_Karaf_Console_On_Background    ${member_index}
 164     ${message} =    Execute_Controller_Karaf_Command_On_Background    ${command}    ${member_index}
 165     [Return]    ${message}
 166
 167 Log_Message_To_Controller_Karaf
 168     [Arguments]    ${message}    ${member_index_list}=${EMPTY}    ${tolerate_failure}=True
 169     [Documentation]    Make sure this resource is initialized. Send a message into the controller's karaf log file on every node listed (or all).
 170     ...    By default, failure while processing a node is silently ignored, unless ${tolerate_failure} is False.
 171     ${index_list} =    ClusterManagement.List_Indices_Or_All    given_list=${member_index_list}
 172     : FOR    ${index}    IN    @{index_list}    # usually: 1, 2, 3.
 173     \    ${status}    ${output} =    BuiltIn.Run_Keyword_And_Ignore_Error    Execute_Controller_Karaf_Command_With_Retry_On_Background    log:log "ROBOT MESSAGE: ${message}"    member_index=${index}
 174     \    BuiltIn.Run_Keyword_Unless    ${tolerate_failure} or "${status}" == "PASS"    BuiltIn.Fail    ${output}
 175
 176 Log_Test_Suite_Start_To_Controller_Karaf
 177     [Arguments]    ${member_index_list}=${EMPTY}
 178     [Documentation]    Log suite name to karaf log, useful in suite setup.
 179     Log_Message_To_Controller_Karaf    Starting suite ${SUITE_SOURCE}    ${member_index_list}
 180
 181 Log_Testcase_Start_To_Controller_Karaf
 182     [Arguments]    ${member_index_list}=${EMPTY}
 183     [Documentation]    Log test case name to karaf log, useful in test case setup.
 184     Log_Message_To_Controller_Karaf    Starting test ${SUITE_NAME}.${TEST_NAME}    ${member_index_list}
 185
 186 Set_Bgpcep_Log_Levels
 187     [Arguments]    ${bgpcep_level}=${DEFAULT_BGPCEP_LOG_LEVEL}    ${protocol_level}=${DEFAULT_PROTOCOL_LOG_LEVEL}    ${member_index_list}=${EMPTY}
 188     [Documentation]    Assuming OCKCOB was used, set logging level on bgpcep and protocol loggers without affecting current SSH session.
 189     # FIXME: Move to appropriate Resource
 190     ${index_list} =    ClusterManagement.List_Indices_Or_All    given_list=${member_index_list}
 191     : FOR    ${index}    IN    @{index_list}    # usually: 1, 2, 3.
 192     \    Execute_Controller_Karaf_Command_On_Background    log:set ${bgpcep_level} org.opendaylight.bgpcep    member_index=${index}
 193     \    Execute_Controller_Karaf_Command_On_Background    log:set ${protocol_level} org.opendaylight.protocol    member_index=${index}
 194
 195 Get Karaf Log Type From Test Start
 196     [Arguments]    ${ip}    ${test_name}    ${type}    ${user}=${ODL_SYSTEM_USER}    ${password}=${ODL_SYSTEM_PASSWORD}    ${prompt}=${ODL_SYSTEM_PROMPT}
 197     ...    ${log_file}=${KARAF_LOG}
 198     [Documentation]    Scrapes all log messages that match regexp ${type} which fall after a point given by a log message that
 199     ...    contains ${test_name}. This is useful if your test cases are marking karaf.log with a message indicating when
 200     ...    that test case has started; such that you can easily pull out any extra log messsages to parse/log/etc in the
 201     ...    test logic itself. For example, you can grab all ERRORS that occur during your test case.
 202     ${cmd}    Set Variable    sed '1,/ROBOT MESSAGE: Starting test ${test_name}/d' ${log_file} | grep '${type}'
 203     ${output}    Run Command On Controller    ${ip}    ${cmd}    ${user}    ${password}    ${prompt}
 204     [Return]    ${output}
 205
 206 Get Karaf Log Types From Test Start
 207     [Arguments]    ${ip}    ${test_name}    ${types}    ${user}=${ODL_SYSTEM_USER}    ${password}=${ODL_SYSTEM_PASSWORD}    ${prompt}=${ODL_SYSTEM_PROMPT}
 208     ...    ${log_file}=${KARAF_LOG}
 209     [Documentation]    A wrapper keyword for "Get Karaf Log Type From Test Start" so that we can parse for multiple types
 210     ...    of log messages. For example, we can grab all messages of type WARN and ERROR
 211     : FOR    ${type}    IN    @{types}
 212     \    Get Karaf Log Type From Test Start    ${ip}    ${test_name}    ${type}    ${user}    ${password}
 213     \    ...    ${prompt}    ${log_file}
 214
 215 Get Karaf Log Events From Test Start
 216     [Arguments]    ${test_name}    ${user}=${ODL_SYSTEM_USER}    ${password}=${ODL_SYSTEM_PASSWORD}    ${prompt}=${ODL_SYSTEM_PROMPT}
 217     [Documentation]    Wrapper for the wrapper "Get Karaf Log Types From Test Start" so that we can easily loop over
 218     ...    any number of controllers to analyze karaf.log for ERROR, WARN and Exception log messages
 219     ${log_types} =    Create List    ERROR    WARN    Exception
 220     : FOR    ${i}    IN RANGE    1    ${NUM_ODL_SYSTEM} + 1
 221     \    Get Karaf Log Types From Test Start    ${ODL_SYSTEM_${i}_IP}    ${test_name}    ${log_types}
 222
 223 Fail If Exceptions Found During Test
 224     [Arguments]    ${test_name}    ${exceptions_white_list}=${EMPTY}
 225     [Documentation]    Create a failure if an Exception is found in the karaf.log. Will work for single controller jobs
 226     ...    as well as 3node cluster jobs
 227     : FOR    ${i}    IN RANGE    1    ${NUM_ODL_SYSTEM} + 1
 228     \    Verify Exception Logging In Controller    ${ODL_SYSTEM_${i}_IP}    ${test_name}    ${exceptions_white_list}
 229
 230 Verify Exception Logging In Controller
 231     [Arguments]    ${controller_ip}    ${test_name}    ${exceptions_white_list}
 232     [Documentation]    Local keyword to make it easier to loop through N controllers to pull Exceptions from the
 233     ...    karaf.log file and validate with "Check Against White List"
 234     ${exceptions}=    Get Karaf Log Type From Test Start    ${controller_ip}    ${test_name}    Exception
 235     @{log_lines}=    Split String    ${exceptions}    ${\n}
 236     ${num_log_entries}    Get Length    ${log_lines}
 237     Return From Keyword If    ${num_log_entries} == ${0}    No Exceptions found.
 238     : FOR    ${log_message}    IN    @{log_lines}
 239     \    Check Against White List    ${log_message}    ${exceptions_white_list}
 240
 241 Check Against White List
 242     [Arguments]    ${exception_line}    ${exceptions_white_list}
 243     [Documentation]    As soon as the ${exceptions_line} is found in one of the elements of ${exceptions_white_list}
 244     ...    this keyword will exit and give a Pass to the caller. If there is no match, this keyword will end up
 245     ...    marking a failure. In the case that no exceptions are found, the caller could end up passing a single
 246     ...    empty line as that is what is returned when a grep on karaf.log has no match, so we can safely return
 247     ...    in that case as well.
 248     Return From Keyword If    "${exception_line}" == ""
 249     : FOR    ${exception}    IN    @{exceptions_white_list}
 250     \    Return From Keyword If    "${exception}" in "${exception_line}"    Exceptions found, but whitelisted: ${\n}${exception_line}${\n}
 251     Fail    Exceptions Found: ${\n}${exception_line}${\n}
 252
 253 Wait_For_Karaf_Log
 254     [Arguments]    ${message}    ${timeout}=60    ${member_index}=${1}
 255     [Documentation]    Read karaf logs until message appear
 256     # TODO: refactor this keyword to use the new workflow to account for multiple controllers.    Initial work was done
 257     # in this patch https://git.opendaylight.org/gerrit/#/c/45596/
 258     # however, the consumers of this keyword were breaking after that change.    Initial theory is that a previous
 259     # keyword used before this "Wait For Karaf Log" keyword was closing the karaf console connection, so the
 260     # "Flexible SSH Login" keyword from the patch above (45596) was failing.
 261     BuiltIn.Log    Waiting for '${message}' in karaf log
 262     SSHLibrary.Open_Connection    ${ODL_SYSTEM_IP}    port=${KARAF_SHELL_PORT}    prompt=${KARAF_PROMPT_LOGIN}    timeout=${timeout}
 263     SSHLibrary.Login    ${KARAF_USER}    ${KARAF_PASSWORD}    loglevel=${loglevel}
 264     SSHLibrary.Write    log:tail
 265     SSHLibrary.Read_Until    ${message}
 266     SSHLibrary.Close_Connection
 267
 268 Restart_Bundle
 269     [Arguments]    ${bundle_id}
 270     [Documentation]    Restarts bundle passed as argument. Note this operation is only for testing and not production environments
 271     # TODO: prepare this for cluster environment and multiple controllers
 272     Execute_Controller_Karaf_Command_With_Retry_On_Background    bundle:restart -f $(bundle:id '${bundle_id}')
 273
 274 Restart_Karaf
 275     [Documentation]    Restarts Karaf and polls log to detect when Karaf is up and running again
 276     # TODO: prepare this for cluster environment and multiple controllers
 277     Execute_Controller_Karaf_Command_With_Retry_On_Background    log:clear
 278     Execute_Controller_Karaf_Command_With_Retry_On_Background    shutdown -r -f
 279     BuiltIn.Run_Keyword_And_Return_Status    BuiltIn.Wait_Until_Keyword_Succeeds    240s    60s    Wait_For_Karaf_Log    Karaf started in
 280
 281 Restart_Jetty
 282     [Documentation]    Restarts jetty bundle (to reload certificates or key/truststore information)
 283     Execute_Controller_Karaf_Command_With_Retry_On_Background    log:clear
 284     Restart_Bundle    OPS4J Pax Web - Jetty
 285     Wait_For_Karaf_Log    Instantiated the Application class org.opendaylight.restconf.RestconfApplication
 286     Wait_For_Karaf_Log    Instantiated the Application class org.opendaylight.netconf.sal.rest.impl.RestconfApplication
 287     Wait_For_Karaf_Log    Instantiated the Application class org.opendaylight.aaa.idm.IdmLightApplication