test: Add calsoft test for iscsi target.

	export INITIATOR_IP=127.0.0.1

	timing_enter iscsi_tgt

	time ./test/iscsi_tgt/calsoft/calsoft.sh

	time ./test/iscsi_tgt/filesystem/filesystem.sh

	time ./test/iscsi_tgt/fio/fio.sh

	time ./test/iscsi_tgt/reset/reset.sh

[AuthGroup1]

  Comment "Auth Group1"

  Auth "root" "tester"

import os

import time

import sys

import subprocess

import threading

import json

CALSOFT_BIN_PATH = "/usr/local/calsoft/iscsi-pcts-v1.5/bin"

'''

11/26/2015 disable tc_login_11_2 and tc_login_11_4

RFC 7143 6.3

Neither the initiator nor the target should attempt to declare or

negotiate a parameter more than once during login, except for

responses to specific keys that explicitly allow repeated key

declarations (e.g., TargetAddress)

The spec didn't make it clear what other keys could be re-declare

Disscussed this with UNH and get the conclusion that TargetName/

TargetAddress/MaxRecvDataSegmentLength could be re-declare.

'''

'''

12/1/2015 add tc_login_2_2 to known_failed_cases

RFC 7143 6.1

A standard-label MUST begin with a capital letter and must not exceed

63 characters.

key name: A standard-label

'''

known_failed_cases = ['tc_ffp_15_2', 'tc_ffp_29_2', 'tc_ffp_29_3',

                      'tc_err_1_1', 'tc_err_1_2', 'tc_err_2_8',

                      'tc_err_3_1', 'tc_err_3_2', 'tc_err_3_3',

                      'tc_err_3_4', 'tc_err_5_1', 'tc_login_3_1',

                      'tc_login_11_2', 'tc_login_11_4', 'tc_login_2_2']

def run_case(case, result_list, log_dir_path):

    try:

        case_log = subprocess.check_output("{}/{}".format(CALSOFT_BIN_PATH, case), stderr=subprocess.STDOUT, shell=True)

    except subprocess.CalledProcessError as e:

        result_list.append({"Name": case, "Result": "FAIL"})

        case_log = e.output

    else:

        result_list.append({"Name": case, "Result": "PASS"})

    with open(log_dir_path + case + '.txt', 'w') as f:

        f.write(case_log)

def main():

    if not os.path.exists(CALSOFT_BIN_PATH):

        print "The Calsoft test suite is not available on this machine."

        sys.exit(1)

    output_dir = sys.argv[1]

    if len(sys.argv) > 2:

        output_file = sys.argv[2]

    else:

        output_file = "%s/calsoft.json" % (output_dir)

    log_dir = "%s/calsoft/" % output_dir

    all_cases = [x for x in os.listdir(CALSOFT_BIN_PATH) if x.startswith('tc')]

    all_cases.sort()

    case_result_list = []

    result = {"Calsoft iSCSI tests": case_result_list}

    if not os.path.exists(log_dir):

        os.mkdir(log_dir)

    for case in known_failed_cases:

        print "Skipping %s. It is known to fail." % (case)

        case_result_list.append({"Name": case, "Result": "SKIP"})

    thread_objs = []

    left_cases = list(set(all_cases) - set(known_failed_cases))

    index = 0

    max_thread_count = 32

    while index < len(left_cases):

        cur_thread_count = 0

        for thread_obj in thread_objs:

            if thread_obj.is_alive():

                cur_thread_count += 1

        while cur_thread_count < max_thread_count and index < len(left_cases):

            thread_obj = threading.Thread(target=run_case, args=(left_cases[index], case_result_list, log_dir, ))

            thread_obj.start()

            time.sleep(0.02)

            thread_objs.append(thread_obj)

            index += 1

            cur_thread_count += 1

    end_time = time.time() + 30

    while time.time() < end_time:

        for thread_obj in thread_objs:

            if thread_obj.is_alive():

                break

        else:

            break

    else:

        print "Thread timeout"

        exit(1)

    with open(output_file, 'w') as f:

        json.dump(obj=result, fp=f, indent=2)

    if any(["FAIL" == x["Result"] for x in case_result_list]):

        print "Test case %s failed." % (x["Name"])

        sys.exit(1)

if __name__ == '__main__':

    main()

#!/usr/bin/env bash

testdir=$(readlink -f $(dirname $0))

rootdir=$testdir/../../..

source $rootdir/scripts/autotest_common.sh

if [ -z "$TARGET_IP" ]; then

	echo "TARGET_IP not defined in environment"

	exit 1

fi

if [ -z "$INITIATOR_IP" ]; then

	echo "INITIATOR_IP not defined in environment"

	exit 1

fi

timing_enter calsoft

# iSCSI target configuration

PORT=3260

RPC_PORT=5260

INITIATOR_TAG=2

INITIATOR_NAME=ALL

NETMASK=$INITIATOR_IP/32

MALLOC_LUN_SIZE=64

MALLOC_BLOCK_SIZE=512

rpc_py="python $rootdir/scripts/rpc.py"

calsoft_py="python $testdir/calsoft.py"

# Copy the calsoft config file to /usr/local/etc

mkdir -p /usr/local/etc

cp $testdir/its.conf /usr/local/etc/

cp $testdir/auth.conf /usr/local/etc/

./app/iscsi_tgt/iscsi_tgt -c $testdir/iscsi.conf &

pid=$!

echo "Process pid: $pid"

trap "process_core; killprocess $pid; exit 1 " SIGINT SIGTERM EXIT

waitforlisten $pid ${RPC_PORT}

echo "iscsi_tgt is listening. Running tests..."

$rpc_py add_portal_group 1 $TARGET_IP:$PORT

$rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK

$rpc_py construct_malloc_lun $MALLOC_LUN_SIZE $MALLOC_BLOCK_SIZE

# "Malloc0:0" ==> use Malloc0 blockdev for LUN0

# "1:2" ==> map PortalGroup1 to InitiatorGroup2

# "64" ==> iSCSI queue depth 64

# "0 0 0 1" ==> enable CHAP authentication using auth group 1

$rpc_py construct_target_node Target3 Target3_alias 'Malloc0:0' '1:2' 64 0 0 0 1

sleep 1

if [ "$1" ]; then

	$calsoft_py "$output_dir" "$1"

	failed=$?

else

	$calsoft_py "$output_dir"

	failed=$?

fi

trap - SIGINT SIGTERM EXIT

killprocess $pid

timing_exit calsoft

exit $failed

[Global]

  ReactorMask 0x1

  LogFacility "local7"

[iSCSI]

  NodeBase "iqn.2016-06.io.spdk"

  AuthFile /usr/local/etc/auth.conf

  Timeout 30

  DiscoveryAuthMethod Auto

  DiscoveryAuthGroup AuthGroup1

  MaxSessions 256

  MaxR2T 256

  MaxOutstandingR2T 256

  FirstBurstLength 262144

  MaxBurstLength 16776192

  MaxRecvDataSegmentLength 131072

  ErrorRecoveryLevel 2

  NopInInterval 10

  AllowDuplicateIsid Yes

[Rpc]

  Enable Yes