Open Source Projects Europe

#!/bin/bash -e

COL_DEFAULT='\e[0;00m'
COL_BLUE='\e[0;96m'
COL_GREEN='\e[0;92m'


mkdir -p ${BUNDLES_DIR}

CODE_ZIP_FILENAME="code.zip"
NPMINSTALL="
cd /tmp/component
while [ ! -f node_modules/.bin/coffee ]; do
  [ -d node_modules ] && rm -rf node_modules
  npm install --production
done
"

export DOCKER="docker"
if $(groups|grep -qvw docker); then
  # No estamos en el grupo docker. Probamos a ver si somos sudoers
  sudo -n true
  if [ $? == 0 ]; then
    export DOCKER="sudo docker"
  else
    echo "Imposible ejecutar docker"
    exit -1
  fi
fi

function checkProjectDir() {
  ls ${C2NET_DIR}
}

function buildComponent() {
  INITIAL_DIR="${PWD}"
  COMPONENT_NAME=$1
  RUNTIME=${2:-node}

  COMP_DIR="${C2NET_DIR}/${COMPONENT_NAME}"
  COMP_BUNDLES_DIR="${BUNDLES_DIR}/${COMPONENT_NAME}"
  BLOB_BUNDLE_COMPONENT_NAME="${SERVICE_NAME}-${COMPONENT_NAME}-code-blob"

  echo -e $COL_GREEN"* Bundling component ${COMPONENT_NAME}..."$COL_DEFAULT
  echo ""

  cd ${COMP_DIR}
  mkdir -p ${COMP_BUNDLES_DIR}

  cd code/src

  if [ "$RUNTIME" == "node" ]; then

    echo "  - Compiling using NodeJS runtime - c2netproject.eu/runtime/nodejs:1_0_0"
    # Launch npm install in a Docker container compatible with the Runtime
    $DOCKER run --rm "$DNS" -v $PWD:/tmp/component --entrypoint=bash c2netproject.eu/runtime/nodejs:1_0_0 -c "$NPMINSTALL"


    echo "  - Completed npm install"

    # Copy src + package.json to bundles
    cp -fr ${COMP_DIR} ${COMP_BUNDLES_DIR}
    echo "  - Component copied: ${COMPONENT_NAME}"

    # Remove node_modules (requires root)
    $DOCKER run --rm -v $PWD:/tmp/component --entrypoint=bash c2netproject.eu/runtime/nodejs:1_0_0 -c "rm -rf node_modules"
    echo "  - Deleted node_modules"

  elif [ "$RUNTIME" == "java" ]; then
    echo "  - Compiling using JAVA runtime: $DEV_DOCKER_IMAGE"
    rm -rf build
    javaCompile $PWD
    cd build
    zip -r ${COMP_BUNDLES_DIR}/${CODE_ZIP_FILENAME} .
    echo "  - Created code zip: ${CODE_ZIP_FILENAME}"
    cd ..

    $DOCKER run "$DNS" --rm -v $PWD:/tmp/component --entrypoint=bash $DEV_DOCKER_IMAGE -c 'rm -rf build'
    echo "  - Deleted build dir"

  elif [ "$RUNTIME" == "mariadb" ]; then
    echo "  - Compiling using MariaDB runtime - eslap.cloud/runtime/mariadb:1_0_0"
    # Launch npm install in a Docker container compatible with the Runtime
    $DOCKER run "$DNS" --rm -v $PWD:/tmp/component --entrypoint=bash eslap.cloud/runtime/mariadb:1_0_0 -c "$NPMINSTALL"
    echo "  - Completed npm install"

    # Create code zip (src + package.json)
    zip -q -r ${COMP_BUNDLES_DIR}/${CODE_ZIP_FILENAME} .
    echo "  - Created code zip: ${CODE_ZIP_FILENAME}"

    # Remove node_modules (requires root)
    $DOCKER run --rm -v $PWD:/tmp/component --entrypoint=bash eslap.cloud/runtime/mariadb:1_0_0 -c "rm -rf node_modules"
    echo "  - Deleted node_modules"
  fi



#  cd ../..
#
#  cd ${COMP_BUNDLES_DIR}
#  COMP_BLOB_SHA1=$(sha1sum ${CODE_ZIP_FILENAME} | awk '{print $1}')
#  createBlobBundle ${BLOB_BUNDLE_COMPONENT_NAME} ${COMP_BLOB_SHA1}
#  echo "  - Generated blob manifest"
#
#  # Create component code blob bundle
#  zip -r blobBundle_component_${COMPONENT_NAME}.zip Manifest.json ${CODE_ZIP_FILENAME}
#  echo "  - Generated blob bundle for code: blobBundle_component_${COMPONENT_NAME}.zip"
#  mv Manifest.json Manifest_blob.json
#
#  # Create component bundle
#  cp ${COMP_DIR}/Manifest.json Manifest.json
#  sed -i -e "s/\"code\"\s*:\s*\".*\"/\"code\": \"${BLOB_BUNDLE_COMPONENT_NAME}\"/g" Manifest.json
#  rm -f component_bundle_${COMPONENT_NAME}.zip
#  zip -r $BUNDLES_DIR/component_bundle_${COMPONENT_NAME}.zip Manifest.json blobBundle_component_${COMPONENT_NAME}.zip
#  echo "  - Generated component bundle: component_bundle_${COMPONENT_NAME}.zip"
#  rm Manifest.json \
#    blobBundle_component_${COMPONENT_NAME}.zip \
#    Manifest_blob.json \
#    code.zip
#
#  # Reset the current directory to the original one
#  cd ${INITIAL_DIR}
#  rm -rf ${COMP_BUNDLES_DIR}
#  echo ""
}


