#!/bin/bash

# Copyright (c) Istituto Nazionale di Fisica Nucleare (INFN). 2006-2010.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

#
# Size
#
function get_size () {

  FUNCTION="get_size"

  if [ "$#" -ne "9" ]; then
    echo "Internal Error"
    exit 1 
  fi

  ERROR=1
  SIZE=`/usr/bin/curl -s http://$2:$3/info/status/$1`
  if [ -z "${SIZE}" ]; then
    echo "${FUNCTION}: the command /usr/bin/curl -s http://$2:$3/info/status/$1 return no value; check storm backend service status."
  elif [ "${SIZE}" == "<html><body><h1>Internal Error</h1></body></html>" ]; then
    echo "${FUNCTION}: the command /usr/bin/curl -s http://$2:$3/info/status/$1 return Internal Error; check storm backend info service status."
  else
    # convert in GB (base 10)
    used=`echo $SIZE | sed -e 's/[{}]/''/g' | awk -v RS=',"' -F: '/^used-space/ {print $2}'`
    free=`echo $SIZE | sed -e 's/[{}]/''/g' | awk -v RS=',"' -F: '/^free-space/ {print $2}'`
    reserved=`echo $SIZE | sed -e 's/[{}]/''/g' | awk -v RS=',"' -F: '/^reserved-space/ {print $2}'`
    total=`echo $SIZE | sed -e 's/[{}]/''/g' | awk -v RS=',"' -F: '/^total-space/ {print $2}'`
    available=`echo $SIZE | sed -e 's/[{}]/''/g' | awk -v RS=',"' -F: '/^available-space/ {print $2}'`
    busy=`echo $SIZE | sed -e 's/[{}]/''/g' | awk -v RS=',"' -F: '/^busy-space/ {print $2}'`
    if [ "${available}" -eq "0" ]; then
      available=$((${total} - ${busy}))
    fi
    NSIZE=`/usr/libexec/storm-dynamic-info-provider/storm-base-ten-converter -u $used -f $free -r $reserved -t $total -a $available`
    used=`echo $NSIZE | sed -e 's/[{}]/''/g' | awk -v RS=',' -F': ' '/used-space/ {print $2}'`
    free=`echo $NSIZE | sed -e 's/[{}]/''/g' | awk -v RS=',' -F': ' '/free-space/ {print $2}'`
    reserved=`echo $NSIZE | sed -e 's/[{}]/''/g' | awk -v RS=',' -F': ' '/reserved-space/ {print $2}'`
    total=`echo $NSIZE | sed -e 's/[{}]/''/g' | awk -v RS=',' -F': ' '/total-space/ {print $2}'`
    available=`echo $NSIZE | sed -e 's/[{}]/''/g' | awk -v RS=',' -F': ' '/available-space/ {print $2}'`
    ERROR=0
    export $5=${total}
    export $6=${available}
    export $7=${used}
    export $8=${free}
    export $9=${reserved}
  fi

  return ${ERROR}

}

###
### Main section
###

