csit/libraries/Utils.robot

   1 *** Settings ***
   2 Documentation     General Utils library. This library has broad scope, it can be used by any robot system tests.
   3 Library           SSHLibrary
   4 Library           HttpLibrary.HTTP
   5 Library           String
   6 Library           DateTime
   7 Library           Process
   8 Library           Collections
   9 Library           RequestsLibrary
  10 Library           OperatingSystem
  11 Library           ${CURDIR}/UtilLibrary.py
  12 Resource          ${CURDIR}/SSHKeywords.robot
  13 Resource          ${CURDIR}/TemplatedRequests.robot
  14 Resource          ${CURDIR}/../variables/Variables.robot
  15
  16 *** Variables ***
  17 # TODO: Introduce ${tree_size} and use instead of 1 in the next line.
  18 ${start}          sudo mn --controller=remote,ip=${ODL_SYSTEM_IP} --topo tree,1 --switch ovsk,protocols=OpenFlow13
  19
  20 *** Keywords ***
  21 Start Mininet
  22     [Arguments]    ${system}=${TOOLS_SYSTEM_IP}    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${TOOLS_SYSTEM_PASSWORD}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${timeout}=30s
  23     [Documentation]    Basic setup/cleanup work that can be done safely before any system
  24     ...    is run.
  25     Log    Start the test on the base edition
  26     Clean Mininet System
  27     ${mininet_conn_id}=    Open Connection    ${system}    prompt=${prompt}    timeout=${timeout}
  28     Set Suite Variable    ${mininet_conn_id}
  29     SSHKeywords.Flexible Mininet Login    user=${user}    password=${password}
  30     Execute Command    sudo ovs-vsctl set-manager ptcp:6644
  31     Write    ${start}
  32     Read Until    mininet>
  33
  34 Stop Mininet
  35     [Arguments]    ${prompt}=${DEFAULT_LINUX_PROMPT}
  36     [Documentation]    Cleanup/Shutdown work that should be done at the completion of all
  37     ...    tests
  38     Log    Stop the test on the base edition
  39     Switch Connection    ${mininet_conn_id}
  40     Read
  41     Write    exit
  42     Read Until    ${prompt}
  43     Close Connection
  44
  45 Report Failure Due To Bug
  46     [Arguments]    ${number}    ${include_bug_in_tags}=True
  47     [Documentation]    Report that a test failed due to a known Bugzilla bug whose
  48     ...    number is provided as an argument.
  49     ...    Not FAILED (incl. SKIPPED) test are not reported.
  50     ...    This keyword must be used in the [Teardown] setting of the affected test
  51     ...    or as the first line of the test if FastFail module is not being
  52     ...    used. It reports the URL of the bug on console and also puts it
  53     ...    into the Robot log file.
  54     ${test_skipped}=    BuiltIn.Evaluate    len(re.findall('SKIPPED', """${TEST_MESSAGE}""")) > 0    modules=re
  55     BuiltIn.Return From Keyword If    ('${TEST_STATUS}' != 'FAIL') or ${test_skipped}
  56     Comment    Jira tickets are {PROJECT}-{NUMBER} while Bugzilla tickets are {NUMBER}
  57     ${match}    BuiltIn.Run Keyword And Return Status    Should Contain    ${number}    -
  58     ${bug_url}=    BuiltIn.Set Variable If    ${match}    https://jira.opendaylight.org/browse/${number}    https://bugs.opendaylight.org/show_bug.cgi?id=${number}
  59     ${msg}=    BuiltIn.Set_Variable    This test fails due to ${bug_url}
  60     ${newline}=    BuiltIn.Evaluate    chr(10)
  61     BuiltIn.Set Test Message    ${msg}${newline}${newline}${TEST_MESSAGE}
  62     BuiltIn.Log    ${msg}
  63     BuiltIn.Run Keyword If    "${include_bug_in_tags}"=="True"    Set Tags    ${bug_url}
  64
  65 Report_Failure_And_Point_To_Linked_Bugs
  66     [Documentation]    Report that a test failed and point to linked Bugzilla bug(s).
  67     ...    Linked bugs must contain the ${reference} inside comments (workaround
  68     ...    becasue of currently missing suitable field for external references and
  69     ...    not correctly working the CONTENT MATCHES filter).
  70     ...    Not FAILED (incl. SKIPPED) test are not reported.
  71     ...    This keyword must be used in the [Teardown] setting of the affected test
  72     ...    or as the first line of the test if FastFail module is not being
  73     ...    used. It reports the URL of the bug on console and also puts it
  74     ...    into the Robot log file.
  75     ${test_skipped}=    BuiltIn.Evaluate    len(re.findall('SKIPPED', """${TEST_MESSAGE}""")) > 0    modules=re
  76     BuiltIn.Return From Keyword If    ('${TEST_STATUS}' != 'FAIL') or ${test_skipped}
  77     ${newline}=    BuiltIn.Evaluate    chr(10)
  78     ${reference}=    String.Replace_String_Using_Regexp    ${SUITE_NAME}_${TEST_NAME}    [ /\.-]    _
  79     ${reference}=    String.Convert_To_Lowercase    ${reference}
  80     ${msg}=    BuiltIn.Set_Variable    ... click for list of related bugs or create a new one if needed (with the${newline}"${reference}"${newline}reference somewhere inside)
  81     ${bugs}=    BuiltIn.Set_Variable    "https://bugs.opendaylight.org/buglist.cgi?f1=cf_external_ref&o1=substring&v1=${reference}&order=bug_status"
  82     BuiltIn.Set Test Message    ${msg}${newline}${bugs}${newline}${newline}${TEST_MESSAGE}
  83     BuiltIn.Log    ${msg}${newline}${bugs}
  84
  85 Check Nodes Stats
  86     [Arguments]    ${node}    ${session}=session
  87     [Documentation]    A GET on the /node/${node} API is made and specific flow stat
  88     ...    strings are checked for existence.
  89     ${resp}    RequestsLibrary.Get Request    ${session}    ${OPERATIONAL_NODES_API}/node/${node}
  90     Should Be Equal As Strings    ${resp.status_code}    200
  91     Should Contain    ${resp.content}    flow-capable-node-connector-statistics
  92     Should Contain    ${resp.content}    flow-table-statistics
  93
  94 Check For Specific Number Of Elements At URI
  95     [Arguments]    ${uri}    ${element}    ${expected_count}    ${session}=session
  96     [Documentation]    A GET is made to the specified ${URI} and the specific count of a
  97     ...    given element is done (as supplied by ${element} and ${expected_count})
  98     ${resp}    RequestsLibrary.Get Request    ${session}    ${uri}
  99     Log    ${resp.content}
 100     Should Be Equal As Strings    ${resp.status_code}    200
 101     Should Contain X Times    ${resp.content}    ${element}    ${expected_count}
 102
 103 Log Content
 104     [Arguments]    ${resp_content}
 105     ${resp_json} =    BuiltIn.Run Keyword If    '''${resp_content}''' != '${EMPTY}'    RequestsLibrary.To Json    ${resp_content}    pretty_print=True
 106     ...    ELSE    BuiltIn.Set Variable    ${EMPTY}
 107     BuiltIn.Log    ${resp_json}
 108     [Return]    ${resp_json}
 109
 110 Check For Elements At URI
 111     [Arguments]    ${uri}    ${elements}    ${session}=session    ${pretty_print_json}=False
 112     [Documentation]    A GET is made at the supplied ${URI} and every item in the list of
 113     ...    ${elements} is verified to exist in the response
 114     ${resp}    RequestsLibrary.Get Request    ${session}    ${uri}
 115     BuiltIn.Run Keyword If    "${pretty_print_json}" == "True"    Log Content    ${resp.content}
 116     ...    ELSE    BuiltIn.Log    ${resp.content}
 117     Should Be Equal As Strings    ${resp.status_code}    200
 118     FOR    ${i}    IN    @{elements}
 119         Should Contain    ${resp.content}    ${i}
 120     END
 121
 122 Check For Elements Not At URI
 123     [Arguments]    ${uri}    ${elements}    ${session}=session    ${pretty_print_json}=False    ${check_for_null}=False
 124     [Documentation]    A GET is made at the supplied ${uri} and every item in the list of
 125     ...    ${elements} is verified to NOT exist in the response. If ${check_for_null} is True
 126     ...    return of 404 is treated as empty list. From Neon onwards, an empty list is always
 127     ...    returned as null, giving 404 on rest call.
 128     ${resp}    RequestsLibrary.Get Request    ${session}    ${uri}
 129     BuiltIn.Run Keyword If    "${pretty_print_json}" == "True"    Log Content    ${resp.content}
 130     ...    ELSE    BuiltIn.Log    ${resp.content}
 131     BuiltIn.Run Keyword If    "${check_for_null}" == "True"    Builtin.Return From Keyword If    ${resp.status_code} == 404
 132     Should Be Equal As Strings    ${resp.status_code}    200
 133     FOR    ${i}    IN    @{elements}
 134         Should Not Contain    ${resp.content}    ${i}
 135     END
 136
 137 Clean Mininet System
 138     [Arguments]    ${system}=${TOOLS_SYSTEM_IP}
 139     Run Command On Mininet    ${system}    sudo mn -c
 140     Run Command On Mininet    ${system}    sudo ps -elf | egrep 'usr/local/bin/mn' | egrep python | awk '{print "sudo kill -9",$4}' | sh
 141
 142 Clean Up Ovs
 143     [Arguments]    ${system}=${TOOLS_SYSTEM_IP}
 144     [Documentation]    Cleans up the OVS instance and remove any existing common known bridges.
 145     ${output}=    Run Command On Mininet    ${system}    sudo ovs-vsctl list-br
 146     Log    ${output}
 147     FOR    ${i}    IN    ${output}
 148         Run Command On Mininet    ${system}    sudo ovs-vsctl --if-exists del-br ${i}
 149     END
 150     Run Command On Mininet    ${system}    sudo ovs-vsctl del-manager
 151
 152 Extract Value From Content
 153     [Arguments]    ${content}    ${index}    ${strip}=nostrip
 154     [Documentation]    Will take the given response content and return the value at the given index as a string
 155     ${value}=    Get Json Value    ${content}    ${index}
 156     ${value}=    Convert To String    ${value}
 157     ${value}=    Run Keyword If    '${strip}' == 'strip'    Strip Quotes    ${value}
 158     [Return]    ${value}
 159
 160 Get Process ID Based On Regex On Remote System
 161     [Arguments]    ${system}    ${regex_string_to_match_on}    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${EMPTY}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${prompt_timeout}=30s
 162     [Documentation]    Uses ps to find a process that matches the supplied regex. Returns the PID of that process
 163     ...    The ${regex_string_to_match_on} should produce a unique process otherwise the PID returned may not be
 164     ...    the expected PID
 165     # doing the extra -v grep in this command to exclude the grep process itself from the output
 166     ${cmd}=    Set Variable    ps -elf | grep -v grep | grep ${regex_string_to_match_on} | awk '{print $4}'
 167     ${output}=    Run Command On Remote System    ${system}    ${cmd}    user=${user}    password=${password}    prompt=${prompt}
 168     ...    prompt_timeout=${prompt_timeout}
 169     # ${output} contains the system prompt and all we want is the value of the number
 170     ${pid}=    Fetch From Left    ${output}    \r
 171     # TODO: Get Process * keywords have perhaps non-standard default credentials.
 172     # ...    Should there be * On Mininet and * On Controller specializations?
 173     [Return]    ${pid}
 174
 175 Get Process Thread Count On Remote System
 176     [Arguments]    ${system}    ${pid}    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${EMPTY}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${prompt_timeout}=30s
 177     [Documentation]    Executes the ps command to retrieve the lightweight process (aka thread) count.
 178     ${cmd}=    Set Variable    ps --no-headers -o nlwp ${pid}
 179     ${output}=    Run Command On Remote System    ${system}    ${cmd}    user=${user}    password=${password}    prompt=${prompt}
 180     ...    prompt_timeout=${prompt_timeout}
 181     # ${output} contains the system prompt and all we want is the value of the number
 182     ${thread_count}=    Fetch From Left    ${output}    \r
 183     [Return]    ${thread_count}
 184
 185 Strip Quotes
 186     [Arguments]    ${string_to_strip}
 187     [Documentation]    Will strip ALL quotes from given string and return the new string
 188     ${string_to_return}=    Replace String    ${string_to_strip}    "    \    count=-1
 189     [Return]    ${string_to_return}
 190
 191 Run Command On Remote System
 192     [Arguments]    ${system}    ${cmd}    ${user}=${DEFAULT_USER}    ${password}=${EMPTY}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${prompt_timeout}=${DEFAULT_TIMEOUT}
 193     ...    ${return_stdout}=True    ${return_stderr}=False
 194     [Documentation]    Reduces the common work of running a command on a remote system to a single higher level
 195     ...    robot keyword, taking care to log in with a public key and. The command given is written and the return value
 196     ...    depends on the passed argument values of return_stdout (default: True) and return_stderr (default: False).
 197     ...    At least one should be True, or the keyword will exit and FAIL. If both are True, the resulting return value
 198     ...    will be a two element list containing both. Otherwise the resulting return value is a string.
 199     ...    No test conditions are checked.
 200     Run Keyword If    "${return_stdout}"!="True" and "${return_stderr}"!="True"    Fail    At least one of {return_stdout} or {return_stderr} args should be set to True
 201     ${current_ssh_connection}=    SSHLibrary.Get Connection
 202     BuiltIn.Log    Attempting to execute command "${cmd}" on remote system "${system}" by user "${user}" with keyfile pass "${keyfile_pass}" and prompt "${prompt}" and password "${password}"
 203     ${conn_id}=    SSHLibrary.Open Connection    ${system}    prompt=${prompt}    timeout=${prompt_timeout}
 204     SSHKeywords.Flexible SSH Login    ${user}    ${password}
 205     ${stdout}    ${stderr}    SSHLibrary.Execute Command    ${cmd}    return_stderr=True
 206     SSHLibrary.Close Connection
 207     Log    ${stderr}
 208     Run Keyword If    "${return_stdout}"!="True"    Return From Keyword    ${stderr}
 209     Run Keyword If    "${return_stderr}"!="True"    Return From Keyword    ${stdout}
 210     [Teardown]    SSHKeywords.Restore_Current_SSH_Connection_From_Index    ${current_ssh_connection.index}
 211     [Return]    ${stdout}    ${stderr}
 212
 213 Run Command On Remote System And Log
 214     [Arguments]    ${system}    ${cmd}    ${user}=${DEFAULT_USER}    ${password}=${EMPTY}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${prompt_timeout}=${DEFAULT_TIMEOUT}
 215     [Documentation]    Reduces the common work of running a command on a remote system to a single higher level
 216     ...    robot keyword, taking care to log in with a public key and. The command given is written
 217     ...    and the output returned. No test conditions are checked.
 218     ${output} =    Run Command On Remote System    ${system}    ${cmd}    ${user}    ${password}    ${prompt}
 219     ...    ${prompt_timeout}
 220     Log    ${output}
 221     [Return]    ${output}
 222
 223 Run Command On Mininet
 224     [Arguments]    ${system}=${TOOLS_SYSTEM_IP}    ${cmd}=echo    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${TOOLS_SYSTEM_PASSWORD}    ${prompt}=${TOOLS_SYSTEM_PROMPT}
 225     [Documentation]    Call Run Comand On Remote System, but with default values suitable for Mininet machine.
 226     BuiltIn.Run Keyword And Return    Run Command On Remote System    ${system}    ${cmd}    ${user}    ${password}    prompt=${prompt}
 227
 228 Run Command On Controller
 229     [Arguments]    ${system}=${ODL_SYSTEM_IP}    ${cmd}=echo    ${user}=${ODL_SYSTEM_USER}    ${password}=${ODL_SYSTEM_PASSWORD}    ${prompt}=${ODL_SYSTEM_PROMPT}
 230     [Documentation]    Call Run Comand On Remote System, but with default values suitable for Controller machine.
 231     BuiltIn.Run Keyword And Return    Run Command On Remote System    ${system}    ${cmd}    ${user}    ${password}    prompt=${prompt}
 232
 233 Run Command On Existing Connection
 234     [Arguments]    ${conn_id}=${EMPTY}    ${cmd}=echo    ${return_stdout}=True    ${return_stderr}=False
 235     [Documentation]    Switch to and run command on an already existing SSH connection and switch back
 236     Run Keyword If    "${return_stdout}"!="True" and "${return_stderr}"!="True"    Fail    At least one of {return_stdout} or {return_stderr} args should be set to True
 237     ${current_ssh_connection}=    SSHLibrary.Get Connection
 238     BuiltIn.Log    Attempting to execute command "${cmd}" on existing connection "${conn_id}
 239     SSHLibrary.Switch Connection    ${conn_id}
 240     ${stdout}    ${stderr}    SSHLibrary.Execute Command    ${cmd}    return_stderr=True
 241     Log    ${stderr}
 242     Run Keyword If    "${return_stdout}"!="True"    Return From Keyword    ${stderr}
 243     Run Keyword If    "${return_stderr}"!="True"    Return From Keyword    ${stdout}
 244     [Teardown]    SSHKeywords.Restore_Current_SSH_Connection_From_Index    ${current_ssh_connection.index}
 245     [Return]    ${stdout}    ${stderr}
 246
 247 Verify File Exists On Remote System
 248     [Arguments]    ${system}    ${file}    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${TOOLS_SYSTEM_PASSWORD}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${prompt_timeout}=5s
 249     [Documentation]    Will create connection with public key and will PASS if the given ${file} exists,
 250     ...    otherwise will FAIL
 251     ${conn_id}=    Open Connection    ${system}    prompt=${prompt}    timeout=${prompt_timeout}
 252     SSHKeywords.Flexible SSH Login    ${user}    ${password}
 253     SSHLibrary.File Should Exist    ${file}
 254     Close Connection
 255
 256 Check Karaf Log File Does Not Have Messages
 257     [Arguments]    ${ip}    ${message}    ${user}=${ODL_SYSTEM_USER}    ${password}=${ODL_SYSTEM_PASSWORD}    ${prompt}=${ODL_SYSTEM_PROMPT}    ${log_file}=${WORKSPACE}/${BUNDLEFOLDER}/data/log/karaf.log
 258     [Documentation]    Fails if the provided ${message} is found in the karaf.log file. Uses grep to search. The
 259     ...    karaf.log file can be overridden with ${log_file} to be any file on the given system @ ${ip}
 260     ${output}=    Run Command On Controller    ${ip}    grep -c '${message}' ${log_file}    user=${user}    password=${password}    prompt=${prompt}
 261     Should Be Equal As Strings    ${output}    0
 262
 263 Verify Controller Is Not Dead
 264     [Arguments]    ${controller_ip}=${ODL_SYSTEM_IP}
 265     [Documentation]    Will execute any tests to verify the controller is not dead. Some checks are
 266     ...    Out Of Memory Execptions.
 267     Check Karaf Log File Does Not Have Messages    ${controller_ip}    java.lang.OutOfMemoryError
 268     # TODO: Should Verify Controller * keywords also accept user, password, prompt and karaf_log arguments?
 269
 270 Verify Controller Has No Null Pointer Exceptions
 271     [Arguments]    ${controller_ip}=${ODL_SYSTEM_IP}
 272     [Documentation]    Will execute any tests to verify the controller is not having any null pointer eceptions.
 273     Check Karaf Log File Does Not Have Messages    ${controller_ip}    java.lang.NullPointerException
 274
 275 Get Epoch Time
 276     [Arguments]    ${time}
 277     [Documentation]    Get the Epoc time from MM/DD/YYYY HH:MM:SS
 278     ${epoch_time}=    Convert Date    ${time}    epoch    exclude_milles=True    date_format=%m/%d/%Y %H:%M:%S
 279     ${epoch_time}=    Convert To Integer    ${epoch_time}
 280     [Return]    ${epoch_time}
 281
 282 Remove Space on String
 283     [Arguments]    ${str}    ${count}=-1
 284     [Documentation]    Remove the empty space from given string.count is optional,if its given
 285     ...    that many occurence of space will be removed from left
 286     ${x}=    Convert To String    ${str}
 287     ${x}=    Replace String    ${str}    ${SPACE}    ${EMPTY}    count=${count}
 288     [Return]    ${x}
 289
 290 Split Value from String
 291     [Arguments]    ${str}    ${splitter}
 292     [Documentation]    Split the String based on given splitter and return as list
 293     @{x}=    Split String    ${str}    ${splitter}
 294     [Return]    @{x}
 295
 296 Concatenate the String
 297     [Arguments]    ${str1}    ${str2}
 298     [Documentation]    Catenate the two non-string objects and return as String
 299     ${str1}=    Convert to String    ${str1}
 300     ${str2}=    Convert to String    ${str2}
 301     ${output}=    Catenate    ${str1}    ${str2}
 302     [Return]    ${output}
 303
 304 Post Elements To URI
 305     [Arguments]    ${rest_uri}    ${data}    ${headers}=${headers}    ${session}=session
 306     [Documentation]    Perform a POST rest operation, using the URL and data provided
 307     ${resp} =    RequestsLibrary.Post Request    ${session}    ${rest_uri}    data=${data}    headers=${headers}
 308     Log    ${resp.content}
 309     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
 310
 311 Remove All Elements At URI
 312     [Arguments]    ${uri}    ${session}=session
 313     ${resp}    RequestsLibrary.Delete Request    ${session}    ${uri}
 314     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
 315
 316 Remove All Elements At URI And Verify
 317     [Arguments]    ${uri}    ${session}=session
 318     ${resp}    RequestsLibrary.Delete Request    ${session}    ${uri}
 319     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
 320     ${resp}    RequestsLibrary.Get Request    ${session}    ${uri}
 321     Should Be Equal As Strings    ${resp.status_code}    404
 322
 323 Remove All Elements If Exist
 324     [Arguments]    ${uri}    ${session}=session
 325     [Documentation]    Delete all elements from an URI if the configuration was not empty
 326     ${resp}    RequestsLibrary.Get Request    ${session}    ${uri}
 327     Run Keyword If    '${resp.status_code}'!='404'    Remove All Elements At URI    ${uri}    ${session}
 328
 329 Add Elements To URI From File
 330     [Arguments]    ${dest_uri}    ${data_file}    ${headers}=${headers}    ${session}=session
 331     [Documentation]    Put data from a file to a URI
 332     ${body}    OperatingSystem.Get File    ${data_file}
 333     ${resp}    RequestsLibrary.Put Request    ${session}    ${dest_uri}    data=${body}    headers=${headers}
 334     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
 335
 336 Add Elements To URI From File And Verify
 337     [Arguments]    ${dest_uri}    ${data_file}    ${headers}=${headers}    ${session}=session
 338     [Documentation]    Put data from a file to a URI and verify the HTTP response
 339     ${body}    OperatingSystem.Get File    ${data_file}
 340     Add Elements to URI And Verify    ${dest_uri}    ${body}    ${headers}    ${session}
 341
 342 Add Elements To URI And Verify
 343     [Arguments]    ${dest_uri}    ${data}    ${headers}=${headers}    ${session}=session
 344     [Documentation]    Put data to a URI and verify the HTTP response
 345     ${resp}    RequestsLibrary.Put Request    ${session}    ${dest_uri}    ${data}    headers=${headers}
 346     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
 347     ${resp}    RequestsLibrary.Get Request    ${session}    ${dest_uri}
 348     Should Not Be Equal    ${resp.status_code}    404
 349
 350 Add Elements To URI From File And Check Validation Error
 351     [Arguments]    ${dest_uri}    ${data_file}    ${headers}=${headers}    ${session}=session
 352     [Documentation]    Shorthand for PUTting data from file and expecting status code 400.
 353     BuiltIn.Comment    TODO: Does this have any benefits, considering TemplatedRequests can also do this in one line?
 354     ${body}    OperatingSystem.Get File    ${data_file}
 355     ${resp}    RequestsLibrary.Put Request    ${session}    ${dest_uri}    data=${body}    headers=${headers}
 356     Should Contain    ${DATA_VALIDATION_ERROR}    ${resp.status_code}
 357
 358 Add Elements To URI From File And Check Server Error
 359     [Arguments]    ${dest_uri}    ${data_file}    ${headers}=${headers}    ${session}=session
 360     [Documentation]    Shorthand for PUTting data from file and expecting status code 500.
 361     ...    Consider opening a Bug against ODL, as in most test cases, 400 is the http code to expect.
 362     BuiltIn.Comment    TODO: Does this have any benefits, considering TemplatedRequests can also do this in one line?
 363     ${body}    OperatingSystem.Get File    ${data_file}
 364     ${resp}    RequestsLibrary.Put Request    ${session}    ${dest_uri}    data=${body}    headers=${headers}
 365     Should Contain    ${INTERNAL_SERVER_ERROR}    ${resp.status_code}
 366
 367 Post Elements To URI From File
 368     [Arguments]    ${dest_uri}    ${data_file}    ${headers}=${headers}    ${session}=session
 369     ${body}    OperatingSystem.Get File    ${data_file}
 370     ${resp}    RequestsLibrary.Post Request    ${session}    ${dest_uri}    data=${body}    headers=${headers}
 371     Should Contain    ${ALLOWED_STATUS_CODES}    ${resp.status_code}
 372
 373 Run Process With Logging And Status Check
 374     [Arguments]    @{proc_args}
 375     [Documentation]    Execute an OS command, log STDOUT and STDERR output and check exit code to be 0
 376     ${result}=    Run Process    @{proc_args}
 377     Log    ${result.stdout}
 378     Log    ${result.stderr}
 379     Should Be Equal As Integers    ${result.rc}    0
 380     [Return]    ${result}
 381
 382 Get Data From URI
 383     [Arguments]    ${session}    ${uri}    ${headers}=${NONE}
 384     [Documentation]    Issue a GET request and return the data obtained or on error log the error and fail.
 385     ...    Issues a GET request for ${uri} in ${session} using headers from
 386     ...    ${headers}. If the request returns a HTTP error, fails. Otherwise
 387     ...    returns the data obtained by the request.
 388     ${response}=    RequestsLibrary.Get Request    ${session}    ${uri}    ${headers}
 389     Builtin.Return_From_Keyword_If    ${response.status_code} == 200    ${response.text}
 390     Builtin.Log    ${response.text}
 391     Builtin.Fail    The request failed with code ${response.status_code}
 392
 393 Get URI And Verify
 394     [Arguments]    ${uri}    ${session}=session    ${headers}=${NONE}
 395     [Documentation]    Issue a GET request and verify a successfull HTTP return.
 396     ...    Issues a GET request for ${uri} in ${session} using headers from ${headers}.
 397     ${response} =    RequestsLibrary.Get Request    ${session}    ${uri}    ${headers}
 398     Builtin.Log    ${response.status_code}
 399     Should Contain    ${ALLOWED_STATUS_CODES}    ${response.status_code}
 400
 401 No Content From URI
 402     [Arguments]    ${session}    ${uri}    ${headers}=${NONE}
 403     [Documentation]    Issue a GET request and return on error 404 (No content) or will fail and log the content.
 404     ...    Issues a GET request for ${uri} in ${session} using headers from
 405     ...    ${headers}. If the request returns a HTTP error, fails. Otherwise
 406     ...    returns the data obtained by the request.
 407     ${response}=    RequestsLibrary.Get Request    ${session}    ${uri}    ${headers}
 408     Builtin.Return_From_Keyword_If    ${response.status_code} == 404
 409     Builtin.Log    ${response.text}
 410     Builtin.Fail    The request failed with code ${response.status_code}
 411
 412 Get Index From List Of Dictionaries
 413     [Arguments]    ${dictionary_list}    ${key}    ${value}
 414     [Documentation]    Extract index for the dictionary in a list that contains a key-value pair. Returns -1 if key-value is not found.
 415     ${length}=    Get Length    ${dictionary_list}
 416     ${index}=    Set Variable    -1
 417     FOR    ${i}    IN RANGE    ${length}
 418         ${dictionary}=    Get From List    ${dictionary_list}    ${i}
 419         Run Keyword If    """&{dictionary}[${key}]""" == """${value}"""    Set Test Variable    ${index}    ${i}
 420     END
 421     [Return]    ${index}
 422
 423 Check Item Occurrence
 424     [Arguments]    ${string}    ${dictionary_item_occurrence}
 425     [Documentation]    Check string for occurrences of items expressed in a list of dictionaries {item=occurrences}. 0 occurences means item is not present.
 426     FOR    ${item}    IN    @{dictionary_item_occurrence}
 427         Should Contain X Times    ${string}    ${item}    &{dictionary_item_occurrence}[${item}]
 428     END
 429
 430 Post Log Check
 431     [Arguments]    ${uri}    ${body}    ${session}=session    ${status_codes}=200
 432     [Documentation]    Post body to ${uri}, log response content, and check status
 433     ${resp}=    RequestsLibrary.Post Request    ${session}    ${uri}    ${body}
 434     Log    ${resp.content}
 435     TemplatedRequests.Check Status Code    ${resp}    ${status_codes}
 436     [Return]    ${resp}
 437
 438 Get Log File Name
 439     [Arguments]    ${testtool}    ${testcase}=${EMPTY}
 440     [Documentation]    Get the name of the suite sanitized to be usable as a part of filename.
 441     ...    These names are used to constructs names of the log files produced
 442     ...    by the testing tools so two suites using a tool wont overwrite the
 443     ...    log files if they happen to run in one job.
 444     ${name}=    BuiltIn.Evaluate    """${SUITE_NAME}""".replace(" ","-").replace("/","-").replace(".","-")
 445     ${suffix}=    BuiltIn.Set_Variable_If    '${testcase}' != ''    --${testcase}    ${EMPTY}
 446     ${date} =    DateTime.Get Current Date
 447     ${timestamp} =    DateTime.Convert Date    ${date}    epoch
 448     [Return]    ${testtool}--${name}${suffix}.${timestamp}.log
 449
 450 Set_User_Configurable_Variable_Default
 451     [Arguments]    ${name}    ${value}
 452     [Documentation]    Set a default value for an user configurable variable.
 453     ...    This keyword is needed if your default value is calculated using
 454     ...    a complex expression which needs BuiltIn.Evaluate or even more
 455     ...    complex keywords. It sets the variable ${name} (the name of the
 456     ...    variable MUST be specified WITHOUT the ${} syntactic sugar due
 457     ...    to limitations of Robot Framework) to ${value} but only if the
 458     ...    variable ${name} was not set previously. This keyword is intended
 459     ...    for user configurable variables which are supposed to be set only
 460     ...    with pybot -v; calling this keyword on a variable that was already
 461     ...    set by another keyword will silently turn the call into a NOP and
 462     ...    thus is a bug in the suite or resource trying to call this
 463     ...    keyword.
 464     # TODO: Figure out how to make the ${value} evaluation "lazy" (meaning
 465     #    evaluating it only when the user did not set anything and thus the
 466     #    default is needed). This might be needed to avoid potentially costly
 467     #    keyword invocations when they are not needed. Currently no need for
 468     #    this was identified, thus leaving it here as a TODO. Based on
 469     #    comments the best approach would be to create another keyword that
 470     #    expects a ScalarClosure in the place of ${value} and calls the
 471     #    closure to get the value but only if the value is needed).
 472     #    The best idea how to implement this "laziness" would be to have the
 473     #    used to define another keyword that will be responsible for getting
 474     #    the default value and then passing the name of this getter keyword
 475     #    to this keyword. Then this keyword would call the getter (to obtain
 476     #    the expensive default value) only if it discovers that this value
 477     #    is really needed (because the variable is not set yet).
 478     # TODO: Is the above TODO really necessary? Right now we don't have any
 479     #    examples of "expensive default values" where to obtain the default
 480     #    value is so expensive on resources (e.g. need to SSH somewhere to
 481     #    check something) that we would want to skip the calculation if the
 482     #    variable for which it is needed has a value already provided by the
 483     #    user using "pybot -v" or something. One example would be
 484     #    JAVA_HOME if it would be designed as user-configurable variable
 485     #    (currently it is not; users can specify "use jdk7" or "use jdk8"
 486     #    but not "use the jdk over there"; and there actually is no JAVA_HOME
 487     #    present in the resource, rather the Java invocation command uses the
 488     #    Java invocation with a full path). The default value of JAVA_HOME
 489     #    has to be obtained by issuing commands on the SSH connection where
 490     #    the resulting Java invocation command will be used (to check
 491     #    multiple candidate paths until one that fits is found) and we could
 492     #    skip all this checking if a JAVA_HOME was supplied by the user using
 493     #    "pybot -v".
 494     ${value}=    BuiltIn.Get_Variable_Value    \${${name}}    ${value}
 495     BuiltIn.Set_Suite_Variable    \${${name}}    ${value}
 496
 497 Convert_To_Minutes
 498     [Arguments]    ${time}
 499     [Documentation]    Convert a Robot time string to an integer expressing the time in minutes, rounded up
 500     ...    This is a wrapper around DateTime.Convert_Time which does not
 501     ...    provide this functionality directly nor is even able to produce
 502     ...    an integer directly. It is needed for RestPerfClient which
 503     ...    cannot accept floats for its --timeout parameter and interprets
 504     ...    the value supplied in this parameter in minutes.
 505     ${seconds}=    DateTime.Convert_Time    ${time}    result_format=number
 506     ${minutes}=    BuiltIn.Evaluate    int(math.ceil(${seconds}/60.0))    modules=math
 507     [Return]    ${minutes}
 508
 509 Write Commands Until Expected Prompt
 510     [Arguments]    ${cmd}    ${prompt}    ${timeout}=${DEFAULT_TIMEOUT}
 511     [Documentation]    quick wrapper for Write and Read Until Prompt Keywords to make test cases more readable
 512     BuiltIn.Log    cmd: ${cmd}
 513     SSHLibrary.Set Client Configuration    timeout=${timeout}
 514     SSHLibrary.Read
 515     SSHLibrary.Write    ${cmd}
 516     ${output}=    SSHLibrary.Read Until    ${prompt}
 517     [Return]    ${output}
 518
 519 Write Commands Until Expected Regexp
 520     [Arguments]    ${cmd}    ${regexp}    ${timeout}=${DEFAULT_TIMEOUT}
 521     [Documentation]    quick wrapper for Write and Read Until Prompt Keywords to make test cases more readable
 522     BuiltIn.Log    cmd: ${cmd}
 523     SSHLibrary.Set Client Configuration    timeout=${timeout}
 524     SSHLibrary.Read
 525     SSHLibrary.Write    ${cmd}
 526     ${output}=    SSHLibrary.Read Until Regexp    ${regexp}
 527     [Return]    ${output}
 528
 529 Install Package On Ubuntu System
 530     [Arguments]    ${package_name}    ${system}=${TOOLS_SYSTEM_IP}    ${user}=${TOOLS_SYSTEM_USER}    ${password}=${TOOLS_SYSTEM_PASSWORD}    ${prompt}=${DEFAULT_LINUX_PROMPT}    ${prompt_timeout}=30s
 531     [Documentation]    Keyword to install packages for testing to Ubuntu Mininet VM
 532     Log    Keyword to install package to Mininet Ubuntu VM
 533     Open Connection    ${system}    prompt=${prompt}    timeout=${prompt_timeout}
 534     SSHKeywords.Flexible Mininet Login    user=${user}    password=${password}
 535     Write    sudo apt-get install -y ${package_name}
 536     Read Until    ${prompt}
 537
 538 Json Parse From String
 539     [Arguments]    ${plain_string_with_json}
 540     [Documentation]    Parse given plain string into json (dictionary)
 541     ${json_data}    Evaluate    json.loads('''${plain_string_with_json}''')    json
 542     [Return]    ${json_data}
 543
 544 Json Parse From File
 545     [Arguments]    ${json_file}
 546     [Documentation]    Parse given file content into json (dictionary)
 547     ${json_plain_string}    OperatingSystem.Get file    ${json_file}
 548     ${json_data}    Json Parse From String    ${json_plain_string}
 549     [Return]    ${json_data}
 550
 551 Modify Iptables On Remote System
 552     [Arguments]    ${remote_system_ip}    ${iptables_rule}    ${user}=${ODL_SYSTEM_USER}    ${password}=${ODL_SYSTEM_PASSWORD}    ${prompt}=${ODL_SYSTEM_PROMPT}
 553     [Documentation]    Wrapper keyword to run iptables with any given ${iptables_rule} string on the remote system given
 554     ...    by ${remote_system_ip}. The iptables listing will be output before and after the command is run
 555     ${list_iptables_command} =    BuiltIn.Set Variable    sudo /sbin/iptables -L -n
 556     ${output} =    Utils.Run Command On Remote System    ${remote_system_ip}    ${list_iptables_command}    ${user}    ${password}    prompt=${prompt}
 557     BuiltIn.Log    ${output}
 558     Utils.Run Command On Remote System    ${remote_system_ip}    sudo /sbin/iptables ${iptables_rule}    ${user}    ${password}    prompt=${prompt}
 559     ${output} =    Utils.Run Command On Remote System    ${remote_system_ip}    ${list_iptables_command}    ${user}    ${password}    prompt=${prompt}
 560     BuiltIn.Log    ${output}
 561
 562 Get_Sysstat_Statistics
 563     [Arguments]    ${ip_address}=${ODL_SYSTEM_IP}
 564     [Documentation]    Store current connection index, open new connection to ip_address. Run command to get sysstat results from script,
 565     ...    which is running on all children nodes. Returns cpu, network, memory usage statistics from the node for each 10 minutes
 566     ...    that node was running. Used for debug purposes. Returns whole output of sysstat.
 567     ${current_connection}=    SSHLibrary.Get_Connection
 568     SSHKeywords.Open_Connection_To_ODL_System    ${ip_address}
 569     SSHLibrary.Write    sar -A -f /var/log/sa/sa*
 570     ${output}    SSHLibrary.Read_Until_Prompt
 571     BuiltIn.Log    ${output}
 572     SSHLibrary.Close_Connection
 573     [Teardown]    SSHKeywords.Restore_Current_SSH_Connection_From_Index    ${current_connection.index}
 574     [Return]    ${output}
 575
 576 Check Diagstatus
 577     [Arguments]    ${ip_address}=${ODL_SYSTEM_IP}    ${check_status}=True    ${expected_status}=${200}
 578     [Documentation]    GET http://${ip_address}:${RESTCONFPORT}/diagstatus and return the response. ${check_status}
 579     ...    and ${expected_status_code} can be used to ignore the status code, or validate any status code value.
 580     ...    By default, this keyword will pass if the status code returned is 200, and fail otherwise.
 581     RequestsLibrary.Create Session    diagstatus_session    http://${ip_address}:${RESTCONFPORT}
 582     ${resp}    RequestsLibrary.Get Request    diagstatus_session    /diagstatus
 583     Run Keyword If    "${check_status}" == "True"    BuiltIn.Should Be Equal As Strings    ${resp.status_code}    ${expected_status}
 584     [Return]    ${resp}
 585
 586 Download File On Openstack Node
 587     [Arguments]    ${conn_id}    ${save_file_name}    ${url}
 588     [Documentation]    Download a file from web to the node. the input will be a session ID with established SSH connection.
 589     SSHLibrary.Switch Connection    ${conn_id}
 590     Utils.Write Commands Until Expected Prompt    wget -O /tmp/${save_file_name} ${url}    ${DEFAULT_LINUX_PROMPT_STRICT}