Autor Tema: La red Golem  (Leído 897 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado Hwagm

  • Administrador
  • *
  • Mensajes: 17737
    • GNU/Linux Wifislax
La red Golem
« en: 25-09-2018, 09:52 (Martes) »
Conozco bastante este proyecto porque he formado parte de el en sus pruebas alpha iniciales

Es muy poderoso y permite una red extensa de ordenadores para realizar un trabajo

Imaginar el renderizado de un proyecto 3D importante donde una empresa no puede tener los equipos adecuados. Con la red golem y un coste bajo tiene a su disposición miles de equipos que efectuaran el trabajo

Es un poder de computo remoto.

Usa su crypto golem y ethereum

https://golem.network







Desconectado Hwagm

  • Administrador
  • *
  • Mensajes: 17737
    • GNU/Linux Wifislax
Re:La red Golem
« Respuesta #1 en: 21-09-2019, 11:43 (Sábado) »


Es una versión estable. El video es para Windows 10

Mas tarde hablaremos de linux

El problema actual es que hay más proveedores que solicitantes


La forma de pago es el golem integrado perfectamente en la Red ethreum

Antes el precio lo ponía el solicitante y tu decías por qué tarea mínima permitias ejecutar una tarea.

Ahora los precios se ha traspasado a los proveedores que pueden competir entre ellos respecto a precios y reputación

Es decir en la Red golem si importa el tamaño xd. O aquello de burro grande es mejor ande o no ande.

Como dije en sus fases iniciales yo formaba parte de la Red y la simulación entonces de lo obtenido me parecio interesante si bien es simulada y en las partes finales no pude updates porque no tengo los requisitos necesarios.

Actualmente no formó parte pero estoy por traerme del trabajo el nuevo bicho que me han comprado para usar el tía portal

What are the minimum requirements to run Golem?
We support Windows 10, OS X Sierra and higher, Ubuntu 16.04 LTS and Ubuntu 18.04 LTS. In general we recommend a processor with multiple cores and lots of RAM. At minimum, you can run Golem with:

2 GB RAM
2 cores
20 GB HDD
public IP or ability to forward ports or router with UPnP activated





« Última modificación: 21-09-2019, 11:44 (Sábado) por Hwagm »


Desconectado Hwagm

  • Administrador
  • *
  • Mensajes: 17737
    • GNU/Linux Wifislax
Re:La red Golem
« Respuesta #2 en: 21-09-2019, 12:01 (Sábado) »
Instalación para linux



1.- download script

https://raw.githubusercontent.com/golemfactory/golem/0.20.2/Installer/Installer_Linux/install.sh

Código: [Seleccionar]
#!/bin/bash
trap "exit" INT

# Meta information

SCRIPT_VERSION="0.1.0"
SCRIPT_AUTHOR="Karol Tomala"

# Default variables

DEBUG=0
DOWNLOAD_PROGRESS=0
CLEANUP_TMP=1
INSTALL_DEVELOP=0
INSTALL_OPTIONAL=0
NO_EXTENSIONS_INSTALL=0
EXTENSION_HASH_CHECK=1

EXTRA_PACKAGES=()
REMOVE_EXTRA_PACKAGES=()
HOLD_PACKAGES=()
UNHOLD_PACKAGES=()
AFTER_DEPENDENCY_INSTALL_FUNCTIONS=()

DOWNLOADERS=( curl wget )
DOWNLOAD_TMP_PATH=/tmp
MANIFEST_URL='https://golem-releases.cdn.golem.network/manifest.yml'
MANIFEST_FILE='golem_releases_manifest.yml'

SUPPORTED_OS=( linux )

MANIFEST_RELEASES_PREFIX="golem_releases"
MANIFEST_RELEASES_LATEST="${MANIFEST_RELEASES_PREFIX}_latest"
MANIFEST_RELEASES_PUBLISHED="${MANIFEST_RELEASES_PREFIX}_published"
MANIFEST_RELEASES_DESCRIPTIONS="${MANIFEST_RELEASES_PREFIX}_descriptions"

INSTALL_DESTINATION_PREFIX=/opt/golem
INSTALL_SYMLINK_PREFIX=/usr/local/bin

TMP_ERR_LOG=/tmp/golem_install_script.err.log

SKIP_DEPS_UPDATE=0
OVERWRITE=1

TYPEPRINT_DELAY=.005

DEFAULT_COMPONENT_STATUS="mandatory"

# Docker variables

DOCKER_GPG_KEY="https://download.docker.com/linux/ubuntu/gpg"
DOCKER_VERSION=
INSTALL_DOCKER=1
REMOVE_DOCKER=0
DOCKER_CONFIG_FILE="/etc/docker/daemon.json"

# Character maps

CHAR_UNICODE_SPIN='⡄⡆⡇⠇⠃⠋⠉⠙⠘⠚⠒⠖⠆⠦⠤⢤⢠⣠⣀⣄'
CHAR_ASCII_SPIN='-\|/'

# Message functions

err_msg () { local arg_msg=$*; echo "ERROR: $arg_msg" >&2; exit 1; }
warn_msg () { local arg_msg=$*; echo "WARNING: $arg_msg" >&2; }
debug_msg () { local arg_msg=$*; [ $DEBUG -eq 1 ] && echo "DEBUG: $arg_msg" >&2; }
info_msg () { local arg_msg=$*; echo "$arg_msg"; }
spinner_msg () {
  local arg_msg=$*
  if [ "$UNICODE_SUPPORT" == "Y" ]; then
    local bullet="⬝"
    local tick="✓"
    local cross="✕"
  else
    local bullet="*"
    local tick="+"
    local cross="-"
  fi
  printf " $bullet $arg_msg "
  spinner
  [ $PID_STATUS -eq 0 ] && printf "$tick\n" || printf "$cross\n"
  return $PID_STATUS
}

typeprint () {
  local x=$@
  for((i=0;i<${#x};i++));do echo -n "${x:$i:1}";sleep $TYPEPRINT_DELAY;done;echo
}

# Info functions

print_banner () {
  typeprint "Golem Linux Installer version $SCRIPT_VERSION"
}

# Helper functions

test_unicode () {
  echo -ne "\xe2\x88\xb4\033[6n\033[1K\r"
  read -d R foo
  echo -ne "\033[1K\r"
  echo -e "${foo}" | cut -d \[ -f 2 | cut -d";" -f 2 | (
    read UNICODE
    [ $UNICODE -eq 2 ] && return 0
    [ $UNICODE -ne 2 ] && return 1
  )
}

run_tput () {
  local arg_1=$1
  [ $TPUT_UNAVAILABLE -ne 0 ] && return 1
  $TPUT_RUNTIME "$arg_1"
  return 0
}

spinner () {
  # Process Id of the previous running command
  local pid=$!
  run_tput civis
  [ "$UNICODE_SUPPORT" == "Y" ] && spin="$CHAR_UNICODE_SPIN" || spin="$CHAR_ASCII_SPIN"
  printf ' '
  local i=0
  while kill -0 $pid 2>/dev/null
  do
    i=$(( (i+1) % ${#spin} ))
    printf "\b${spin:$i:1}"
    sleep .1
  done
  printf "\b \b"
  run_tput cnorm
  wait $pid
  PID_STATUS=$?
}

function_exists () {
  declare -f -F $1 > /dev/null
  return $?
}

parse_yaml () {
   local prefix=$2
   local s='[[:space:]]*' w='[a-zA-Z0-9_]*' fs=$(echo @|tr @ '\034')
   sed -ne "s|^\($s\):|\1|" \
        -e "s|^\($s\)\($w\)$s:$s[\"']\(.*\)[\"']$s\$|\1$fs\2$fs\3|p" \
        -e "s|^\($s\)\($w\)$s:$s\(.*\)$s\$|\1$fs\2$fs\3|p"  $1 |
   awk -F$fs '{
      indent = length($1)/2;
      vname[indent] = $2;
      for (i in vname) {if (i > indent) {delete vname[i]}}
      if (length($3) > 0) {
         vn=""; for (i=0; i<indent; i++) {vn=(vn)(vname[i])("_")}
         printf("%s%s%s=\"%s\"\n", "'$prefix'",vn, $2, $3);
      }
   }'
}

contains_element () {
  local e match="$1"
  shift
  for e; do [[ "$e" == "$match" ]] && return 0; done
  return 1
}

cleanup_tmp () {
  [ $CLEANUP_TMP -ne 1 ] && return
  rm -f $DOWNLOAD_TMP_PATH/$MANIFEST_FILE
}

# Downloader functions

download_curl () {
  local arg_url="$1"
  local arg_dst_file="$2"
  if [ $DOWNLOAD_PROGRESS -eq 1 ]; then
    $DOWNLOADER_RUNTIME -f -L --output "$DOWNLOAD_TMP_PATH/$arg_dst_file" --progress-bar "$arg_url"
    res=$?
  else
    $DOWNLOADER_RUNTIME -f -L -s --output "$DOWNLOAD_TMP_PATH/$arg_dst_file" "$arg_url"
    res=$?
  fi
  sleep 1
  return $res
}

download_wget () {
  local arg_url="$1"
  local arg_dst_file="$2"
  if [ $DOWNLOAD_PROGRESS -eq 1 ]; then
    $DOWNLOADER_RUNTIME --show-progress -q -O "$DOWNLOAD_TMP_PATH/$arg_dst_file" "$arg_url"
    res=$?
  else
    $DOWNLOADER_RUNTIME -q -O "$DOWNLOAD_TMP_PATH/$arg_dst_file" "$arg_url"
    res=$?
  fi
  return $res
}

download () {
  local arg_url=$1
  local arg_dst_file=$2
  local downloader_name=$( basename $DOWNLOADER_RUNTIME )
  local function_name="download_${downloader_name}"
  if ! function_exists $function_name; then
    err_msg "No such function: ${function_name}."
  fi
  debug_msg "Downloading $arg_url as file $DOWNLOAD_TMP_PATH/$arg_dst_file"
  $function_name "$arg_url" "$arg_dst_file"
  return $?
}

# Self-check functions

check_unicode () {
  test_unicode
  local RC=$?
  export UNICODE_SUPPORT=`[ $RC -eq 0 ] && echo "Y" || echo "N"`
  unset test_unicode
}

check_which () {
  $( which bash > /dev/null 2>&1 )
  return $?
}

check_app_exists () {
  local app_name=$1
  which $app_name > /dev/null 2>&1
  return $?
}

check_downloader () {
  debug_msg "Checking downloader availability"
  local exit_status=1
  for downloader in ${DOWNLOADERS[@]}; do
    local downloader_path=$( which $downloader 2>/dev/null; exit_status=$? )
    [ $exit_status -eq 0 ] && break
  done
  [ "$downloader_path" == "" ] && return 1
  echo $downloader_path
  return 0
}

check_tput () {
  debug_msg "Checking tput availability"
  local tput_path=$( which tput 2>/dev/null )
  res=$?
  echo $tput_path
  return $res
}

check_os () {
  local os_name=$( uname -s | awk '{print tolower($0)}' )
  local supported_os=$( echo ${SUPPORTED_OS[@]} | awk '{print tolower($0)}' )
  contains_element $os_name ${supported_os[@]} || err_msg "Installer does not support '$os_name' operating system."
}

check_distribution () {
  local distro_name=$( lsb_release -is 2>/dev/null | awk '{print tolower($0)}' )
  echo $distro_name
}

check_distribution_version () {
  local distro_version=$( lsb_release -rs 2>/dev/null | awk '{print tolower($0)}' )
  echo $distro_version
}

self_check () {
  debug_msg "Self check"
  check_unicode
  check_which || err_msg "No 'which' found in PATH."

  apps_to_check=( basename sed awk grep uname lsb_release cut uniq tr tar sha256sum )
  for app_name in ${apps_to_check[@]}; do
    check_app_exists "$app_name" || err_msg "No '$app_name' found in PATH."
  done

  check_os
  DOWNLOADER_RUNTIME=$( check_downloader )
  [ $? -ne 0 ] && err_msg "No suitable downloader found (one of: ${DOWNLOADERS[@]})."
  TPUT_RUNTIME=$( check_tput )
  TPUT_UNAVAILABLE=$?
}

cache_sudo () {
  # Just for getting password cached
  sudo ls > /dev/null 2>&1
}

# Manifest functions

manifest_check () {
  debug_msg "Checking manifest"
  local manifest_error="Manifest has improper format. Perhaps newer install script is required?"
  eval $( parse_yaml "$DOWNLOAD_TMP_PATH/$MANIFEST_FILE" )
  # local var_name="${MANIFEST_DEPENDENCY_PREFIX}_ubuntu_default"
  # [ -z ${!var_name+x} ] && err_msg "$manifest_error"
  [ -z ${golem_releases_latest+x} ] && err_msg "$manifest_error"
  [ -z ${golem_releases_published+x} ] && err_msg "$manifest_error"
  local release_descriptions=( $( compgen -A variable | grep "${MANIFEST_RELEASES_DESCRIPTIONS}" ) )
  [ ${#release_descriptions[@]} -eq 0 ] && err_msg "$manifest_error"
}

retrieve_manifest () {
  debug_msg "Retrieving manifest"
  rm -f $DOWNLOAD_TMP_PATH/${MANIFEST_FILE} > /dev/null 2>&1
  download "${MANIFEST_URL}" "${MANIFEST_FILE}" &
  spinner_msg "Downloading manifest" || err_msg "Failed downloading manifest."
  [ ! -f $DOWNLOAD_TMP_PATH/$MANIFEST_FILE ] && err_msg "Manifest file does not exist."
  manifest_check
}

# Dependency functions

failed_dependency_install () {
  local err_message=$1
  exec 2>&6 6>&-
  [ -f $TMP_ERR_LOG ] && echo -e "\nCommand returned errors:\n------------------------" && cat $TMP_ERR_LOG >&2 && rm -f $TMP_ERR_LOG && echo
  err_msg "${err_message}"
}

install_dependencies_ubuntu () {
  local dependencies=$@
  debug_msg "Installing dependencies for Ubuntu"
  exec 6>&2 2>$TMP_ERR_LOG
  if [ ${SKIP_DEPS_UPDATE} -eq 0 ]; then
    $( sudo apt-get update -y > /dev/null ) &
    spinner_msg "Updating apt repositories" || failed_dependency_install "Failed updating apt repositories."
  fi
  if [[ ! -z "$UNHOLD_PACKAGES" && ${#UNHOLD_PACKAGES[@]} -gt 0 ]]; then
    $( sudo apt-mark unhold ${UNHOLD_PACKAGES[@]} > /dev/null ) &
    spinner_msg "Unsetting packages hold: ${UNHOLD_PACKAGES[@]}" || failed_dependency_install "Failed packages unhold."
  fi
  if [[ ! -z "$HOLD_PACKAGES" && ${#HOLD_PACKAGES[@]} -gt 0 ]]; then
    $( sudo apt-mark unhold ${HOLD_PACKAGES[@]} > /dev/null ) &
    spinner_msg "Unsetting packages hold: ${HOLD_PACKAGES[@]}" || failed_dependency_install "Failed packages unhold."
  fi
  $( sudo apt-get install -y ${dependencies[@]} > /dev/null ) &
  spinner_msg "Installing dependencies" || failed_dependency_install "Failed dependency installation."
  if [[ ! -z "$EXTRA_PACKAGES" && ${#EXTRA_PACKAGES[@]} -gt 0 ]]; then
    $( sudo apt-get install -y ${EXTRA_PACKAGES[@]} > /dev/null ) &
    spinner_msg "Installing extra dependencies" || failed_dependency_install "Failed extra dependency installation."
  fi
  if [[ ! -z "$HOLD_PACKAGES" && ${#HOLD_PACKAGES[@]} -gt 0 ]]; then
    $( sudo apt-mark hold ${HOLD_PACKAGES[@]} > /dev/null ) &
    spinner_msg "Setting packages on hold: ${HOLD_PACKAGES[@]}" || failed_dependency_install "Failed packages hold."
  fi
  exec 2>&6 6>&-
}

install_dependencies () {
  local distro_name=$1
  local dependencies=${@:2}

  debug_msg "Installing dependencies"
  local function_name="install_dependencies_$distro_name"
  if ! function_exists $function_name; then
    err_msg "Cannot install dependencies. Distribution not supported: $distro_name. No such function: ${function_name}."
  fi
  $function_name "${dependencies[@]}"
}

resolve_dependencies () {
  local distro_name=$1
  local distro_version=$2
  local dependency_var="${MANIFEST_DEPENDENCY_PREFIX}_${distro_name}_${distro_version}"
  local references=( $( echo "${!dependency_var}" | grep -w -o -E -e "@[a-zA-Z0-9_]+" ) )
  local non_references=( $( echo "${!dependency_var}" | grep -o -P "(?:(?<=^)|(?<=\s))(?<!@)[a-zA-Z0-9-_.]+" ) )
  local result="${non_references[@]}"
  for reference in ${references[@]}; do
    local resolved_references=( $( resolve_dependencies "${distro_name}" "${reference:1}" ) )
    result+=" ${resolved_references[@]}"
  done
  echo "${result[@]}" | tr -s ' ' '\n' | sort -u | tr -s '\n' ' '
}

install_docker_ubuntu () {
  local docker_version=$1
  debug_msg "Installing docker on Ubuntu"
  exec 6>&2 2>$TMP_ERR_LOG
  $( sudo apt-get remove -y docker docker-engine docker.io > /dev/null ) &
  spinner_msg "Removing obsolete docker" || failed_dependency_install "Failed removing obsolete docker."
  if [[ ! -z "$REMOVE_DOCKER" && $REMOVE_DOCKER -eq 1 ]]; then
    $( sudo systemctl stop docker > /dev/null ) &
    spinner_msg "Stopping docker" || failed_dependency_install "Failed stopping docker."
    $( sudo apt-get remove -y docker-ce docker-ce-cli ${REMOVE_EXTRA_PACKAGES[@]} > /dev/null ) &
    spinner_msg "Removing installed docker-ce and extra packages" || failed_dependency_install "Failed removing docker-ce and extra packages."
  fi
  $( sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common > /dev/null ) &
  spinner_msg "Installing docker dependencies" || failed_dependency_install "Failed installing docker dependencies."
  $( download "$DOCKER_GPG_KEY" "docker-repo-key.gpg"; sudo apt-key add $DOWNLOAD_TMP_PATH/docker-repo-key.gpg > /dev/null ) &
  spinner_msg "Adding docker repository GPG key" || failed_dependency_install "Failed adding docker repository GPG key."
  $( sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" > /dev/null ) &
  spinner_msg "Adding docker repository" || failed_dependency_install "Failed adding docker repository."
  if [ $SKIP_DEPS_UPDATE -eq 0 ]; then
    $( sudo apt-get update -y > /dev/null ) &
    spinner_msg "Updating packages" || failed_dependency_install "Failed updating packages."
  fi
  local docker_version_to_install="docker-ce"
  [ ! -z "$docker_version" ] && docker_version_to_install="docker-ce=${docker_version}"
  $( sudo apt-get install -y --allow-change-held-packages ${docker_version_to_install} > /dev/null ) &
  spinner_msg "Installing docker-ce" || failed_dependency_install "Failed installing docker-ce."
  if [ -z "${SUDO_USER}" ]; then
    $( sudo usermod -aG docker ${USER} ) &
  else
    $( sudo usermod -aG docker ${SUDO_USER} ) &
  fi
  spinner_msg "Add user to docker group." || failed_dependency_install "Cannot add user to docker group."
  $( sudo systemctl restart docker ) &
  spinner_msg "Restarting docker" || failed_dependency_install "Failed to restart docker."
  $( sudo docker run hello-world > /dev/null 2>&1 ) &
  spinner_msg "Testing docker is running" || failed_dependency_install "Docker cannot run hello-world. Testing failed."
  exec 2>&6 6>&-
}

install_docker () {
  local distro_name=$1
  local docker_version=$2
  local function_name="install_docker_$distro_name"
  if ! function_exists $function_name; then
    err_msg "Cannot install docker. Distribution not supported: $distro_name. No such function: ${function_name}."
  fi
  $function_name "${docker_version}"
}

check_package_installed_version_ubuntu () {
  echo $(dpkg -l 2>/dev/null | grep "$@\s" | grep -E 'hi|ii' | head -1 | awk '{print $3}')
}

check_package_installed_version () {
  local distro_name=$1
  local package_name=$2
  local function_name="check_package_installed_version_$distro_name"
  if ! function_exists $function_name; then
    err_msg "Cannot check package installed. Distribution not supported: $distro_name. No such function: ${function_name}."
  fi
  $function_name "${package_name}"
}

check_distro_installer_ubuntu () {
  local ubuntu_installer_components=( apt-get add-apt-repository apt-key )
  for installer_component in ${ubuntu_installer_components[@]}; do
    check_app_exists "$installer_component" || err_msg "No '$installer_component' found in PATH."
  done
}

check_distro_installer () {
  local distro_name=$1
  local function_name="check_distro_installer_$distro_name"
  if ! function_exists $function_name; then
    err_msg "Cannot check distro installer. Distribution not supported: $distro_name. No such function: ${function_name}."
  fi
  $function_name
}

parse_dependencies () {
  debug_msg "Parse dependencies"
  local distro_name=$( check_distribution )
  local supported_distros=( $( compgen -A variable | grep "${MANIFEST_DEPENDENCY_PREFIX}_" | cut -d_ -f8 | uniq ) )
  debug_msg "${MANIFEST_DEPENDENCY_PREFIX}"
  debug_msg "Script supported distributions: ${supported_distros[@]}"
  debug_msg "Found distribution name: $distro_name"
  if ! contains_element "$distro_name" "${supported_distros[@]}"; then
    err_msg "Linux distribution '$distro_name' is not supported by this installer."
  fi
  local distro_version=$( check_distribution_version | tr -s '.' '_' )
  local supported_versions=( $( compgen -A variable | grep "${MANIFEST_DEPENDENCY_PREFIX}_${distro_name}_" | cut -d_ -f9- | uniq ) )
  if ! contains_element "$distro_version" "${supported_versions[@]}"; then
    if ! contains_element "default" "${supported_versions[@]}"; then
      err_msg "Manifest file does not have dependency definition for this distribution version, nor default one."
    else
      distro_version="default"
    fi
  fi
  debug_msg "Supported distribution version: $distro_version"
  check_distro_installer "$distro_name"
  [ $INSTALL_DOCKER -ne 0 ] && install_docker "$distro_name" "${DOCKER_VERSION}"
  local dependencies=( $( resolve_dependencies "${distro_name}" "$distro_version" ) )
  install_dependencies "$distro_name" "${dependencies[@]}"
  for after_dependency_func in ${AFTER_DEPENDENCY_INSTALL_FUNCTIONS[@]}; do
    ${after_dependency_func} "$distro_name"
  done
}

# Extensions install

parse_extensions () {
  debug_msg "Parse extensions for $install_release_version"
  local install_release_version=$1
  local extensions_list=( $( compgen -A variable | grep "${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_extensions" | cut -d_ -f8 | uniq ) )
  [ ${#extensions_list[@]} -eq 0 ] && debug_msg "No extensions found for release in manifest." && return

  for extension in ${extensions_list[@]}; do
    local extension_script_var="${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_extensions_${extension}_script"
    local extension_hash_var="${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_extensions_${extension}_hash"
    [[ -z ${extension_script_var} || "${!extension_script_var}" == "" ]] && warn_msg "Extension '${extension}' has no script defined in manifest. Skipping..." && continue
    if [ $EXTENSION_HASH_CHECK -eq 1 ]; then
      [[ -z ${extension_hash_var} || "${!extension_hash_var}" == "" ]] && warn_msg "Extension '${extension}' has no hash defined in manifest. Skipping..." && continue
    fi

    local extension_script=${!extension_script_var}
    local extension_file=${extension_script##*/}
    download "${extension_script}" "${extension_file}" &
    spinner_msg "Downloading install script for extension '$extension'" || { warn_msg "Failed downloading extension script. Skipping..." && continue; }

    if [ $EXTENSION_HASH_CHECK -eq 1 ]; then
      local extension_file_hash=$( sha256sum ${DOWNLOAD_TMP_PATH}/${extension_file} | cut -d\  -f1 )
      [ "$extension_file_hash" != "${!extension_hash_var}" ] && warn_msg "Extension hash '${extension}' mismatch. Skipping..." && continue
    fi

    source "${DOWNLOAD_TMP_PATH}/${extension_file}"

  done
}

# Installation functions

install_release () {
  local release_file=$1
  local release_version=$2
  local release_links=${@:3}

  debug_msg "Installing release"
  exec 6>&2 2>$TMP_ERR_LOG
  if [ ! -d $INSTALL_DESTINATION ]; then
    sudo mkdir -p $INSTALL_DESTINATION > /dev/null || failed_dependency_install "Cannot create directory: $INSTALL_DESTINATION"
  else
    [ $OVERWRITE -ne 1 ] && failed_dependency_install "Installation destination path already exists: $INSTALL_DESTINATION"
    warn_msg "Installation destination path already exists! Overwriting."
  fi
  $( sudo tar -C $INSTALL_DESTINATION -xzf $DOWNLOAD_TMP_PATH/$release_file --strip-components 1 > /dev/null ) &
  spinner_msg "Extracting release archive ${release_file} to ${INSTALL_DESTINATION}" || failed_dependency_install "Failed extracting archive '${release_file}'."

  if [ ${#release_links[@]} -ne 0 ]; then
    for release_link in ${release_links[@]}; do
      [ ! -f ${INSTALL_DESTINATION}/$release_link ] && warn_msg "Cannot symlink ${release_link}. File not found." && continue
      $( sudo ln -fs ${INSTALL_DESTINATION}/$release_link $INSTALL_SYMLINK_PREFIX ) &
      spinner_msg "Symlinking ${release_link} to ${INSTALL_SYMLINK_PREFIX}" || failed_dependency_install "Failed symlinking '${release_link}'."
    done
  fi
  exec 2>&6 6>&-
}

install_component () {
  local component_file=$1
  local component_name=$2
  local component_destination=$3
  [[ -z ${component_destination+x} || "$component_destination" == "" ]] && component_destination=$INSTALL_DESTINATION
  local component_links=${@:4}

  debug_msg "Installing release component $component_name"
  exec 6>&2 2>$TMP_ERR_LOG
  if [ ! -d $component_destination ]; then
    sudo mkdir -p $component_destination > /dev/null || failed_dependency_install "Cannot create directory: $component_destination"
  fi
  $( sudo tar -C $component_destination -xzf $DOWNLOAD_TMP_PATH/$component_file --strip-components 1 > /dev/null ) &
  spinner_msg "Extracting component archive ${component_file} to ${component_destination}" || failed_dependency_install "Failed extracting archive '${component_file}'."

  if [ ${#component_links[@]} -ne 0 ]; then
    for component_link in ${component_links[@]}; do
      [ ! -f ${component_destination}/$component_link ] && warn_msg "Cannot symlink ${component_link}. File not found." && continue
      $( sudo ln -fs ${component_destination}/$component_link $INSTALL_SYMLINK_PREFIX ) &
      spinner_msg "Symlinking ${component_link} to ${INSTALL_SYMLINK_PREFIX}" || failed_dependency_install "Failed symlinking '${component_link}'."
    done
  fi
  exec 2>&6 6>&-
}

parse_releases () {
  local install_version=$1
  local release_latest=${!MANIFEST_RELEASES_LATEST}
  [[ -z ${install_version+x} || "$install_version" == "" ]] && install_version=$release_latest
  local release_published=( ${!MANIFEST_RELEASES_PUBLISHED} )
  contains_element $install_version ${release_published[@]} || err_msg "Manifest does not have Golem release '$install_version' in published versions."
  local release_descriptions=( $( compgen -A variable | grep "${MANIFEST_RELEASES_DESCRIPTIONS}" | cut -d_ -f4-6 | uniq ) )
  [ ${#release_descriptions[@]} -eq 0 ] && err_msg "Manifest does not have at least one release version description."
  local release_descriptions_versions=( $( echo ${release_descriptions[@]} | tr -s '_' '.' ) )
  contains_element $release_latest ${release_descriptions_versions[@]} || err_msg "Manifest has latest release set, but no release description found."
  contains_element $install_version ${release_descriptions_versions[@]} || err_msg "Manifest has no release '$install_version' description."
  local install_release_version=$( echo $install_version | tr -s '.' '_' )

  local release_description=( $( compgen -A variable | grep "${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}" ) )
  local release_status_var="${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_status"
  contains_element $release_status_var ${release_description[@]} || err_msg "Release description for version '$install_version' does not have 'status'."
  local release_status=${!release_status_var}
  [[ "$release_status" != "release" && $INSTALL_DEVELOP -ne 1 ]] && err_msg "You are trying to install development version, but no --develop flag was specified."

  local release_url_var="${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_url"
  contains_element $release_url_var ${release_description[@]} || err_msg "Release description for version '$install_version' does not have 'url'."
  local release_url=${!release_url_var}
  local release_file=${release_url##*/}

  local release_links=()
  local release_links_var="${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_links"
  [[ -z $release_links_var || "${!release_links_var}" == "" ]] || release_links=( ${!release_links_var} )

  MANIFEST_DEPENDENCY_PREFIX="${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_dependencies"

  parse_extensions "${install_release_version}"

  parse_dependencies

  $( download "${release_url}" "${release_file}" ) &
  spinner_msg "Downloading release ${install_version}" || err_msg "Failed downloading release '${install_version}'."

  INSTALL_DESTINATION=$INSTALL_DESTINATION_PREFIX/$install_version

  install_release "$release_file" "$install_version" "${release_links[@]}"

  local component_install=0
  local release_components_vars=( $( compgen -A variable | grep "${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_components" ) )
  [ ${#release_components_vars[@]} -eq 0 ] && component_install=0 || component_install=1

  if [ $component_install -eq 1 ]; then
    local release_components=( $( compgen -A variable | grep "${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_components_" | cut -d_ -f8 | uniq ) )
    for release_component in ${release_components[@]}; do
      local release_component_url_var="${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_components_${release_component}_url"
      local release_component_url=${!release_component_url_var}
      local release_component_file=${release_component_url##*/}

      local release_component_path_var="${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_components_${release_component}_path"
      local release_component_path=""
      [ -z ${release_component_path_var+x} ] || release_component_path=$INSTALL_DESTINATION/${!release_component_path_var}

      local release_component_links_var="${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_components_${release_component}_links"
      local release_component_links=()
      [ -z ${release_component_links_var+x} ] || release_component_links="${!release_component_links_var}"

      local release_component_status_var="${MANIFEST_RELEASES_DESCRIPTIONS}_${install_release_version}_components_${release_component}_status"
      local release_component_status=$DEFAULT_COMPONENT_STATUS
      [[ -z ${release_component_status_var+x} || "${!release_component_status_var}" == "" ]] || release_component_status="${!release_component_status_var}"

      local release_component_install=1
      [[ "$release_component_status" == "optional" && $INSTALL_OPTIONAL -eq 0 ]] && release_component_install=0 && warn_msg "Component ${release_component} is optional. Skipping... If you want to install it, rerun installer with --optional."

      if [ $release_component_install -eq 1 ]; then
        $( download "${release_component_url}" "${release_component_file}" ) &
        spinner_msg "Downloading install component ${release_component}" || err_msg "Failed downloading install component '${release_component_file}'."

        install_component "$release_component_file" "$release_component" "$release_component_path" "${release_component_links[@]}"
      fi
    done
  fi
}

# Option parsing functions

print_usage () {
  echo "Usage: $0 [-h] [-d][-D][-m URL][-o][-O][-t TMP][-V VER]"
}

print_help () {
  print_banner
  echo -e "Options:"
  echo -e "  -h --help              Show help."
  echo -e "  -d --develop           Install development version."
  echo -e "  -D --debug             Show debug messages."
  echo -e "  -E --no-extensions     Do not try to install extensions."
  echo -e "  -m --manifest-url URL  Manifest URL."
  echo -e "  -o --optional          Install optional components."
  echo -e "  -O --overwrite         Overwrite existing installation."
  echo -e "  -s --symlink-prefix PREFIX    Location of symlinks to binaries."
  echo -e "  --skip-deps-update     Skip dependency update."
  echo -e "  -t --temp-path TMP     Download temporary path (default: ${DOWNLOAD_TMP_PATH})."
  echo -e "  -V --version VER       Install Golem version."
}

parse_options () {
  while (( "$#" )); do
    case "$1" in
      '-h' | '--help')
        print_help
        exit 1
        ;;
      '-d' | '--develop')
        INSTALL_DEVELOP=1
        ;;
      '-D' | '--debug')
        DEBUG=1
        ;;
      '-E' | '--no-extensions')
        NO_EXTENSIONS_INSTALL=1
        ;;
      '-o' | '--optional')
        INSTALL_OPTIONAL=1
        ;;
      '-O' | '--overwrite')
        OVERWRITE=1
        ;;
      '-m' | '--manifest-url')
        shift
        [[ -z $1 || "$1" == "" || "${1:0:1}" == "-" ]] && err_msg "--manifest-url requires URL argument."
        MANIFEST_URL="$1"
        ;;
      '-s' | '--symlink-prefix')
        shift
        [[ -z $1 || "$1" == "" || "${1:0:1}" == "-" ]] && err_msg "--symlink-prefix requires PREFIX argument."
        INSTALL_SYMLINK_PREFIX="$1"
        ;;
      '--skip-deps-update')
        SKIP_DEPS_UPDATE=1
        ;;
      '-V' | '--version')
        shift
        [[ -z $1 || "$1" == "" || "${1:0:1}" == "-" ]] && err_msg "--version requires VER argument."
        VERSION_TO_INSTALL=$1
        ;;
      '-t' | '--temp-path')
        shift
        [[ -z $1 || "$1" == "" || "${1:0:1}" == "-" ]] && err_msg "--temp-path requires TMP argument."
        DOWNLOAD_TMP_PATH=$1
        [ ! -d $DOWNLOAD_TMP_PATH ] && err_msg "Temporary path '$DOWNLOAD_TMP_PATH' does not exist."
        ;;
      *)
        print_usage
        err_msg "ERROR: Unknown option: $1"
        exit 1
        ;;
    esac
    shift
  done
}

# Main function

main () {
  parse_options $@
  print_banner
  self_check
  cache_sudo
  retrieve_manifest
  parse_releases "${VERSION_TO_INSTALL}"
  info_msg "Golem has been installed succesfully."
}

main $@

2. - abrimos shell y ejecutamos

Código: [Seleccionar]
chmod +x install.sh && ./install.sh



Link foto sacada de un buen sitio donde explica muy bien la red golem

https://criptotendencia.com/2019/03/11/generar-ingresos-pasivos-en-criptomonedas-golem-parte-ii/

https://criptotendencia.com/2019/03/07/como-generar-ingresos-pasivos-con-criptomonedas-golem-parte-i/



« Última modificación: 21-09-2019, 12:18 (Sábado) por Hwagm »