# Source configuration file
if [ $# = 1 ]; then
  source $1
else
  exit 1
fi

# Source utils file
UTIL=/opt/glite/yaim/functions/utils/manage_conf
if [ -e ${UTIL} ]; then
  source ${UTIL}
else
  exit 1
fi

FILE=`mktemp`

ERROR=0
# Prepare need variables
for SA in ${STORM_STORAGEAREA_LIST}; do

  # Convert case
  SA_UPP=`echo ${SA} | tr '[:lower:]' '[:upper:]'`
  SA_LOW=`echo ${SA} | tr '[:upper:]' '[:lower:]'`

  # Remove DNS-like characters from SA_UPP names
  SA_UPP=`echo ${SA_UPP} | sed -e 's/-//g' -e 's/\.//g'`

  x=STORM_${SA_UPP}_TOKEN;           SA_TOKEN=${!x:-${SA_UPP}_TOKEN}
  x=STORM_${SA_UPP}_QUOTA;           SA_QUOTA=${!x:-false}
  x=STORM_${SA_UPP}_VONAME;          SA_VONAME=${!x:-${SA_LOW}}
  x=STORM_${SA_UPP}_STORAGECLASS;    SA_STORAGECLASS=${!x:-${STORM_STORAGECLASS}}

  hash_insert SA_TOTAL_ONLINE_SIZE_GB ${SA_UPP} 0          # default
  hash_insert SA_FREE_ONLINE_SIZE_GB  ${SA_UPP} 0           # default
  hash_insert SA_USED_ONLINE_SIZE_GB  ${SA_UPP} 0           # default
  hash_insert SA_RESERVED_ONLINE_SIZE_GB ${SA_UPP} 0      # default
  hash_insert SA_USED_ONLINE_SIZE_KB ${SA_UPP} 0           # default
  hash_insert SA_AVAILABLE_ONLINE_SIZE_KB ${SA_UPP} 0      # default

  hash_insert SA_TOTAL_NEARLINE_SIZE_GB ${SA_UPP} 0        # default

  x=STORM_${SA_UPP}_ONLINE_SIZE;   SA_SIZE=${!x}

  if ! [ -z "${SA_STORAGECLASS}" ]; then
    case ${SA_STORAGECLASS} in
      "T1D0")
        x=STORM_${SA_UPP}_NEARLINE_SIZE; SA_NL_SIZE=${!x}
        x=STORM_${SA_UPP}_ONLINE_SIZE;   SA_SIZE=${!x}
        ;;
      "T1D1")
        x=STORM_${SA_UPP}_ONLINE_SIZE;   SA_SIZE=${!x}
        ;;
      "T0D1")
        x=STORM_${SA_UPP}_ONLINE_SIZE;   SA_SIZE=${!x}
        ;;
      *)
        x=STORM_${SA_UPP}_ONLINE_SIZE;   SA_SIZE=${!x}
        ;;
    esac
  fi

  get_size  ${SA_TOKEN} ${STORM_BACKEND_HOST} ${STORM_BACKEND_REST_SERVICES_PORT} ${SA_SIZE} TOTAL AVAILABLE USED FREE RESERVED

  if [ $? -eq 1 ]; then
    ERROR=1
    break
  fi

  if ! [ -z "${SA_STORAGECLASS}" ]; then
    if [ "${SA_STORAGECLASS}" == "T1D0" ] ; then
        # Get size values on SA_TOKEN (in GB)
        hash_insert SA_TOTAL_NEARLINE_SIZE_GB ${SA_UPP} ${SA_NL_SIZE}
    fi
  fi

  # Get size values on SA_TOKEN (in GB)
  hash_insert SA_USED_ONLINE_SIZE_GB  ${SA_UPP} $((${USED}/(1000*1000*1000)))
  hash_insert SA_FREE_ONLINE_SIZE_GB  ${SA_UPP} $((${FREE}/(1000*1000*1000)))
  hash_insert SA_TOTAL_ONLINE_SIZE_GB ${SA_UPP} $((${TOTAL}/(1000*1000*1000)))
  hash_insert SA_RESERVED_ONLINE_SIZE_GB ${SA_UPP} $((${RESERVED}/(1000*1000*1000)))

  # Get size values on SA_TOKEN (in KB)
  hash_insert SA_USED_ONLINE_SIZE_KB  ${SA_UPP} $((${USED}/1000))
  hash_insert SA_AVAILABLE_ONLINE_SIZE_KB  ${SA_UPP} $((${AVAILABLE}/1000))

  # Prepare per-VO and global values
  PERVO_VONAME_INDEX=`echo ${SA_VONAME} | sed -e 's/-//g' -e 's/\.//g'`
  # Add VONAME if missing
  if ! [[ "${PERVO_VONAMES}" =~ "${SA_VONAME}" ]]; then
    PERVO_VONAMES="${PERVO_VONAMES} ${SA_VONAME}"
  fi

  # Sum size values for VONAME and global(in GB)
  x=`hash_find PERVO_USED_ONLINE_SIZE_GB ${PERVO_VONAME_INDEX}`
  y=`hash_find SA_USED_ONLINE_SIZE_GB ${SA_UPP}`
  hash_insert PERVO_USED_ONLINE_SIZE_GB ${PERVO_VONAME_INDEX} $((x+y))
  let GLOBAL_USED_ONLINE_SIZE_GB+=$y

  x=`hash_find PERVO_RESERVED_ONLINE_SIZE_GB ${PERVO_VONAME_INDEX}`
  y=`hash_find SA_RESERVED_ONLINE_SIZE_GB ${SA_UPP}`
  hash_insert PERVO_RESERVED_ONLINE_SIZE_GB ${PERVO_VONAME_INDEX} $((x+y))
  let GLOBAL_RESERVED_ONLINE_SIZE_GB+=$y

  x=`hash_find PERVO_FREE_ONLINE_SIZE_GB ${PERVO_VONAME_INDEX}`
  y=`hash_find SA_FREE_ONLINE_SIZE_GB ${SA_UPP}`
  hash_insert PERVO_FREE_ONLINE_SIZE_GB ${PERVO_VONAME_INDEX} $((x+y))
  let GLOBAL_FREE_ONLINE_SIZE_GB+=$y

  x=`hash_find PERVO_TOTAL_ONLINE_SIZE_GB ${PERVO_VONAME_INDEX}`
  y=`hash_find SA_TOTAL_ONLINE_SIZE_GB ${SA_UPP}`
  hash_insert PERVO_TOTAL_ONLINE_SIZE_GB ${PERVO_VONAME_INDEX} $((x+y))
  let GLOBAL_TOTAL_ONLINE_SIZE_GB+=$y

  x=`hash_find PERVO_TOTAL_NEARLINE_SIZE_GB ${PERVO_VONAME_INDEX}`
  y=`hash_find SA_TOTAL_NEARLINE_SIZE_GB ${SA_UPP}`
  hash_insert PERVO_TOTAL_NEARLINE_SIZE_GB ${PERVO_VONAME_INDEX} $((x+y))
  let GLOBAL_TOTAL_NEARLINE_SIZE_GB+=$y

  # Sum size values for VONAME (in KB)
  x=`hash_find PERVO_USED_ONLINE_SIZE_KB ${PERVO_VONAME_INDEX}`
  y=`hash_find SA_USED_ONLINE_SIZE_KB ${SA_UPP}`
  hash_insert PERVO_USED_ONLINE_SIZE_KB ${PERVO_VONAME_INDEX} $((x+y))
  let GLOBAL_USED_ONLINE_SIZE_KB+=$y

  x=`hash_find PERVO_AVAILABLE_ONLINE_SIZE_KB ${PERVO_VONAME_INDEX}`
  y=`hash_find SA_AVAILABLE_ONLINE_SIZE_KB ${SA_UPP}`
  hash_insert PERVO_AVAILABLE_ONLINE_SIZE_KB ${PERVO_VONAME_INDEX} $((x+y))
  let GLOBAL_AVAILABLE_ONLINE_SIZE_KB+=$y

