csit/libraries/NexusKeywords.robot

   1 *** Settings ***
   2 Documentation     Nexus repository access keywords, and supporting Java and Maven handling.
   3 ...
   4 ...               Copyright (c) 2015,2016 Cisco Systems, Inc. and others. All rights reserved.
   5 ...
   6 ...               This program and the accompanying materials are made available under the
   7 ...               terms of the Eclipse Public License v1.0 which accompanies this distribution,
   8 ...               and is available at http://www.eclipse.org/legal/epl-v10.html
   9 ...
  10 ...
  11 ...               This library encapsulates a bunch of somewhat complex and commonly used
  12 ...               Nexus operations into reusable keywords to make writing test suites easier.
  13 ...
  14 ...               Currently, Java version detection is incorporated so that Java tools can be run reliably.
  15 ...               Also, suport for installing and running Maven is added, as that needs the Java detection.
  16 ...               TODO: Move Java detection and Maven to a separate Resource, or rename this Resource.
  17 Library           Collections
  18 Library           OperatingSystem
  19 Library           SSHLibrary
  20 Library           String
  21 Library           XML
  22 Library           Collections
  23 Library           RequestsLibrary
  24 Resource          ${CURDIR}/CompareStream.robot
  25 Resource          ${CURDIR}/SSHKeywords.robot
  26 Resource          ${CURDIR}/Utils.robot
  27
  28 *** Variables ***
  29 &{COMPONENT_MAPPING}    netconf=netconf-impl    bgpcep=pcep-impl    carpeople=clustering-it-model    yangtools=yang-data-impl    bindingv1=mdsal-binding-generator-impl    odl-micro=odlmicro-impl
  30 @{RELEASE_INTEGRATED_COMPONENTS}    mdsal    odlparent    yangtools    carpeople    netconf    bgpcep
  31 ${JDKVERSION}     None
  32 ${JAVA_8_HOME_CENTOS}    /usr/lib/jvm/java-1.8.0
  33 ${JAVA_8_HOME_UBUNTU}    /usr/lib/jvm/java-8-openjdk-amd64
  34 ${JAVA_11_HOME_CENTOS}    /usr/lib/jvm/java-11-openjdk
  35 ${JAVA_11_HOME_UBUNTU}    /usr/lib/jvm/java-11-openjdk-amd64
  36 ${JAVA_17_HOME_CENTOS}    /usr/lib/jvm/java-17-openjdk
  37 ${JAVA_17_HOME_UBUNTU}    /usr/lib/jvm/java-17-openjdk-amd64
  38 ${JAVA_OPTIONS}    -Xmx2560m    # Note that '-Xmx=3g' is wrong syntax. Also 3GB heap may not fit in 4GB RAM.
  39 ${MAVEN_DEFAULT_OUTPUT_FILENAME}    default_maven.log
  40 ${MAVEN_OPTIONS}    -Pq -Djenkins
  41 ${MAVEN_REPOSITORY_PATH}    /tmp/r
  42 ${MAVEN_SETTINGS_URL}    https://raw.githubusercontent.com/opendaylight/odlparent/master/settings.xml
  43 ${MAVEN_VERSION}    3.3.9
  44 ${NEXUS_FALLBACK_URL}    ${NEXUSURL_PREFIX}/content/repositories/opendaylight.snapshot
  45 ${NEXUS_RELEASE_BASE_URL}    https://nexus.opendaylight.org/content/repositories/opendaylight.release
  46 ${NEXUS_RELEASES_URL}    ${NEXUS_RELEASE_BASE_URL}/org/opendaylight/integration/karaf
  47
  48 *** Keywords ***
  49 Initialize_Artifact_Deployment_And_Usage
  50     [Arguments]    ${tools_system_connect}=True
  51     [Documentation]    Places search utility to ODL system, which will be needed for version detection.
  52     ...    By default also initialize a SSH connection to Tools system,
  53     ...    as following Keywords assume a working connection towards target system.
  54     # Connect to the ODL machine.
  55     ${odl} =    SSHKeywords.Open_Connection_To_ODL_System
  56     # Deploy the search tool.
  57     SSHLibrary.Put_File    ${CURDIR}/../../tools/deployment/search.sh
  58     SSHLibrary.Close_Connection
  59     # Optionally connect to the Tools System machine.
  60     BuiltIn.Return_From_Keyword_If    not (${tools_system_connect})    # the argument may be a convoluted Python expression
  61     SSHKeywords.Open_Connection_To_Tools_System
  62
  63 NexusKeywords__Get_Items_To_Look_At
  64     [Arguments]    ${component}
  65     [Documentation]    Get a list of items that might contain the version number that we are looking for.
  66     ...
  67     ...    &{COMPONENT_MAPPING} is the centralized place to maintain the mapping
  68     ...    from a stream independent component nickname to the list of artifact names to search for.
  69     Collections.Dictionary_Should_Contain_Key    ${COMPONENT_MAPPING}    ${component}    Component not supported by NexusKeywords version detection: ${component}
  70     BuiltIn.Run_Keyword_And_Return    Collections.Get_From_Dictionary    ${COMPONENT_MAPPING}    ${component}
  71
  72 NexusKeywords__Detect_Version_To_Pull
  73     [Arguments]    ${component}
  74     [Documentation]    Determine the exact Nexus directory to be used as a source for a particular test tool
  75     ...    Figure out what version of the tool needs to be pulled out of the
  76     ...    Nexus by looking at the version directory of the subsystem from
  77     ...    which the tool is being pulled. This code is REALLY UGLY but there
  78     ...    is no way around it until the bug
  79     ...    https://bugs.opendaylight.org/show_bug.cgi?id=5206 gets fixed.
  80     ...    I also don't want to depend on maven-metadata-local.xml and other
  81     ...    bits and pieces of ODL distribution which are not required for ODL
  82     ...    to function properly.
  83     ${itemlist} =    NexusKeywords__Get_Items_To_Look_At    ${component}
  84     ${current_ssh_connection} =    SSHLibrary.Get Connection
  85     SSHKeywords.Open_Connection_To_ODL_System
  86     ${version}    ${result} =    SSHLibrary.Execute_Command    sh search.sh ${WORKSPACE}/${BUNDLEFOLDER}/system ${itemlist}    return_rc=True
  87     SSHLibrary.Close_Connection
  88     SSHKeywords.Restore Current SSH Connection From Index    ${current_ssh_connection.index}
  89     BuiltIn.Log    ${version}
  90     BuiltIn.Run_Keyword_If    ${result}!=0    BuiltIn.Fail    Component "${component}": searching for "${itemlist}" found no version, cannot locate test tool.
  91     ${version}    ${location} =    String.Split_String    ${version}    max_split=1
  92     [Return]    ${version}    ${location}
  93
  94 Deploy_From_Url
  95     [Arguments]    ${url}
  96     [Documentation]    On active SSH conenction execute download ${url} command, log output, check RC and return file name.
  97     ${filename} =    String.Fetch_From_Right    ${url}    /
  98     ${response}    ${result} =    SSHLibrary.Execute_Command    wget -q -N '${url}' 2>&1    return_rc=True
  99     BuiltIn.Log    ${response}
 100     BuiltIn.Run_Keyword_If    ${result} != 0    BuiltIn.Fail    File ${filename} could not be downloaded from ${url}
 101     [Return]    ${filename}
 102
 103 Deploy_Artifact
 104     [Arguments]    ${component}    ${artifact}    ${name_prefix}=${artifact}-    ${name_suffix}=-executable.jar    ${fallback_url}=${NEXUS_FALLBACK_URL}    ${explicit_url}=${EMPTY}    ${build_version}=${EMPTY}    ${build_location}=${EMPTY}
 105     [Documentation]    Deploy the specified artifact from Nexus to the cwd of the machine to which the active SSHLibrary connection points.
 106     ...    ${component} is a name part of an artifact present in system/ of ODl installation with the same version as ${artifact} should have.
 107     ...    Must have ${BUNDLE_URL} variable set to the URL from which the
 108     ...    tested ODL distribution was downloaded and this place must be
 109     ...    inside a repository created by a standard distribution
 110     ...    construction job. If this is detected to ne be the case, fallback URL is used.
 111     ...    If ${explicit_url} is non-empty, Deploy_From_Utrl is called instead.
 112     ...    TODO: Allow deploying to a specific directory, we have SSHKeywords.Execute_Command_At_Cwd_Should_Pass now.
 113     BuiltIn.Run_Keyword_And_Return_If    """${explicit_url}""" != ""    Deploy_From_Url    ${explicit_url}
 114     ${urlbase} =    String.Fetch_From_Left    ${BUNDLE_URL}    /org/opendaylight
 115     # If the BUNDLE_URL points somewhere else (perhaps *patch-test* job in Jenkins),
 116     # ${urlbase} is the whole ${BUNDLE_URL}, in which case we use the ${fallback_url}
 117     # If we are working with a "release integrated" project, we always will want to look for
 118     # a released version, not in the snapshots
 119     ${urlbase} =    BuiltIn.Set_Variable_If    '${urlbase}' != '${BUNDLE_URL}'    ${urlbase}    ${fallback_url}
 120     CompareStream.Run_Keyword_If_At_Most_Magnesium    Collections.Remove_Values_From_List    ${RELEASE_INTEGRATED_COMPONENTS}    carpeople
 121     CompareStream.Run_Keyword_If_At_Most_Aluminium    Collections.Remove_Values_From_List    ${RELEASE_INTEGRATED_COMPONENTS}    netconf
 122     CompareStream.Run_Keyword_If_At_Most_Silicon    Collections.Remove_Values_From_List    ${RELEASE_INTEGRATED_COMPONENTS}    bgpcep
 123     ${version}    ${location} =    BuiltIn.Run_Keyword_If    '${build_version}'=='${EMPTY}'    NexusKeywords__Detect_Version_To_Pull    ${component}
 124     ...    ELSE    BuiltIn.Set_Variable    ${build_version}    ${build_location}
 125     BuiltIn.Run_Keyword_If    'SNAPSHOT' in '${version}'    Collections.Remove_Values_From_List    ${RELEASE_INTEGRATED_COMPONENTS}    netconf    bgpcep
 126     # check if the bundle url is pointing to a staging artifact
 127     # when we are pointing at a staged artifact we need to use the staging repo instead of release/snapshot artifacts
 128     ${is_staged} =    BuiltIn.Set_Variable_If    "opendaylight.release" not in '${urlbase}' and "opendaylight.snapshot" not in '${urlbase}'    "TRUE"    "FALSE"
 129     # if we have a staged artifact we need to use the urlbase given to us in the job params
 130     ${is_mri_component} =    BuiltIn.Set_Variable_If    '${component}' in ${RELEASE_INTEGRATED_COMPONENTS}    "TRUE"    "FALSE"
 131     ${urlbase} =    BuiltIn.Set_Variable_If    ${is_mri_component} == "TRUE" and ${is_staged} == "FALSE"    ${NEXUS_RELEASE_BASE_URL}    ${urlbase}
 132     # TODO: Use RequestsLibrary and String instead of curl and bash utilities?
 133     ${url} =    BuiltIn.Set_Variable    ${urlbase}/${location}/${artifact}/${version}
 134     # TODO: Review SSHKeywords for current best keywords to call.
 135     ${metadata} =    SSHKeywords.Execute_Command_Should_Pass    curl -L ${url}/maven-metadata.xml
 136     ${status}    ${namepart} =    BuiltIn.Run_Keyword_And_Ignore_Error    SSHKeywords.Execute_Command_Should_Pass    echo "${metadata}" | grep value | head -n 1 | cut -d '>' -f 2 | cut -d '<' -f 1    stderr_must_be_empty=${True}
 137     ${length} =    BuiltIn.Get_Length    ${namepart}
 138     ${namepart} =    BuiltIn.Set_Variable_If    "${status}" != "PASS" or ${length} == 0    ${version}    ${namepart}
 139     ${filename} =    BuiltIn.Set_Variable    ${name_prefix}${namepart}${name_suffix}
 140     BuiltIn.Log    ${filename}
 141     ${url} =    BuiltIn.Set_Variable    ${url}/${filename}
 142     ${response}    ${result} =    SSHLibrary.Execute_Command    wget -q -N '${url}' 2>&1    return_rc=True
 143     BuiltIn.Log    ${response}
 144     BuiltIn.Return_From_Keyword_If    ${result} == 0    ${filename}
 145     # staged autorelease for non-mri project might not contain the artifact we need so we need to fallback to grabbing it from the release repo
 146     ${release_url} =    String.Replace_String_Using_Regexp    ${url}    autorelease-[0-9]{4}    opendaylight.release
 147     ${response}    ${result} =    SSHLibrary.Execute_Command    wget -q -N '${release_url}' 2>&1    return_rc=True
 148     BuiltIn.Run_Keyword_If    ${result} != 0    BuiltIn.Fail    Artifact "${artifact}" in component "${component}" could not be downloaded from ${release_url} nor ${url}
 149     [Return]    ${filename}
 150
 151 Deploy_Test_Tool
 152     [Arguments]    ${component}    ${artifact}    ${suffix}=executable    ${fallback_url}=${NEXUS_FALLBACK_URL}    ${explicit_url}=${EMPTY}    ${build_version}=${EMPTY}    ${build_location}=${EMPTY}
 153     [Documentation]    Deploy a test tool.
 154     ...    The test tools have naming convention of the form
 155     ...    "<repository_url>/some/dir/somewhere/<tool-name>/<tool-name>-<version-tag>-${suffix}.jar"
 156     ...    where "<tool-name>" is the name of the tool and "<version-tag>" is
 157     ...    the version tag that is digged out of the maven metadata. This
 158     ...    keyword calculates ${name_prefix} and ${name_suffix} for
 159     ...    "Deploy_Artifact" and then calls "Deploy_Artifact" to do the real
 160     ...    work of deploying the artifact.
 161     ${name_prefix} =    BuiltIn.Set_Variable    ${artifact}-
 162     ${extension} =    BuiltIn.Set_Variable_If    '${component}'=='odl-micro'    tar    jar
 163     ${name_suffix} =    BuiltIn.Set_Variable_If    "${suffix}" != ""    -${suffix}.${extension}    .${extension}
 164     ${filename} =    Deploy_Artifact    ${component}    ${artifact}    ${name_prefix}    ${name_suffix}    ${fallback_url}
 165     ...    ${explicit_url}    ${build_version}    ${build_location}
 166     [Return]    ${filename}
 167
 168 Install_And_Start_Java_Artifact
 169     [Arguments]    ${component}    ${artifact}    ${suffix}=executable    ${tool_options}=${EMPTY}    ${java_options}=${EMPTY}    ${openjdk}=${JDKVERSION}
 170     ...    ${fallback_url}=${NEXUS_FALLBACK_URL}    ${explicit_url}=${EMPTY}
 171     [Documentation]    Deploy the artifact, assign name for log file, figure out java command, write the command to active SSH connection and return the log name.
 172     ...    This keyword does not examine whether the artifact was started successfully or whether is still running upon return.
 173     # TODO: Unify this keyword with what NexusKeywords.Install_And_Start_Testtool does.
 174     ${actual_java_options} =    BuiltIn.Set_Variable_If    """${java_options}""" != ""    ${java_options}    ${JAVA_OPTIONS}
 175     ${filename} =    Deploy_Test_Tool    ${component}    ${artifact}    ${suffix}    ${fallback_url}    ${explicit_url}
 176     ${command} =    Compose_Full_Java_Command    ${actual_java_options} -jar ${filename} ${tool_options}
 177     ${logfile} =    Utils.Get_Log_File_Name    ${artifact}
 178     SSHLibrary.Write    ${command} >${logfile} 2>&1
 179     [Return]    ${logfile}
 180
 181 Compose_Dilemma_Filepath
 182     [Arguments]    ${default_path}    ${specific_path}
 183     [Documentation]    Query active SSH connection, return specific path if it exists else default path.
 184     ${out}    ${rc} =    SSHLibrary.Execute_Command    ls -lA ${specific_path} 2>&1    return_rc=True
 185     BuiltIn.Return_From_Keyword_If    ${rc} == 0    ${specific_path}
 186     BuiltIn.Return_From_Keyword    ${default_path}
 187
 188 Compose_Base_Java_Command
 189     [Arguments]    ${openjdk}=${JDKVERSION}
 190     [Documentation]    Return string suitable for launching Java programs over SSHLibrary, depending on JRE version needed.
 191     ...    This requires that the SSH connection on which the command is going to be used is active as it is needed for querying files.
 192     ...    Commands composed for one SSH connection shall not be reused on other SSH connections as the two connections may have different Java setups.
 193     ...    Not directly related to Nexus, but versioned Java tools may need this.
 194     # Check whether the user set the override and return it if yes.
 195     BuiltIn.Run_Keyword_And_Return_If    """${openjdk}""" == "openjdk8"    Compose_Dilemma_Filepath    ${JAVA_8_HOME_CENTOS}/bin/java    ${JAVA_8_HOME_UBUNTU}/bin/java
 196     BuiltIn.Run_Keyword_And_Return_If    """${openjdk}""" == "openjdk11"    Compose_Dilemma_Filepath    ${JAVA_11_HOME_CENTOS}/bin/java    ${JAVA_11_HOME_UBUNTU}/bin/java
 197     BuiltIn.Run_Keyword_And_Return_If    """${openjdk}""" == "openjdk17"    Compose_Dilemma_Filepath    ${JAVA_17_HOME_CENTOS}/bin/java    ${JAVA_17_HOME_UBUNTU}/bin/java
 198     # Attempt to call plain "java" command directly. If it works, return it.
 199     ${out}    ${rc} =    SSHLibrary.Execute_Command    java -version 2>&1    return_rc=True
 200     BuiltIn.Return_From_Keyword_If    ${rc} == 0    java
 201     # Query the virtual machine for the JAVA_HOME environment variable and
 202     # use it to assemble a (hopefully) working command. If that worked out,
 203     # return the result.
 204     ${java} =    SSHLibrary.Execute_Command    echo $JAVA_HOME/bin/java 2>&1
 205     ${out}    ${rc} =    SSHLibrary.Execute_Command    ${java} -version 2>&1    return_rc=True
 206     BuiltIn.Return_From_Keyword_If    ${rc} == 0    ${java}
 207     # There are bizzare test environment setups where the (correct) JAVA_HOME
 208     # is set in the VM where Robot is running but not in the VM where the
 209     # tools are supposed to run (usually because these two are really one
 210     # and the same system and idiosyncracies of BASH prevent easy injection
 211     # of the JAVA_HOME environment variable into a place where connections
 212     # made by SSHLibrary would pick it up). So try to use that value to
 213     # create a java command and check that it works.
 214     ${JAVA_HOME} =    OperatingSystem.Get_Environment_Variable    JAVA_HOME    ${EMPTY}
 215     ${java} =    BuiltIn.Set_Variable_If    """${JAVA_HOME}"""!=""    ${JAVA_HOME}/bin/java    false
 216     ${out}    ${rc} =    SSHLibrary.Execute_Command    ${java} -version 2>&1    return_rc=True
 217     BuiltIn.Return_From_Keyword_If    ${rc} == 0    ${java}
 218     # Nothing works, most likely java is not installed at all on the target
 219     # machine or it is hopelesly lost. Bail out with a helpful message
 220     # telling the user how to make it accessible for the script.
 221     BuiltIn.Fail    Unable to find Java; specify \${JDKVERSION}, put it to your PATH or set JAVA_HOME environment variable.
 222
 223 Compose_Full_Java_Command
 224     [Arguments]    ${options}    ${openjdk}=${JDKVERSION}
 225     [Documentation]    Return full Bash command to run Java with given options.
 226     ...    This requires that the SSH connection on which the command is going to be used is active as it is needed for querying files.
 227     ...    The options may include JVM options, application command line arguments, Bash redirects and other constructs.
 228     ${base_command} =    Compose_Base_Java_Command    openjdk=${openjdk}
 229     ${full_command} =    BuiltIn.Set_Variable    ${base_command} ${options}
 230     BuiltIn.Log    ${full_command}
 231     [Return]    ${full_command}
 232
 233 Compose_Java_Home
 234     [Arguments]    ${openjdk}=${JDKVERSION}
 235     [Documentation]    Compose base java command and strip trailing "/bin/java".
 236     ${java_command} =    Compose_Base_Java_Command
 237     ${java_home}    ${bin}    ${java} =    String.Split_String_From_Right    ${java_command}    separator=/    max_split=2
 238     [Return]    ${java_home}
 239
 240 Install_Maven_Bare
 241     [Arguments]    ${maven_version}=3.3.9    ${openjdk}=${JDKVERSION}
 242     [Documentation]    Download and unpack Maven, prepare launch command with proper Java version and download settings file.
 243     ...    This Keyword requires an active SSH connection to target machine.
 244     ...    This Keyword sets global variables, so that suites can reuse existing installation.
 245     ...    This Keyword can only place Maven (and settings) to remote current working directory.
 246     ...    This Keyword does not perform any initial or final cleanup.
 247     # Avoid multiple initialization by several downstream libraries.
 248     ${installed_version} =    BuiltIn.Get_Variable_Value    \${Maven__installed_version}    None
 249     BuiltIn.Return_From_Keyword_If    """${installed_version}""" == """${maven_version}"""
 250     BuiltIn.Set_Global_Variable    \${Maven__installed_version}    ${maven_version}
 251     BuiltIn.Set_Global_Variable    \${maven_directory}    apache-maven-${maven_version}
 252     SSHKeywords.Execute_Command_At_Cwd_Should_Pass    rm -rf '${maven_directory}'
 253     ${maven_archive_filename} =    BuiltIn.Set_Variable    ${maven_directory}-bin.tar.gz
 254     ${maven_download_url} =    BuiltIn.Set_Variable    http://www-us.apache.org/dist/maven/maven-3/${maven_version}/binaries/${maven_archive_filename}
 255     SSHKeywords.Execute_Command_At_Cwd_Should_Pass    wget -N '${maven_download_url}'    stderr_must_be_empty=False
 256     SSHKeywords.Execute_Command_At_Cwd_Should_Pass    tar xvf '${maven_archive_filename}'
 257     ${java_home} =    NexusKeywords.Compose_Java_Home    openjdk=${openjdk}
 258     BuiltIn.Set_Global_Variable    \${maven_bash_command}    export JAVA_HOME='${java_home}' && export MAVEN_OPTS='${JAVA_OPTIONS}' && ./${maven_directory}/bin/mvn
 259     # TODO: Get settings files from Jenkins settings provider, somehow.
 260     SSHKeywords.Execute_Command_At_Cwd_Should_Pass    wget '${MAVEN_SETTINGS_URL}' -O settings.xml    stderr_must_be_empty=False
 261
 262 Install_Maven
 263     [Arguments]    ${maven_version}=3.3.9    ${openjdk}=${JDKVERSION}    ${branch}=${EMPTY}    ${patches}=${EMPTY}
 264     [Documentation]    Install Maven.
 265     ...    Depending on arguments, perform a multipatch build to populate local Maven repository with patched artifacts.
 266     Install_Maven_Bare    maven_version=${maven_version}    openjdk=${openjdk}
 267     BuiltIn.Return_From_Keyword_If    """${patches}""" == ""    No post-install build requested.
 268     BuiltIn.Run_Keyword_If    """${branch}""" == ""    BuiltIn.Fail    BRANCH needs to be specified for multipatch builds.
 269     ${script_name} =    BuiltIn.Set_Variable    include-raw-integration-multipatch-distribution-test.sh
 270     ${script_url} =    BuiltIn.Set_Variable    https://raw.githubusercontent.com/opendaylight/releng-builder/master/jjb/integration/${script_name}
 271     SSHKeywords.Execute_Command_At_Cwd_Should_Pass    wget -N '${script_url}'    stderr_must_be_empty=False
 272     SSHKeywords.Execute_Command_At_Cwd_Should_Pass    export WORKSPACE='${WORKSPACE}' && export BRANCH='${branch}' && export PATCHES_TO_BUILD='${patches}' && bash '${script_name}'    stderr_must_be_empty=False
 273     Run_Maven    pom_file=${WORKSPACE}/patch_tester/pom.xml
 274
 275 Run_Maven
 276     [Arguments]    ${pom_file}=pom.xml    ${log_file}=${MAVEN_DEFAULT_OUTPUT_FILENAME}
 277     [Documentation]    Determine arguments to use and call mvn command against given pom file.
 278     SSHKeywords.Execute_Command_At_Cwd_Should_Pass    mkdir -p '${MAVEN_REPOSITORY_PATH}'
 279     ${maven_repository_options} =    BuiltIn.Set_Variable    -Dmaven.repo.local=${MAVEN_REPOSITORY_PATH} -Dorg.ops4j.pax.url.mvn.localRepository=${MAVEN_REPOSITORY_PATH}
 280     SSHKeywords.Execute_Command_At_Cwd_Should_Pass    ${maven_bash_command} clean install dependency:tree -V -B -DoutputFile=dependency_tree.log -s './settings.xml' -f '${pom_file}' ${MAVEN_OPTIONS} ${maven_repository_options} > '${log_file}'
 281
 282 Get_ODL_Versions_From_Nexus
 283     [Documentation]    Returns name of last release found on nexus and list of all versions.
 284     RequestsLibrary.Create_Session    nexus    ${NEXUS_RELEASES_URL}    verify=${TRUE}
 285     ${uri}=    BuiltIn.Set_Variable    maven-metadata.xml
 286     ${response}=    RequestsLibrary.Get_Request    nexus    ${uri}
 287     BuiltIn.Log    ${response.text}
 288     ${root}=    XML.Parse_XML    ${response.text}
 289     ${element}=    XML.Get_Element    ${root}    versioning/latest
 290     ${latest}=    BuiltIn.Set_Variable    ${element.text}
 291     BuiltIn.Log    ${latest}
 292     @{elements}=    XML.Get_Elements    ${root}    .//version
 293     ${versions}=    BuiltIn.Create_List
 294     FOR    ${element}    IN    @{elements}
 295         BuiltIn.Run_Keyword_If    'Carbon' not in $element.text    Collections.Append_To_List    ${versions}    ${element.text}
 296     END
 297     Collections.Sort_List    ${versions}
 298     BuiltIn.Log_Many    @{versions}
 299     [Return]    ${latest}    @{versions}
 300
 301 Get_Latest_ODL_Release_From_Nexus
 302     [Documentation]    Returns name of last release found on nexus
 303     ${latest}    @{versions}=    Get_ODL_Versions_From_Nexus
 304     [Return]    ${latest}
 305
 306 Get_Latest_ODL_Stream_Release
 307     [Arguments]    ${stream}=latest
 308     [Documentation]    Returns name for last release for specified stream.
 309     ${latest}    @{versions}=    Get_ODL_Versions_From_Nexus
 310     BuiltIn.Return_From_Keyword_If    '${stream}'=='latest'    ${latest}
 311     ${latest_version}=    BuiltIn.Set_Variable    xxx
 312     FOR    ${version}    IN    @{versions}
 313         ${latest_version}=    BuiltIn.Set_Variable_If    '${stream}'.title() in '${version}'    ${version}    ${latest_version}
 314     END
 315     BuiltIn.Run_Keyword_If    '${latest_version}'=='xxx'    BuiltIn.Fail    Could not find latest release for stream ${stream}
 316     BuiltIn.Log    ${latest_version}
 317     [Return]    ${latest_version}
 318
 319 Get_Latest_ODL_Stream_Release_URL
 320     [Arguments]    ${stream}=latest    ${format}=.zip
 321     [Documentation]    Returns URL for last release for specified stream. Default format is .zip.
 322     ${latest_version}=    Get_Latest_ODL_Stream_Release    ${stream}
 323     ${url}=    BuiltIn.Set_Variable    ${NEXUS_RELEASES_URL}/${latest_version}/karaf-${latest_version}${format}
 324     BuiltIn.Log    ${url}
 325     [Return]    ${url}
 326
 327 Get_Latest_ODL_Previous_Stream_Release
 328     [Arguments]    ${stream}=${ODL_STREAM}
 329     [Documentation]    Returns name for last release for previous stream of specified stream.
 330     ...    Note: If specified stream is not found on nexus, then it is taken as new one (not released yet).
 331     ...    So in this case, latest release version is return.
 332     ...
 333     ...    NOTE: the below logic is stripping the initial 0. values from the 0.x.x version string that is
 334     ...    the current (and future) version numbering scheme. There is always a leading 0. to the version
 335     ...    strings and stripping it makes is easier to do int comparison to find the largest version in the
 336     ...    list. Comparing as strings does not work. There are some python libs like distutils.version
 337     ...    or packaging that can do a better job comparing versions, but since ODL version numbering is simple
 338     ...    at this point, this convention will suffice. The leading 0. will be added back after the the latest
 339     ...    version is found from the list. The CompareStream.robot library keeps a mapping of major version
 340     ...    numbers to the global variable ${ODL_STREAM} so that is used to ensure we get a major version that is
 341     ...    older than the current running major version.
 342     ${latest}    @{versions}=    Get_ODL_Versions_From_Nexus
 343     ${current_version}=    BuiltIn.Set_Variable    ${Stream_dict}[${ODL_STREAM}].0
 344     ${latest_version}=    BuiltIn.Set_Variable    0.0
 345     FOR    ${version}    IN    @{versions}
 346         ${version} =    String.Replace String Using Regexp    ${version}    ^0\.    ${EMPTY}
 347         ${latest_version}=    Set Variable If    ${version} > ${latest_version} and ${version} < ${current_version}    ${version}    ${latest_version}
 348     END
 349     ${latest_version}=    Set Variable    0.${latest_version}
 350     BuiltIn.Run_Keyword_If    '${latest_version}'=='0.0.0'    BuiltIn.Fail    Could not find latest previous release for stream ${stream}
 351     BuiltIn.Log    ${latest_version}
 352     [Return]    ${latest_version}
 353
 354 Get_Latest_ODL_Previous_Stream_Release_URL
 355     [Arguments]    ${stream}=${ODL_STREAM}    ${format}=.zip
 356     [Documentation]    Returns URL for last release for previous stream of specified stream. Default format is .zip.
 357     ${latest_version}=    Get_Latest_ODL_Previous_Stream_Release    ${stream}
 358     ${url}=    BuiltIn.Set_Variable    ${NEXUS_RELEASES_URL}/${latest_version}/karaf-${latest_version}${format}
 359     BuiltIn.Log    ${url}
 360     [Return]    ${url}