function bundleService() {
  INITIAL_DIR="${PWD}"

  COMP_DIR="${C2NET_DIR}/${COMPONENT_NAME}"
  COMP_BUNDLES_DIR="${BUNDLES_DIR}/${COMPONENT_NAME}"
  BLOB_BUNDLE_COMPONENT_NAME="${SERVICE_NAME}-${COMPONENT_NAME}-code-blob"

  SERV_DIR="${PROJECT_DIR}/service"
  SERV_BUNDLES_DIR="${SERV_DIR}/bundles"
  BLOB_BUNDLE_SERVICE_NAME="${SERVICE_NAME}-service-code-blob"

  echo ${BUNDLES_DIR}
  echo ${PROJECT_DIR}
  echo ${SERV_DIR}
  echo ${SERV_BUNDLES_DIR}
  echo ${BLOB_BUNDLE_SERVICE_NAME}

  exit 0

  echo -e $COL_GREEN"* Bundling service..."$COL_DEFAULT
  echo ""

  cd ${SERV_DIR}
  mkdir -p ${SERV_BUNDLES_DIR}

  # Create code zip for configuration spread
  if [ -d $SERV_DIR/src ]; then
    cd src && zip -r ${SERV_BUNDLES_DIR}/${CODE_ZIP_FILENAME} . && cd ..
    echo "  - Created code zip: ${CODE_ZIP_FILENAME}"

    # Create blob manifest for SERVICE code zip
    cd ${SERV_BUNDLES_DIR}
    SERV_BLOB_SHA1=$(sha1sum ${CODE_ZIP_FILENAME} | awk '{print $1}')
    createBlobBundle ${BLOB_BUNDLE_SERVICE_NAME} ${SERV_BLOB_SHA1}
    echo "  - Generated blob manifest"
    # Create service code blob bundle
    zip -r blobBundle_service.zip Manifest.json ${CODE_ZIP_FILENAME}
    echo "  - Generated blob bundle for code: blobBundle_service.zip"
    mv Manifest.json Manifest_blob.json
  fi

  cd ${SERV_BUNDLES_DIR}
  # Create service bundle
  cp ${SERV_DIR}/Manifest.json Manifest.json
  if [ -d $SERV_DIR/src ]; then
    sed -i -e "s/\"code\"\s*:\s*\".*\"/\"code\": \"${BLOB_BUNDLE_SERVICE_NAME}\"/g" Manifest.json
    rm -f service_bundle.zip
    zip -r ${COMP_BUNDLES_DIR}/service_bundle.zip Manifest.json blobBundle_service.zip
    mv Manifest.json Manifest_service.json
  else
    zip ${BUNDLES_DIR}/service_bundle.zip Manifest.json
  fi
  echo "  - Generated service bundle: service_bundle.zip"

  cd ${INITIAL_DIR}
  rm -rf ${SERV_BUNDLES_DIR}
  echo ""
}


function bundleAll() {
  INITIAL_DIR="${PWD}"

  echo -e $COL_GREEN"* Bundling everything..."$COL_DEFAULT
  echo ""

  cd ${PROJECT_DIR}

  # Create deployment bundle
  rm -f ${BUNDLES_DIR}/deploy_bundle.zip || true
  zip -r ${BUNDLES_DIR}/deploy_bundle.zip \
    Manifest.json \
    resources
  cd ${BUNDLES_DIR}
  zip -g ${BUNDLES_DIR}/deploy_bundle.zip \
    service_bundle.zip \
    component_bundle_*.zip

  echo "  - Generated deployment bundle: deploy_bundle.zip"

  cd ${INITIAL_DIR}
  echo ""
}

function createBlobBundle() {
  name=$1
  hash=$2
  cat <<EOF >Manifest.json
{
  "spec" : "http://eslap.cloud/manifest/blob/1_0_0",
  "name" : "$name",
  "hash" : "$hash"
}
EOF
}

function javaCompile() {
  folder=$1
  echo "JavaCompile: $folder"
  echo "JavaCompile: Creating build folder"
  mkdir -p $folder/build/classes
  echo "JavaCompile: Copying lib folder to build folder"
  cp -r $folder/lib $folder/build/
  echo "JavaCompile: Creating build.sh"
  cat <<EOF >$folder/build/build.sh
  JAVALIB="/eslap/java-runtime-lib"
  for i in \$(find \$JAVALIB -name "*.jar");do CLASSPATH="\$i:\$CLASSPATH";done
  JAVAMYLIB="/tmp/component/lib"
  for i in \$(find \$JAVAMYLIB -name "*.jar");do CLASSPATH="\$i:\$CLASSPATH";done
  export CLASSPATH
  cd /tmp/component
  find -name "*.java" > sources.txt
  javac -d build/classes @sources.txt
  cp component.properties build
EOF
  #javac -d build/classes $(find src -name "*.java")
  echo "JavaCompile: Calling Docker"
  $DOCKER run --rm -v $folder:/tmp/component --entrypoint=bash $DEV_DOCKER_IMAGE -c '. /tmp/component/build/build.sh'
  rm $folder/build/build.sh

}