done

#==========================================================
# Create GlueSE entries

if [ ${ERROR} -eq 0 ]; then
  cat >> ${FILE} << EOF
dn: GLUE2StorageServiceCapacityId=${STORM_FRONTEND_PUBLIC_HOST}/capacity/online,GLUE2ServiceId=${STORM_FRONTEND_PUBLIC_HOST},GLUE2GroupId=resource,o=glue
GLUE2StorageServiceCapacityTotalSize: $((GLOBAL_TOTAL_ONLINE_SIZE_GB))
GLUE2StorageServiceCapacityFreeSize: $((GLOBAL_FREE_ONLINE_SIZE_GB))
GLUE2StorageServiceCapacityUsedSize: $((GLOBAL_USED_ONLINE_SIZE_GB))
GLUE2StorageServiceCapacityReservedSize: $((GLOBAL_RESERVED_ONLINE_SIZE_GB))

EOF

  cat >> ${FILE} << EOF
dn: GLUE2StorageServiceCapacityId=${STORM_FRONTEND_PUBLIC_HOST}/capacity/nearline,GLUE2ServiceId=${STORM_FRONTEND_PUBLIC_HOST},GLUE2GroupId=resource,o=glue
GLUE2StorageServiceCapacityTotalSize: $((GLOBAL_TOTAL_NEARLINE_SIZE_GB))
GLUE2StorageServiceCapacityFreeSize: 0
GLUE2StorageServiceCapacityUsedSize: 0
GLUE2StorageServiceCapacityReservedSize: 0

