blobfuse-nightly.yml

# BlobFuse Nightly Build-Sanity Pipeline

schedules:
  # Cron string < minute hour day-of-month month day-of-week>
  #             * means all like '*' in day of month means everyday
  # Run only on master branch
  # 'always' controls whether to run only if there is a change or not
- cron: "0 0 * * *"
  displayName: Daily midnight BlobFuse build
  branches:
    include:
    - master
  always: true


# List of jobs to run in parallel
jobs:
  - job: NightlySanity
    timeoutInMinutes: 240

    # Define on what all OS we want to run this Pipeline
    strategy:
      matrix:
        Ubuntu-16:
          imageName: 'ubuntu-16.04'
          containerName: 'test-cnt-ubn-16'
          quickTestDir: 'ubn16'
        Ubuntu-18:
          imageName: 'ubuntu-18.04' 
          containerName: 'test-cnt-ubn-18'
          quickTestDir: 'ubn18'
        Ubuntu-20:
          imageName: 'ubuntu-20.04' 
          containerName: 'test-cnt-ubn-20'
          quickTestDir: 'ubn20'
    pool:
      vmImage: $(imageName)

    variables:
    - group: NightlyBlobFuse
    - name: MOUNT_DIR
      value: "/home/vsts/work/blob_mnt"
    - name: TEMP_DIR
      value: "/mnt/blobfusetmp"
    - name: BLOBFUSE_CFG
      value: "/home/vsts/work/blobfuse.cfg"
    - name: BLOBFUSE_CFG_ADLS
      value: "/home/vsts/work/blobfuse.cfg.adls"
    - name: BLOBFUSE_CFG_GTEST
      value: "./connection.cfg"
    - name: BLOBFUSE_STRESS_DIR
      value: "/home/vsts/work/blob_stress"
   

    # Each job has set of steps to be done
    steps:
    - script: |
        sudo apt-get update --fix-missing
        sudo apt-get install pkg-config cmake libcurl4-gnutls-dev libgnutls28-dev uuid-dev libgcrypt20-dev libboost-all-dev gcc g++ -y
      displayName: "Basic Tools Setup"

    - script: |
        sudo apt-get install libfuse-dev -y
        #export GOROOT=/usr/local/go
        #export GOPATH=$HOME/go
        #export PATH=$GOPATH/bin:$GOROOT/bin:$PATH
      displayName: "libFuse Setup"

    # List commits done 
    - script: |
        echo "Below commits were done in last 12 hours : " `date` 
        git --no-pager log --since="12 hours ago" --stat
      displayName: "List Commits"

    # Build the blobFuse binary
    - script: |
        export INCLUDE_TESTS=1
        sudo chmod +x build.sh
        . ./build.sh
      displayName: "Build BlobFuse"

    # Test the binary just to make sure it was built fine
    - script: |
        ./build/blobfuse --version
      displayName: "Test the binary"
    

    # Initialize logging for blobfuse
    - script: |
        sudo cp ./systemd/10-blobfuse.conf /etc/rsyslog.d/
        sudo cp ./systemd/blobfuse-logrotate /etc/logrotate.d/blobfuse
      displayName: "Copy the syslog filter files"
      #continueOnError: true

    # Restart rsyslog to init the logging
    - script: |
        sudo service rsyslog restart
      displayName: "Restart rsyslogd service"
      #continueOnError: true
      
    # Create directory structures for the basic testing
    - script: |
        mkdir $(MOUNT_DIR)
        echo "Creating Mount dir " $(MOUNT_DIR)
      displayName: "Create Mount Directory"

    - script: |
        sudo mkdir $(TEMP_DIR)
        sudo chown -R `whoami` $(TEMP_DIR)
        chmod 777 $(TEMP_DIR)
        echo "Creating Cache dir " $(TEMP_DIR)
      displayName: "Create Cache Directory"
      
        
    # Set container name based on OS
    - script: |
        echo "::set-env name=CONT_NAME::$(containerName)"
      displayName: "Prepare contianer name"

    # --- Create ADLS config for Ubn-18.04 and mount it with ADLS option turn on  
    - script: |
        echo "accountName " $(NIGHTLY_STO_ACC_NAME) > $(BLOBFUSE_CFG_ADLS)
        echo "accountKey " $(NIGHTLY_STO_ACC_KEY) >> $(BLOBFUSE_CFG_ADLS)
        echo "authType Key" >> $(BLOBFUSE_CFG_ADLS)
        echo "containerName " $(containerName) >> $(BLOBFUSE_CFG_ADLS)
        cat $(BLOBFUSE_CFG_ADLS)
        echo "Account : " $(NIGHTLY_STO_ACC_NAME)
      displayName: "Create config file ADLS"

    # --- Create Block Blob config for Ubn-16.04 and mount it with ADLS option turn off  
    - script: |
        echo "accountName " $(NIGHTLY_STO_BLOB_ACC_NAME) > $(BLOBFUSE_CFG)
        echo "accountKey " $(NIGHTLY_STO_BLOB_ACC_KEY) >> $(BLOBFUSE_CFG)
        echo "authType Key" >> $(BLOBFUSE_CFG)
        echo "containerName " $(containerName) >> $(BLOBFUSE_CFG)
        cat $(BLOBFUSE_CFG)
        echo "Account : " $(NIGHTLY_STO_BLOB_ACC_NAME)
      displayName: "Create config file BlockBlob" 

    # Mount container using blobFuse
    - script: |
        ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_ADLS) --use-adls=true --use-attr-cache=true
      displayName: "Mount container ADLS"
      condition: or(eq(variables.imageName, 'ubuntu-18.04'), eq(variables.imageName, 'ubuntu-20.04'))
      timeoutInMinutes: 3
  
    - script: |
        ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG) --use-attr-cache=true
      displayName: "Mount container Block"
      condition: eq(variables.imageName, 'ubuntu-16.04')
      timeoutInMinutes: 3
    # --------------------------------------------------------------------


    - script : |
        sudo cat /var/log/blobfuse.log
      displayName: "Dump Mount Log"
      timeoutInMinutes: 1
      condition: failed()

    # Give some time for system to stablise
    - script: sleep 10s
      displayName: "Let the mount come online"

    # -------------------------------------------------------

    # Check the mount went through or not by listing the mounted directory
    - script: ls -l $(MOUNT_DIR)
      timeoutInMinutes: 5
      displayName: "TEST - Directory Listing"
      continueOnError: true

    # Clear directory form previous failed runs
    - script: |
        rm -rf $(MOUNT_DIR)/* 
      displayName: "TEST - Initial cleanup"
      timeoutInMinutes: 30
      continueOnError: true
             
    # Directory Operation Testing
    - script: mkdir $(MOUNT_DIR)/test_dir
      displayName: "TEST - Create Directory"
      timeoutInMinutes: 5
      continueOnError: true

    # GetStat on Directory
    - script: stat $(MOUNT_DIR)/test_dir
      displayName: "TEST - GetStat Directory"
      timeoutInMinutes: 3
      continueOnError: true

    # Delete newly created Directory
    - script: rm -rf $(MOUNT_DIR)/test_dir
      displayName: "TEST - Delete Directory"
      timeoutInMinutes: 5
      continueOnError: true

    # -------------------------------------------------------

    # File Operations Testing

    # Create a file in mounted directory
    - script: |
        touch $(MOUNT_DIR)/test.txt
      # dd bs=1000 count=1000000 if=/dev/zero of=$(MOUNT_DIR)/test.txt
      displayName: "TEST - Create File (Empty)"
      timeoutInMinutes: 10
      continueOnError: true
     
    # GetStat on File
    - script: stat $(MOUNT_DIR)/test.txt
      displayName: "TEST - GetStat File"
      timeoutInMinutes: 3
      #continueOnError: true

    # File Read-Write test
    - script: |
        sudo cat blobfuse-nightly.yml > $(MOUNT_DIR)/test.log
        sudo cat $(MOUNT_DIR)/test.log
        stat $(MOUNT_DIR)/test.log
      displayName: "TEST - Write to file and Read back"
      timeoutInMinutes: 10
      #continueOnError: true

    # File rename test
    - script: |
        mv $(MOUNT_DIR)/test.txt $(MOUNT_DIR)/test1.txt
      displayName: "TEST - Rename File"
      timeoutInMinutes: 5

    # File copy test
    - script: |
        cp -r ./blobfuse/*.* $(MOUNT_DIR)/
      displayName: "TEST - Copy File"
      timeoutInMinutes: 10
      continueOnError: true

    # Delete newly created file
    - script: | 
        rm -rf  $(MOUNT_DIR)/test.txt
        rm -rf  $(MOUNT_DIR)/test1.txt
        rm -rf  $(MOUNT_DIR)/test.log
      displayName: "TEST - Delete File"
      timeoutInMinutes: 10
      #continueOnError: true

    # Clear directory 
    - script: rm -rf $(MOUNT_DIR)/*
      displayName: "TEST - Directory Cleaning at End"
      timeoutInMinutes: 10
      continueOnError: true

    # Upload blobs and validate data by comparing 
    - script: |
        cp -R ./blobfuse/* $(MOUNT_DIR)/
        touch ./blobfuse/ishallcomeindiff.file
        time for i in {1..10}; do ls -l $(MOUNT_DIR); done
        diff -qr ./blobfuse/ $(MOUNT_DIR)/ 
        rm -rf $(MOUNT_DIR)/*
      displayName: "TEST - Data Validation"
      timeoutInMinutes: 10
      continueOnError: true

    # -------------------------------------------------------

    # Basic testing done.....
    
    # Test complete so now unmount the directory
    - script:  |
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(MOUNT_DIR)/.*
        sudo fusermount -u $(MOUNT_DIR)
        sudo rm -rf $(TEMP_DIR)/*
      displayName: Unmount container
      timeoutInMinutes: 20
      #continueOnError: true
   
    # -------------------------------------------------------
    # BLOCK BLOB TESTS
    # Starting gTest
    
    # Create config file for gtest
    - script: |
        echo "accountName " $(NIGHTLY_STO_BLOB_ACC_NAME) > $(BLOBFUSE_CFG_GTEST)
        echo "accountKey " $(NIGHTLY_STO_BLOB_ACC_KEY) >> $(BLOBFUSE_CFG_GTEST)
        echo "authType Key" >> $(BLOBFUSE_CFG_GTEST)
        echo "containerName " $(containerName) >> $(BLOBFUSE_CFG_GTEST)
        cat $(BLOBFUSE_CFG_GTEST)
        echo "Account : " $(NIGHTLY_STO_ACC_NAME)
      displayName: "TEST - BLOCK gTest Config"
    
    # Run gTest with the config file created earlier
    - script:  |
        cd ./build/
        sudo chmod 777 ./blobfusetests
        sudo ./blobfusetests 
        cd -
      displayName: TEST - BLOCK gTest
      timeoutInMinutes: 30
      continueOnError: true

    # -------------------------------------------------------
    # Starting stressTest

    # Mount a directory for stressTest and run it
    - script:  |
        sudo fusermount -u $(MOUNT_DIR)
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(TEMP_DIR)/*
        sudo mkdir $(BLOBFUSE_STRESS_DIR)
        sudo chown -R `whoami` $(BLOBFUSE_STRESS_DIR)
        sudo chmod 777 $(BLOBFUSE_STRESS_DIR)
        ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_GTEST) --use-attr-cache=true
        cd test
        go run stressTest.go $(MOUNT_DIR)
        cd -
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - BLOCK stressTest
      timeoutInMinutes: 120
      continueOnError: true

    - script:  |
        sudo fusermount -u $(MOUNT_DIR)
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - BLOCK stressTest Cleanup
      timeoutInMinutes: 30
      continueOnError: true

    # Mount a directory for stressTest and run it
    - script:  |
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(TEMP_DIR)/*
        sudo mkdir $(BLOBFUSE_STRESS_DIR)
        sudo chown -R `whoami` $(BLOBFUSE_STRESS_DIR)
        sudo chmod 777 $(BLOBFUSE_STRESS_DIR)
        ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_GTEST)
        cd test
        go run stressTest.go $(MOUNT_DIR)
        cd -
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - BLOCK stressTest No Attr Cache
      timeoutInMinutes: 120
      continueOnError: true

    - script:  |
        sudo fusermount -u $(MOUNT_DIR)
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - BLOCK stressTest Cleanup
      timeoutInMinutes: 30
      continueOnError: true

    # -------------------------------------------------------
    # Mount a directory for feature test (Block) and run it
    - script:  |
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(TEMP_DIR)/*
        ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_GTEST)
        cd test
        go test -v feature_test.go -args -mnt-path=$(MOUNT_DIR)
        cd -
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - BLOCK FeatureTest
      timeoutInMinutes: 120
      continueOnError: true

    - script:  |
        rm -rf $(MOUNT_DIR)/*
        sudo fusermount -u $(MOUNT_DIR)
        sudo rm -rf $(TEMP_DIR)/*
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - BLOCK FeatureTest Cleanup
      timeoutInMinutes: 30
      continueOnError: true


    # -------------------------------------------------------

    # ADLS TESTS
    # Mount a directory for stressTest (ADLS) and run it
    - script:  |
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(TEMP_DIR)/*
        ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_ADLS) --use-adls=true --use-attr-cache=true
        cd test
        go run stressTest.go $(MOUNT_DIR)
        cd -
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - ADLS stressTest
      timeoutInMinutes: 120
      continueOnError: true

    - script:  |
        rm -rf $(MOUNT_DIR)/*
        sudo fusermount -u $(MOUNT_DIR)
        sudo rm -rf $(TEMP_DIR)/*
        sudo rm -rf $(BLOBFUSE_STRESS_DIR)/*
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - ADLS stressTest Cleanup
      timeoutInMinutes: 30
      continueOnError: true
      
    # Mount a directory for stressTest (ADLS) and run it
    - script:  |
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(TEMP_DIR)/*
        ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_ADLS) --use-adls=true
        cd test
        go run stressTest.go $(MOUNT_DIR)
        cd -
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - ADLS stressTest No Attr Cache
      timeoutInMinutes: 120
      continueOnError: true

    - script:  |
        rm -rf $(MOUNT_DIR)/*
        sudo fusermount -u $(MOUNT_DIR)
        sudo rm -rf $(TEMP_DIR)/*
        sudo rm -rf $(BLOBFUSE_STRESS_DIR)/*
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - ADLS stressTest Cleanup
      timeoutInMinutes: 30
      continueOnError: true

    # Mount a directory for stressTest (ADLS) without symlink and run it
    - script:  |
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(TEMP_DIR)/*
        ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_ADLS) --use-adls=true --use-attr-cache=true --no_symlinks=true
        cd test
        go run stressTest.go $(MOUNT_DIR)
        cd -
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - ADLS stressTest noSymlinks
      timeoutInMinutes: 120
      continueOnError: true

    - script:  |
        rm -rf $(MOUNT_DIR)/*
        sudo fusermount -u $(MOUNT_DIR)
        sudo rm -rf $(TEMP_DIR)/*
        sudo rm -rf $(BLOBFUSE_STRESS_DIR)/*
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - ADLS stressTest Cleanup noSymlinks
      timeoutInMinutes: 30
      continueOnError: true

    # -------------------------------------------------------
    # Mount a directory for feature test (ADLS) and run it
    - script:  |
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(TEMP_DIR)/*
        ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_ADLS) --use-adls=true
        pidof blobfuse
        cd test
        go test -v feature_test.go -args -mnt-path=$(MOUNT_DIR) -adls=true
        cd -
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - ADLS FeatureTest
      timeoutInMinutes: 120
      continueOnError: true

    - script:  |
        rm -rf $(MOUNT_DIR)/*
        sudo fusermount -u $(MOUNT_DIR)
        sudo rm -rf $(TEMP_DIR)/*
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - ADLS FeatureTest Cleanup
      timeoutInMinutes: 30
      continueOnError: true
      
    # -------------------------------------------------------
    # Starting pyTest

    # Mount a directory for pyTest and run it
    - script:  |
        sudo rm -rf $(TEMP_DIR)/*
        sudo cp $(BLOBFUSE_CFG_ADLS) $(BLOBFUSE_CFG_GTEST)
        sudo ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_ADLS) --use-adls=true --use-attr-cache=true
        cd ./test/
        sudo python tests.py
        cd -
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - BLOCK pyTest
      timeoutInMinutes: 120
      continueOnError: true

    - script:  |
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(MOUNT_DIR)/.*
        sudo fusermount -u $(MOUNT_DIR)
        sudo kill -9 `pidof blobfuse`
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(MOUNT_DIR)/.*
        sudo rm -rf $(TEMP_DIR)/*
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - BLOCK pyTest Cleanup
      timeoutInMinutes: 10
      continueOnError: true
    # -------------------------------------------------------

    # - script:  |
    #    sudo rm -rf $(MOUNT_DIR)/*
    #    sudo rm -rf $(TEMP_DIR)/*
    #    ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_GTEST)
    #    cd stresstests/
    #    make
    #    chmod 777 ./blobfusestress
    #    sudo ./blobfusestress $(MOUNT_DIR) $(BLOBFUSE_STRESS_DIR)
    #    cd -
    #  condition: eq(variables['Build.SourceBranchName'], 'master')
    #  displayName: TEST - BLOCK CPP stressTest
    #  timeoutInMinutes: 120
    #  continueOnError: true

    # - script:  |
    #    sudo fusermount -u $(MOUNT_DIR)
    #    sudo rm -rf $(BLOBFUSE_STRESS_DIR)/*
    #    sudo rm -rf $(TEMP_DIR)/*
    #  condition: eq(variables['Build.SourceBranchName'], 'master')
    #  displayName: TEST - BLOCK CPP stressTest Cleanup
    #  timeoutInMinutes: 30
    #  continueOnError: true


    # -------------------------------------------------------

    # Create config file for SPN Login
    - script: |
        echo "accountName " $(NIGHTLY_SPN_ACC_NAME) > $(BLOBFUSE_CFG_GTEST)
        echo "authType SPN" >> $(BLOBFUSE_CFG_GTEST)
        echo "servicePrincipalClientId " $(NIGHTLY_SPN_CLIENT_ID) >> $(BLOBFUSE_CFG_GTEST)
        echo "servicePrincipalTenantId " $(NIGHTLY_SPN_TENANT_ID) >> $(BLOBFUSE_CFG_GTEST)
        echo "servicePrincipalClientSecret " $(NIGHTLY_SPN_CLIENT_SECRET) >> $(BLOBFUSE_CFG_GTEST)
        echo "containerName " $(NIGHTLY_SPN_CONT_NAME) >> $(BLOBFUSE_CFG_GTEST)
        cat $(BLOBFUSE_CFG_GTEST)
        echo "Account : " $(NIGHTLY_SPN_ACC_NAME)
      displayName: "TEST - Create SPN Config"
      condition: eq(variables.imageName, 'ubuntu-18.04')

    # List the blobs to verify that the login went successful
    - script:  |
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(TEMP_DIR)/*
        ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_GTEST)
        sleep 5s
        ls -l $(MOUNT_DIR)
        mkdir $(MOUNT_DIR)/A
        touch $(MOUNT_DIR)/A/a.txt
        echo "ASDF" > $(MOUNT_DIR)/A/b.txt
        cp $(MOUNT_DIR)/A/b.txt $(MOUNT_DIR)/A/c.txt
        ls -lRt $(MOUNT_DIR)/A
        rm -rf $(MOUNT_DIR)/A
        sudo fusermount -u $(MOUNT_DIR)
        sudo kill -9 `pidof blobfuse`
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - SPN Validation
      timeoutInMinutes: 120
      continueOnError: true
      condition: eq(variables.imageName, 'ubuntu-18.04')

    # -------------------------------------------------------

    # Create config file for SAS Login
    - script: |
        echo "accountName " $(NIGHTLY_SPN_ACC_NAME) > $(BLOBFUSE_CFG_GTEST)
        echo "sasToken " $(NIGHTLY_SPN_ACC_SAS) >> $(BLOBFUSE_CFG_GTEST)
        echo "authType SAS" >> $(BLOBFUSE_CFG_GTEST)
        echo "containerName " $(NIGHTLY_SPN_CONT_NAME) >> $(BLOBFUSE_CFG_GTEST)
        cat $(BLOBFUSE_CFG_GTEST)
        echo "Account : " $(NIGHTLY_SPN_ACC_NAME)
      displayName: "TEST - Create SAS Config"
      condition: eq(variables.imageName, 'ubuntu-16.04')

    # List the blobs to verify that the login went successful
    - script:  |
        sudo rm -rf $(MOUNT_DIR)/*
        sudo rm -rf $(TEMP_DIR)/*
        ./build/blobfuse $(MOUNT_DIR) --tmp-path=$(TEMP_DIR) --config-file=$(BLOBFUSE_CFG_GTEST)
        sleep 5s
        ls -l $(MOUNT_DIR)
        mkdir $(MOUNT_DIR)/B
        touch $(MOUNT_DIR)/B/b.txt
        echo "ASDF" > $(MOUNT_DIR)/B/c.txt
        cp $(MOUNT_DIR)/B/c.txt $(MOUNT_DIR)/B/d.txt
        ls -lRt $(MOUNT_DIR)/B
        rm -rf $(MOUNT_DIR)/B
        sudo fusermount -u $(MOUNT_DIR)
        sudo kill -9 `pidof blobfuse`
      # condition: eq(variables['Build.SourceBranchName'], 'master')
      displayName: TEST - SAS Validation
      timeoutInMinutes: 120
      continueOnError: true
      condition: eq(variables.imageName, 'ubuntu-16.04')
    # -------------------------------------------------------

    # Cleanup at the end
    - script:  |
        sudo fusermount -u $(MOUNT_DIR)
        sudo kill -9 `pidof blobfuse`
        sudo rm -rf $(TEMP_DIR)/*
      displayName: Cleanup
      timeoutInMinutes: 120
      continueOnError: true

    # Print the log files
    - script: sudo cat /var/log/blobfuse.log
      displayName: Print the log file
      continueOnError: true