EOF

  #==========================================================

  #==========================================================
  # Create Glue2Share entries

  for SA in ${STORM_STORAGEAREA_LIST}; do

    # Convert case
    SA_UPP=`echo ${SA} | tr '[:lower:]' '[:upper:]'`
    SA_LOW=`echo ${SA} | tr '[:upper:]' '[:lower:]'`

    # Remove DNS-like characters from SA_UPP names
    SA_UPP=`echo ${SA_UPP} | sed -e 's/-//g' -e 's/\.//g'`

    x=STORM_${SA_UPP}_ACCESSPOINT;     SA_ACCESSPOINT=${!x:-/${SA_LOW}}
    x=STORM_${SA_UPP}_TOKEN;           SA_TOKEN=${!x}
    x=STORM_${SA_UPP}_VONAME;          SA_VONAME=${!x:-${SA_LOW}}
    x=STORM_${SA_UPP}_STORAGECLASS;    SA_STORAGECLASS=${!x:-${STORM_STORAGECLASS}}
    x=STORM_${SA_UPP}_SERVINGSTATE;    SA_SERVING_STATE=${!x:-/${SA_SERVING_STATE}}
    # Convert in uppercase
    SA_STORAGECLASS=`echo ${SA_STORAGECLASS} | tr '[:lower:]' '[:upper:]'`

    # Check the STORAGECLASS
    SA_RETENTION_POLICY="replica"                                         # default
    SA_ACCESS_LATENCY="online"                                            # default
    SA_INSTALLED_ONLINE_CAPACITY=`hash_find SA_TOTAL_ONLINE_SIZE_GB ${SA_UPP}`   # default
    SA_INSTALLED_NEARLINE_CAPACITY=0                                      # default
    if ! [ -z "${SA_STORAGECLASS}" ]; then
      case ${SA_STORAGECLASS} in
        "T1D0")
          SA_RETENTION_POLICY="custodial"
          SA_ACCESS_LATENCY="nearline"
          SA_INSTALLED_ONLINE_CAPACITY=`hash_find SA_TOTAL_ONLINE_SIZE_GB ${SA_UPP}`
          SA_INSTALLED_NEARLINE_CAPACITY=`hash_find SA_TOTAL_NEARLINE_SIZE_GB ${SA_UPP}`
          ;;
        "T1D1")
          SA_RETENTION_POLICY="custodial"
          SA_ACCESS_LATENCY="online"
          SA_INSTALLED_ONLINE_CAPACITY=`hash_find SA_TOTAL_ONLINE_SIZE_GB ${SA_UPP}`
          SA_INSTALLED_NEARLINE_CAPACITY=0
          ;;
        "T0D1")
          SA_RETENTION_POLICY="replica"
          SA_ACCESS_LATENCY="online"
          SA_INSTALLED_ONLINE_CAPACITY=`hash_find SA_TOTAL_ONLINE_SIZE_GB ${SA_UPP}`
          SA_INSTALLED_NEARLINE_CAPACITY=0
          ;;
        *)
          SA_RETENTION_POLICY="replica"
          SA_ACCESS_LATENCY="online"
          SA_INSTALLED_ONLINE_CAPACITY=`hash_find SA_TOTAL_ONLINE_SIZE_GB ${SA_UPP}`
          SA_INSTALLED_NEARLINE_CAPACITY=0
          ;;
      esac
    fi

    SA_TOTAL_SIZE_GB=$(($((`hash_find SA_TOTAL_ONLINE_SIZE_GB ${SA_UPP}`))+$((`hash_find SA_TOTAL_NEARLINE_SIZE_GB ${SA_UPP}`))))

    cat >> ${FILE} << EOF
dn: GLUE2StorageShareCapacityID=${STORM_FRONTEND_PUBLIC_HOST}/${SA_LOW}/capacity,GLUE2ShareId=${STORM_FRONTEND_PUBLIC_HOST}/${SA_LOW},GLUE2ServiceId=${STORM_FRONTEND_PUBLIC_HOST},GLUE2GroupId=resource,o=glue
GLUE2StorageShareCapacityTotalSize: $((SA_TOTAL_SIZE_GB))
GLUE2StorageShareCapacityFreeSize: $((`hash_find SA_FREE_ONLINE_SIZE_GB ${SA_UPP}`))
GLUE2StorageShareCapacityUsedSize: $((`hash_find SA_USED_ONLINE_SIZE_GB ${SA_UPP}`))
GLUE2StorageShareCapacityReservedSize:  $((`hash_find SA_RESERVED_ONLINE_SIZE_GB ${SA_UPP}`))

EOF

  done

fi

#==========================================================

# Print built file
cat ${FILE}
rm -f ${FILE}

# Exit with success
exit 0
