{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [], "toc_visible": true }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" } }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "view-in-github" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "source": [ "
\n", "\n", "# Hadoop MiniCluster\n", "
\n", "
\n", "\n", "The Hadoop MiniCluster is a lightweight, single-node Hadoop cluster that is primarily used for testing and development purposes. It provides a way to simulate a distributed Hadoop environment on a single machine, allowing developers to experiment with and test their Hadoop applications without the need for a full-scale, multi-node cluster.\n", "\n", "Quote from [the official Hadoop documentation](https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/CLIMiniCluster.html):\n", "\n", "\n", "> *Using the CLI MiniCluster, users can simply start and stop a single-node Hadoop cluster with a single command, and without the need to set any environment variables or manage configuration files. The CLI MiniCluster starts both a YARN/MapReduce & HDFS clusters.*\n", "\n", "\n", "In this notebook we download the Hadoop core and guide you through the steps required to launch the MiniCluster." ], "metadata": { "id": "OFLizmmFvTjK" } }, { "cell_type": "code", "source": [ "# @title\n", "from IPython.core.display import HTML\n", "HTML(\"\"\"\n", "
\n", "\n", " \n", " \n", " \n", " Note:\n", "While the MiniCluster is useful for many development and testing scenarios, it's important to note that it does not fully replicate the complexities and challenges of a true multi-node Hadoop cluster. For production-scale testing or performance evaluations, a larger, more representative cluster setup is recommended.\n", "
\n", "\"\"\")" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 98 }, "id": "8Rl-ti3i2aWM", "outputId": "e93a8d0e-0eb8-4fee-edb3-04e10a4fd0d4", "cellView": "form" }, "execution_count": 1, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ], "text/html": [ "\n", "
\n", "\n", " \n", " \n", " \n", " Note:\n", "While the MiniCluster is useful for many development and testing scenarios, it's important to note that it does not fully replicate the complexities and challenges of a true multi-node Hadoop cluster. For production-scale testing or performance evaluations, a larger, more representative cluster setup is recommended.\n", "
\n" ] }, "metadata": {}, "execution_count": 1 } ] }, { "cell_type": "markdown", "source": [ "## About this tutorial\n", "\n", "This tutorial dives deep to help you really get the hang of things, explaining every step in Big Data processing, even if it takes a bit of time, so just hang in there and be patient! \"Running" ], "metadata": { "id": "piPXIeS3KPDd" } }, { "cell_type": "markdown", "source": [ "# Preamble" ], "metadata": { "id": "Plpb6qoZ8EVh" } }, { "cell_type": "markdown", "source": [ "## Download Hadoop" ], "metadata": { "id": "xvhtO--1RWug" } }, { "cell_type": "code", "source": [ "import urllib.request\n", "import os\n", "import shutil\n", "import tarfile\n", "import logging\n", "import subprocess\n", "import time\n", "import sys\n", "############\n", "# COSTANTS #\n", "############\n", "\n", "# URL for downloading Hadoop (archive site https://archive.apache.org/dist/)\n", "HADOOP_URL = \"https://archive.apache.org/dist/hadoop/core/hadoop-3.4.0/hadoop-3.4.0.tar.gz\"\n", "\n", "# logging level (should be one of: DEBUG, INFO, WARNING, ERROR, CRITICAL)\n", "LOGGING_LEVEL = \"INFO\" #@param [\"DEBUG\", \"INFO\", \"WARNING\", \"ERROR\", \"CRITICAL\"]\n", "\n", "# setup logging\n", "for handler in logging.root.handlers[:]:\n", " logging.root.removeHandler(handler)\n", "\n", "logging_level = getattr(logging, LOGGING_LEVEL.upper(), 10)\n", "\n", "logging.basicConfig(level=logging_level, \\\n", " format='%(asctime)s - %(levelname)s: %(message)s', \\\n", " datefmt='%d-%b-%y %I:%M:%S %p')\n", "\n", "logger = logging.getLogger('my_logger')\n", "\n", "JAVA_PATH = '/usr/lib/jvm/java-11-openjdk-amd64'\n", "\n", "# true if running on Google Colab\n", "IN_COLAB = 'google.colab' in sys.modules\n", "if IN_COLAB:\n", " from google.colab import output\n", "\n", "# setup logging\n", "for handler in logging.root.handlers[:]:\n", " logging.root.removeHandler(handler)\n", "\n", "logging_level = getattr(logging, LOGGING_LEVEL.upper(), 10)\n", "\n", "logging.basicConfig(level=logging_level, \\\n", " format='%(asctime)s - %(levelname)s: %(message)s', \\\n", " datefmt='%d-%b-%y %I:%M:%S %p')\n", "\n", "logger = logging.getLogger('my_logger')\n", "\n", "# set variable JAVA_HOME (install Java if necessary)\n", "def is_java_installed():\n", " os.environ['JAVA_HOME'] = os.path.realpath(shutil.which(\"java\")).split('/bin')[0]\n", " return os.environ['JAVA_HOME']\n", "\n", "def install_java():\n", " # Uncomment and modify the desired version\n", " # java_version= 'openjdk-11-jre-headless'\n", " # java_version= 'default-jre'\n", " # java_version= 'openjdk-17-jre-headless'\n", " # java_version= 'openjdk-18-jre-headless'\n", " java_version= 'openjdk-19-jre-headless'\n", "\n", " print(f\"Java not found. Installing {java_version} ... (this might take a while)\")\n", " try:\n", " cmd = f\"apt install -y {java_version}\"\n", " subprocess_output = subprocess.run(cmd, shell=True, check=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)\n", " stdout_result = subprocess_output.stdout\n", " # Process the results as needed\n", " logger.info(\"Done installing Java {}\".format(java_version))\n", " os.environ['JAVA_HOME'] = os.path.realpath(shutil.which(\"java\")).split('/bin')[0]\n", " logger.info(\"JAVA_HOME is {}\".format(os.environ['JAVA_HOME']))\n", " except subprocess.CalledProcessError as e:\n", " # Handle the error if the command returns a non-zero exit code\n", " logger.warn(\"Command failed with return code {}\".format(e.returncode))\n", " logger.warn(\"stdout: {}\".format(e.stdout))\n", "\n", "# Install Java if not available\n", "if is_java_installed():\n", " logger.info(\"Java is already installed: {}\".format(os.environ['JAVA_HOME']))\n", "else:\n", " logger.info(\"Installing Java\")\n", " install_java()\n", "\n", "\n", "# download Hadoop\n", "file_name = os.path.basename(HADOOP_URL)\n", "if os.path.isfile(file_name):\n", " logger.info(\"{} already exists, not downloading\".format(file_name))\n", "else:\n", " logger.info(\"Downloading {}\".format(file_name))\n", " urllib.request.urlretrieve(HADOOP_URL, file_name)\n", "\n", "# uncompress archive\n", "dir_name = file_name[:-7]\n", "if os.path.exists(dir_name):\n", " logger.info(\"{} is already uncompressed\".format(file_name))\n", "else:\n", " logger.info(\"Uncompressing {}\".format(file_name))\n", " tar = tarfile.open(file_name)\n", " tar.extractall()\n", " tar.close()\n", "\n", "# environment variables\n", "os.environ['HADOOP_HOME'] = os.path.join(os.getcwd(), dir_name)\n", "logger.info(\"HADOOP_HOME is {}\".format(os.environ['HADOOP_HOME']))\n", "os.environ['PATH'] = ':'.join([os.path.join(os.environ['HADOOP_HOME'], 'bin'), os.environ['PATH']])\n", "logger.info(\"PATH is {}\".format(os.environ['PATH']))\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "6223c729-12a3-4010-b232-4d0fe4de25c3", "id": "qUVKZ2j0vTjS" }, "execution_count": 2, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "04-Aug-24 07:09:23 PM - INFO: Java is already installed: /usr/lib/jvm/java-11-openjdk-amd64\n", "04-Aug-24 07:09:23 PM - INFO: Downloading hadoop-3.4.0.tar.gz\n", "04-Aug-24 07:10:00 PM - INFO: Uncompressing hadoop-3.4.0.tar.gz\n", "04-Aug-24 07:10:26 PM - INFO: HADOOP_HOME is /content/hadoop-3.4.0\n", "04-Aug-24 07:10:26 PM - INFO: PATH is /content/hadoop-3.4.0/bin:/opt/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/tools/node/bin:/tools/google-cloud-sdk/bin\n" ] } ] }, { "cell_type": "markdown", "source": [ "### Check environment variables used by `mapred`\n", "\n", "The following steps are not needed but they might be useful to get familiar the `mapred` command.\n", "\n", "`mapred minicluster` is the command that we are going to use to start the MiniCluster once a few variables and libraries are taken care of." ], "metadata": { "id": "wWzin-_oRuTl" } }, { "cell_type": "code", "source": [ "!mapred -h" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "FmCr_cI05Fvm", "outputId": "13ab3991-d6d1-40b2-e11f-b903f0703b40" }, "execution_count": 3, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Usage: mapred [OPTIONS] SUBCOMMAND [SUBCOMMAND OPTIONS]\n", " or mapred [OPTIONS] CLASSNAME [CLASSNAME OPTIONS]\n", " where CLASSNAME is a user-provided Java class\n", "\n", " OPTIONS is none or any of:\n", "\n", "--config dir Hadoop config directory\n", "--debug turn on shell script debug mode\n", "--help usage information\n", "\n", " SUBCOMMAND is one of:\n", "\n", "\n", " Admin Commands:\n", "\n", "frameworkuploader mapreduce framework upload\n", "hsadmin job history server admin interface\n", "\n", " Client Commands:\n", "\n", "classpath prints the class path needed for running mapreduce subcommands\n", "envvars display computed Hadoop environment variables\n", "job manipulate MapReduce jobs\n", "minicluster CLI MiniCluster\n", "pipes run a Pipes job\n", "queue get information regarding JobQueues\n", "sampler sampler\n", "version print the version\n", "\n", " Daemon Commands:\n", "\n", "historyserver run job history servers as a standalone daemon\n", "\n", "SUBCOMMAND may print help when invoked w/o parameters or with -h.\n" ] } ] }, { "cell_type": "code", "source": [ "!mapred envvars" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "381816ac-2a99-4a5e-c3ee-58ba5322d8ec", "id": "XSF0r1CJvTjT" }, "execution_count": 4, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "JAVA_HOME='/usr/lib/jvm/java-11-openjdk-amd64'\n", "HADOOP_MAPRED_HOME='/content/hadoop-3.4.0'\n", "MAPRED_DIR='share/hadoop/mapreduce'\n", "MAPRED_LIB_JARS_DIR='share/hadoop/mapreduce/lib'\n", "HADOOP_CONF_DIR='/content/hadoop-3.4.0/etc/hadoop'\n", "HADOOP_TOOLS_HOME='/content/hadoop-3.4.0'\n", "HADOOP_TOOLS_DIR='share/hadoop/tools'\n", "HADOOP_TOOLS_LIB_JARS_DIR='share/hadoop/tools/lib'\n" ] } ] }, { "cell_type": "markdown", "source": [ "## Set `HADOOP_TOOLS_LIB_JARS_DIR`\n", "\n", "This variable needs to point to the folder containing Hadoop libraries. As you can see in the output of `mapred envvars`, by default this is set incorrectly to `share/hadoop/tools/lib`." ], "metadata": { "id": "-vNiekW25pbB" } }, { "cell_type": "code", "source": [ "os.environ['HADOOP_TOOLS_LIB_JARS_DIR'] = os.path.join(os.environ['HADOOP_HOME'], 'share/hadoop/tools/lib/') #IMPORTANT" ], "metadata": { "id": "EKAwTLHdvTjU" }, "execution_count": 5, "outputs": [] }, { "cell_type": "markdown", "source": [ "## Install the `mockito` library\n", "\n", "To figure out which version of `mockito` is compatible with the current version of Hadoop, check this page for library dependency analysis: https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-hdfs/dependency-analysis.html\n", "\n", "We need Mockito 2.28.2." ], "metadata": { "id": "zrUFZyHOSBb5" } }, { "cell_type": "markdown", "source": [ "After a new Hadoop installation, the mockito library is not yet there!" ], "metadata": { "id": "pQrBSymx6xdT" } }, { "cell_type": "code", "source": [ "!find hadoop-3.4.0 -name \"mockito*\"" ], "metadata": { "id": "84AGO_GwvTjU" }, "execution_count": 6, "outputs": [] }, { "cell_type": "markdown", "source": [ "Download it from the Maven repository." ], "metadata": { "id": "ztngaw_S67Hd" } }, { "cell_type": "code", "source": [ "!wget --no-clobber https://repo1.maven.org/maven2/org/mockito/mockito-core/2.28.2/mockito-core-2.28.2.jar" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "99ccdabf-d9bf-46d3-8caa-96e2d54eb0f7", "id": "9W4RaUGbvTjV" }, "execution_count": 7, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "--2024-08-04 19:10:27-- https://repo1.maven.org/maven2/org/mockito/mockito-core/2.28.2/mockito-core-2.28.2.jar\n", "Resolving repo1.maven.org (repo1.maven.org)... 199.232.192.209, 199.232.196.209, 2a04:4e42:4c::209, ...\n", "Connecting to repo1.maven.org (repo1.maven.org)|199.232.192.209|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 591179 (577K) [application/java-archive]\n", "Saving to: ‘mockito-core-2.28.2.jar’\n", "\n", "\rmockito-core-2.28.2 0%[ ] 0 --.-KB/s \rmockito-core-2.28.2 100%[===================>] 577.32K --.-KB/s in 0.05s \n", "\n", "2024-08-04 19:10:27 (10.3 MB/s) - ‘mockito-core-2.28.2.jar’ saved [591179/591179]\n", "\n" ] } ] }, { "cell_type": "markdown", "source": [ "Install the library in a location where it can be found." ], "metadata": { "id": "rlWXc92bSjeE" } }, { "cell_type": "code", "source": [ "shutil.copy('mockito-core-2.28.2.jar', os.path.join(os.environ['HADOOP_HOME'],'share/hadoop/mapreduce/'))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 0 }, "id": "jk6CvZZY4ehO", "outputId": "05d80737-cc4c-4c61-cc8a-1b84f3440671" }, "execution_count": 8, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'/content/hadoop-3.4.0/share/hadoop/mapreduce/mockito-core-2.28.2.jar'" ], "application/vnd.google.colaboratory.intrinsic+json": { "type": "string" } }, "metadata": {}, "execution_count": 8 } ] }, { "cell_type": "code", "source": [ "os.listdir(os.path.join(os.environ['HADOOP_HOME'],'share/hadoop/mapreduce/'))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "b08dae4a-5d9b-4627-c900-d5244c27f6db", "id": "x5KDVOgFvTjU" }, "execution_count": 9, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "['hadoop-mapreduce-client-core-3.4.0.jar',\n", " 'sources',\n", " 'hadoop-mapreduce-client-uploader-3.4.0.jar',\n", " 'hadoop-mapreduce-client-jobclient-3.4.0.jar',\n", " 'hadoop-mapreduce-client-shuffle-3.4.0.jar',\n", " 'hadoop-mapreduce-client-common-3.4.0.jar',\n", " 'mockito-core-2.28.2.jar',\n", " 'hadoop-mapreduce-client-hs-3.4.0.jar',\n", " 'hadoop-mapreduce-client-app-3.4.0.jar',\n", " 'hadoop-mapreduce-client-jobclient-3.4.0-tests.jar',\n", " 'hadoop-mapreduce-examples-3.4.0.jar',\n", " 'hadoop-mapreduce-client-nativetask-3.4.0.jar',\n", " 'hadoop-mapreduce-client-hs-plugins-3.4.0.jar',\n", " 'jdiff']" ] }, "metadata": {}, "execution_count": 9 } ] }, { "cell_type": "markdown", "source": [ "## Create folders for the datanodes\n", "\n", "These folders are needed for the correct functioning of the MiniCluster." ], "metadata": { "id": "FweWN3enS3HV" } }, { "cell_type": "code", "source": [ "!mkdir -p ./target/test/data/dfs/{name-0-1,name-0-2}" ], "metadata": { "id": "KZg6NLydvTjU" }, "execution_count": 10, "outputs": [] }, { "cell_type": "code", "source": [ "!ls ./target/test/data/dfs/" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "XThvV4kuVYpU", "outputId": "56e8287a-47e4-4359-c029-1f5fbdad7bd0" }, "execution_count": 11, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "name-0-1 name-0-2\n" ] } ] }, { "cell_type": "markdown", "source": [ "# Start the MiniCluster\n", "\n", "\n", "To see a full list of options run `mapred minicluster -help`." ], "metadata": { "id": "7Odx4SZbOhL4" } }, { "cell_type": "code", "source": [ "!mapred minicluster -help" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "R7YqK3brVG2J", "outputId": "7ef5aa31-196e-4d68-8aee-c43a45fd4932" }, "execution_count": 12, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "usage: ...\n", " -D Options to pass into configuration object\n", " -datanodes How many datanodes to start (default 1)\n", " -format Format the DFS (default false)\n", " -help Prints option help.\n", " -jhsport JobHistoryServer port (default 0--we choose)\n", " -namenode URL of the namenode (default is either the DFS\n", " cluster or a temporary dir)\n", " -nnhttpport NameNode HTTP port (default 0--we choose)\n", " -nnport NameNode port (default 0--we choose)\n", " -nodemanagers How many nodemanagers to start (default 1)\n", " -nodfs Don't start a mini DFS cluster\n", " -nomr Don't start a mini MR cluster\n", " -rmport ResourceManager port (default 0--we choose)\n", " -writeConfig Save configuration to this XML file.\n", " -writeDetails Write basic information to this JSON file.\n" ] } ] }, { "cell_type": "markdown", "source": [ "If you are not running this notebook for the first time or have edited the `core-site.xml` file you should now empty it to get the default initial configuration.\n", "\n", "**Note:** the file `core-site.xml` needs to exist and contain the lines\n", "\n", "```\n", "\n", "\n", "\n", "```\n" ], "metadata": { "id": "CKX9vXJ9MRlI" } }, { "cell_type": "code", "source": [ "# check if the file is there\n", "!find $HADOOP_HOME -name \"core-site.xml\"" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "VANlMygeMukl", "outputId": "c9069a09-fb71-4262-87b4-365664f7de9f" }, "execution_count": 13, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "/content/hadoop-3.4.0/etc/hadoop/core-site.xml\n" ] } ] }, { "cell_type": "code", "source": [ "# view the contents of the file\n", "!cat $(find $HADOOP_HOME -name \"core-site.xml\")" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "FyNiiZki_1s1", "outputId": "e38a9975-38f8-49f9-c347-f7d5327f74e7" }, "execution_count": 14, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] } ] }, { "cell_type": "code", "source": [ "with open(os.environ['HADOOP_HOME']+'/etc/hadoop/core-site.xml', 'w') as file:\n", " file.write(\"\\n\")" ], "metadata": { "id": "w4ihWl6hMz2s" }, "execution_count": 15, "outputs": [] }, { "cell_type": "code", "source": [ "!cat $(find $HADOOP_HOME -name \"core-site.xml\")" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "C4QcevYKdvf7", "outputId": "901ed557-b095-488d-85b1-bbeccbfd6cba" }, "execution_count": 16, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\n", "" ] } ] }, { "cell_type": "markdown", "source": [ "## `mapred minicluster -format`\n", "\n", "Finally, we are all set up to start the MiniCluster.\n", "\n", "Make sure to include the `-format` option to initialize and format the filesystem.\n", "\n", "Other than that, we are using the defaults for all the other options.\n" ], "metadata": { "id": "_2vNXuN1AE6q" } }, { "cell_type": "markdown", "source": [ "Note that this process runs forever thus blocking the notebook. In order to proceed with the rest of the notebook, just interrupt the running cell.\n", "\n", "We'll see later how to run the MiniCluster as a subprocess without blocking the notebook's cells execution.\n", "\n", "Uncomment the next cell to launch the MiniCluster!" ], "metadata": { "id": "y7jGgVy3WF4S" } }, { "cell_type": "code", "source": [ "#!mapred minicluster -format" ], "metadata": { "id": "5c46g83gvTjX" }, "execution_count": 17, "outputs": [] }, { "cell_type": "markdown", "source": [ "If the MiniMRCluster started correctly, you should see a line like this at the bottom:\n", "\n", " 2024-01-14 13:53:15,112 INFO mapreduce.MiniHadoopClusterManager: Started MiniMRCluster" ], "metadata": { "id": "IlU0eS5_QGbq" } }, { "cell_type": "markdown", "source": [ "# Stop the MiniCluster process\n", "\n", "To continue to work with this notebook, you need to stop the MiniCluster by terminating the execution of the previous cell." ], "metadata": { "id": "Oc0xM9VNRei5" } }, { "cell_type": "markdown", "source": [ "![interrupt_cell.png](data:image/png;base64,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)" ], "metadata": { "id": "fJGsLuZ46pXf" } }, { "cell_type": "markdown", "source": [ "# Start the MiniCluster as a subprocess\n", "\n", "It is convenient to start the MiniCluster as a subprocess in order prevent it from blocking the execution of other notebook cells.\n", "\n", "The MiniCluster is a Java process with multiple listening ports.\n", "\n" ], "metadata": { "id": "F9BfFS27vTjX" } }, { "cell_type": "markdown", "source": [ "## Use `lsof` to show listening ports\n", "\n", "To check ports that have listening services use `lsof`.\n", "\n", "The output should look like this:\n", "\n", "```\n", "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\n", "node 7 root 21u IPv6 19666 0t0 TCP *:8080 (LISTEN)\n", "kernel_manager_ 20 root 3u IPv4 18322 0t0 TCP 172.28.0.12:6000 (LISTEN)\n", "colab-fileshim. 61 root 3u IPv4 19763 0t0 TCP 127.0.0.1:3453 (LISTEN)\n", "jupyter-noteboo 79 root 7u IPv4 19989 0t0 TCP 172.28.0.12:9000 (LISTEN)\n", "python3 428 root 21u IPv4 25506 0t0 TCP 127.0.0.1:38217 (LISTEN)\n", "python3 467 root 3u IPv4 26425 0t0 TCP 127.0.0.1:43729 (LISTEN)\n", "python3 467 root 5u IPv4 26426 0t0 TCP 127.0.0.1:60229 (LISTEN)\n", "```" ], "metadata": { "id": "0X1zImnU5Afb" } }, { "cell_type": "code", "source": [ "!lsof -n -i -P +c0 -sTCP:LISTEN" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "v_ieJekiBv-2", "outputId": "25c07f4f-56ba-4431-9c8a-f4cd72a25b7c" }, "execution_count": 18, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\n", "node 7 root 21u IPv6 20065 0t0 TCP *:8080 (LISTEN)\n", "kernel_manager_ 25 root 6u IPv4 19487 0t0 TCP 172.28.0.12:6000 (LISTEN)\n", "colab-fileshim. 70 root 3u IPv4 19330 0t0 TCP 127.0.0.1:3453 (LISTEN)\n", "jupyter-noteboo 91 root 7u IPv4 20298 0t0 TCP 172.28.0.12:9000 (LISTEN)\n", "python3 2301 root 21u IPv4 84721 0t0 TCP 127.0.0.1:37185 (LISTEN)\n", "python3 2340 root 3u IPv4 86086 0t0 TCP 127.0.0.1:35717 (LISTEN)\n", "python3 2340 root 5u IPv4 86087 0t0 TCP 127.0.0.1:45663 (LISTEN)\n" ] } ] }, { "cell_type": "markdown", "source": [ "Options used in `lsof`:\n", "\n", "* `-i` specifies that you want to display only network files, that is open network connections\n", "* `-n` and `-P` tell `lsof` to show IP addresses (`-n`) and ports (`-P`) in numeric form. This makes `lsof` faster as it saves the time for name lookups.\n", "* the option `+c0` is used to show a longer substring of the name of the UNIX command associated with the process (https://linux.die.net/man/8/lsof)\n", "* `-sTCP:LISTEN` filters for TCP connections in state `LISTEN`\n", "\n", "See also [lsof and listening ports](https://unix.stackexchange.com/questions/26887/lsof-and-listening-ports) on Stackexchange." ], "metadata": { "id": "tg9V_qXGZ1fe" } }, { "cell_type": "markdown", "source": [ "## Start the subprocess\n", "\n", "Start the MiniCluster as a subprocess using Python's [`subprocess` library](https://docs.python.org/3/library/subprocess.html).\n", "\n", "The files `out.txt` and `err.txt` will contain respectively the standard output and the standard error emitted by the `mapred minicluster` command." ], "metadata": { "id": "a-OKONXJBwkf" } }, { "cell_type": "code", "source": [ "import subprocess\n", "with open('out.txt', \"w\") as stdout_file, open('err.txt', \"w\") as stderr_file:\n", " process = subprocess.Popen(\n", " [\"mapred\", \"minicluster\", \"-format\"],\n", " stdout=stdout_file,\n", " stderr=stderr_file\n", " )" ], "metadata": { "id": "aTBwruBkAuP_" }, "execution_count": 19, "outputs": [] }, { "cell_type": "markdown", "source": [ "Wait for a couple of seconds because the services might not be available immediately." ], "metadata": { "id": "gY484JgGCVUd" } }, { "cell_type": "code", "source": [ "if not IN_COLAB:\n", " time.sleep(30)\n", "else:\n", " time.sleep(10)" ], "metadata": { "id": "dk_FGmuOCoBW" }, "execution_count": 20, "outputs": [] }, { "cell_type": "markdown", "source": [ "Now check for listening ports again (you can also refresh the next cell with ctrl-enter)." ], "metadata": { "id": "6iBMkb6fCqUU" } }, { "cell_type": "code", "source": [ "!lsof -n -i -P +c0 -sTCP:LISTEN" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Rt9J9bj4A_5m", "outputId": "a18dc323-201b-4680-c488-897b64a3737e" }, "execution_count": 21, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\n", "node 7 root 21u IPv6 20065 0t0 TCP *:8080 (LISTEN)\n", "kernel_manager_ 25 root 6u IPv4 19487 0t0 TCP 172.28.0.12:6000 (LISTEN)\n", "colab-fileshim. 70 root 3u IPv4 19330 0t0 TCP 127.0.0.1:3453 (LISTEN)\n", "jupyter-noteboo 91 root 7u IPv4 20298 0t0 TCP 172.28.0.12:9000 (LISTEN)\n", "python3 2301 root 21u IPv4 84721 0t0 TCP 127.0.0.1:37185 (LISTEN)\n", "python3 2340 root 3u IPv4 86086 0t0 TCP 127.0.0.1:35717 (LISTEN)\n", "python3 2340 root 5u IPv4 86087 0t0 TCP 127.0.0.1:45663 (LISTEN)\n", "java 2805 root 341u IPv4 98240 0t0 TCP 127.0.0.1:46505 (LISTEN)\n", "java 2805 root 351u IPv4 98317 0t0 TCP 127.0.0.1:44975 (LISTEN)\n", "java 2805 root 361u IPv4 98320 0t0 TCP 127.0.0.1:42669 (LISTEN)\n", "java 2805 root 364u IPv4 100111 0t0 TCP 127.0.0.1:44643 (LISTEN)\n", "java 2805 root 393u IPv4 98335 0t0 TCP 127.0.0.1:34731 (LISTEN)\n", "java 2805 root 394u IPv4 98342 0t0 TCP 127.0.0.1:36923 (LISTEN)\n" ] } ] }, { "cell_type": "markdown", "source": [ "You should have gotten something like this (a total of $18$ listening ports associated with the MiniCluster process):\n", "\n", "```\n", "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\n", "node 6 root 21u IPv6 17373 0t0 TCP *:8080 (LISTEN)\n", "kernel_manager_ 20 root 3u IPv4 17180 0t0 TCP 172.28.0.12:6000 (LISTEN)\n", "colab-fileshim. 58 root 3u IPv4 19499 0t0 TCP 127.0.0.1:3453 (LISTEN)\n", "jupyter-noteboo 75 root 7u IPv4 19658 0t0 TCP 172.28.0.12:9000 (LISTEN)\n", "python3 4081 root 21u IPv4 108431 0t0 TCP 127.0.0.1:44519 (LISTEN)\n", "python3 4108 root 3u IPv4 109755 0t0 TCP 127.0.0.1:46699 (LISTEN)\n", "python3 4108 root 5u IPv4 109756 0t0 TCP 127.0.0.1:51813 (LISTEN)\n", "java 17261 root 347u IPv4 390097 0t0 TCP 127.0.0.1:38817 (LISTEN)\n", "java 17261 root 357u IPv4 391184 0t0 TCP 127.0.0.1:41631 (LISTEN)\n", "java 17261 root 367u IPv4 390801 0t0 TCP 127.0.0.1:34651 (LISTEN)\n", "java 17261 root 370u IPv4 390804 0t0 TCP 127.0.0.1:35015 (LISTEN)\n", "java 17261 root 399u IPv4 390814 0t0 TCP 127.0.0.1:46503 (LISTEN)\n", "java 17261 root 400u IPv4 390817 0t0 TCP 127.0.0.1:44665 (LISTEN)\n", "java 17261 root 423u IPv4 401418 0t0 TCP *:8031 (LISTEN)\n", "java 17261 root 440u IPv4 395796 0t0 TCP *:10033 (LISTEN)\n", "java 17261 root 450u IPv4 400174 0t0 TCP *:19888 (LISTEN)\n", "java 17261 root 455u IPv4 396244 0t0 TCP 127.0.0.1:43877 (LISTEN)\n", "java 17261 root 465u IPv4 400367 0t0 TCP *:8088 (LISTEN)\n", "java 17261 root 470u IPv4 400420 0t0 TCP *:8033 (LISTEN)\n", "java 17261 root 490u IPv4 401422 0t0 TCP *:8030 (LISTEN)\n", "java 17261 root 500u IPv4 400426 0t0 TCP 127.0.0.1:37335 (LISTEN)\n", "java 17261 root 510u IPv4 400470 0t0 TCP 127.0.0.1:42337 (LISTEN)\n", "java 17261 root 520u IPv4 401450 0t0 TCP 127.0.0.1:40401 (LISTEN)\n", "java 17261 root 530u IPv4 401454 0t0 TCP *:42359 (LISTEN)\n", "java 17261 root 531u IPv4 401457 0t0 TCP 127.0.0.1:38543 (LISTEN)\n", "```\n", "\n", "The `java` process is the one responsible for providing the MiniCluster services by listening on several ports.\n", "\n", "There are two known ports for the Web interfaces (see [https://hadoop.apache.org/docs/.../ClusterSetup.html#Web_Interfaces](https://hadoop.apache.org/docs/r3.0.1/hadoop-project-dist/hadoop-common/ClusterSetup.html#Web_Interfaces)):\n", "* $8088$ the port to the ResourceManager\n", "* $19888$ the port to the MapReduce JobHistory Server\n", "\n" ], "metadata": { "id": "crP9O3O9DfUT" } }, { "cell_type": "markdown", "source": [ "### Access the Web UI" ], "metadata": { "id": "rHb_H6-rt2NQ" } }, { "cell_type": "markdown", "source": [ "Let us check the Web interface at port $8088$." ], "metadata": { "id": "vUo-K1HmKTIv" } }, { "cell_type": "code", "source": [ "!wget http://localhost:8088" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "GOKETlOVKTRg", "outputId": "c3c0a621-d346-4841-8c14-9697c1dd1f84" }, "execution_count": 22, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "--2024-08-04 19:10:41-- http://localhost:8088/\n", "Resolving localhost (localhost)... 127.0.0.1, ::1\n", "Connecting to localhost (localhost)|127.0.0.1|:8088... failed: Connection refused.\n", "Connecting to localhost (localhost)|::1|:8088... failed: Cannot assign requested address.\n", "Retrying.\n", "\n", "--2024-08-04 19:10:42-- (try: 2) http://localhost:8088/\n", "Connecting to localhost (localhost)|127.0.0.1|:8088... failed: Connection refused.\n", "Connecting to localhost (localhost)|::1|:8088... failed: Cannot assign requested address.\n", "Retrying.\n", "\n", "--2024-08-04 19:10:44-- (try: 3) http://localhost:8088/\n", "Connecting to localhost (localhost)|127.0.0.1|:8088... failed: Connection refused.\n", "Connecting to localhost (localhost)|::1|:8088... failed: Cannot assign requested address.\n", "Retrying.\n", "\n", "--2024-08-04 19:10:47-- (try: 4) http://localhost:8088/\n", "Connecting to localhost (localhost)|127.0.0.1|:8088... connected.\n", "HTTP request sent, awaiting response... 302 Found\n", "Location: http://localhost:8088/cluster [following]\n", "--2024-08-04 19:10:47-- http://localhost:8088/cluster\n", "Reusing existing connection to localhost:8088.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 14065 (14K) [text/html]\n", "Saving to: ‘index.html’\n", "\n", "index.html 100%[===================>] 13.74K --.-KB/s in 0.001s \n", "\n", "2024-08-04 19:10:48 (24.8 MB/s) - ‘index.html’ saved [14065/14065]\n", "\n" ] } ] }, { "cell_type": "markdown", "source": [ "We can serve the ResourceManager UI in the browser through Google Colab." ], "metadata": { "id": "jO6uA0_aLbX_" } }, { "cell_type": "code", "source": [ "if IN_COLAB:\n", " # serve the Web UI on Colab\n", " print(\"Click on the link below to open the Resource Manager Web UI 🚀\")\n", " output.serve_kernel_port_as_window(8088, path='/node')" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 52 }, "id": "4a1mpPpYL25c", "outputId": "2f72432f-1ab6-41d4-a3ac-39d72dd23e0f" }, "execution_count": 23, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Click on the link below to open the Resource Manager Web UI 🚀\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "application/javascript": [ "(async (port, path, text, element) => {\n", " if (!google.colab.kernel.accessAllowed) {\n", " return;\n", " }\n", " element.appendChild(document.createTextNode(''));\n", " const url = await google.colab.kernel.proxyPort(port);\n", " const anchor = document.createElement('a');\n", " anchor.href = new URL(path, url).toString();\n", " anchor.target = '_blank';\n", " anchor.setAttribute('data-href', url + path);\n", " anchor.textContent = text;\n", " element.appendChild(anchor);\n", " })(8088, \"/node\", \"https://localhost:8088/node\", window.element)" ] }, "metadata": {} } ] }, { "cell_type": "markdown", "source": [ "The port $19888$ is redirected to the same page as port $8088$, so it won't be very useful. I'm not sure if this is due to a missing configuration parameter or if it's a bug." ], "metadata": { "id": "zoL28RXvRyZV" } }, { "cell_type": "code", "source": [ "!wget http://localhost:19888" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Ll29MYBUSAhg", "outputId": "efcf5335-4eae-40df-b101-603983590c27" }, "execution_count": 24, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "--2024-08-04 19:10:48-- http://localhost:19888/\n", "Resolving localhost (localhost)... 127.0.0.1, ::1\n", "Connecting to localhost (localhost)|127.0.0.1|:19888... connected.\n", "HTTP request sent, awaiting response... 302 Found\n", "Location: http://localhost:19888/cluster [following]\n", "--2024-08-04 19:10:48-- http://localhost:19888/cluster\n", "Reusing existing connection to localhost:19888.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 14065 (14K) [text/html]\n", "Saving to: ‘index.html.1’\n", "\n", "\rindex.html.1 0%[ ] 0 --.-KB/s \rindex.html.1 100%[===================>] 13.74K --.-KB/s in 0s \n", "\n", "2024-08-04 19:10:48 (104 MB/s) - ‘index.html.1’ saved [14065/14065]\n", "\n" ] } ] }, { "cell_type": "code", "source": [ "if IN_COLAB:\n", " # serve the Web UI on Colab\n", " print(\"Click on the link below to open the MapReduce JobHistory Server Web UI 🚀\")\n", " output.serve_kernel_port_as_window(19888, path='/node')" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 52 }, "id": "XwxSD_Ez4mA5", "outputId": "2ceef797-d3a6-4da5-a55c-4d223815dbe9" }, "execution_count": 25, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Click on the link below to open the MapReduce JobHistory Server Web UI 🚀\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "application/javascript": [ "(async (port, path, text, element) => {\n", " if (!google.colab.kernel.accessAllowed) {\n", " return;\n", " }\n", " element.appendChild(document.createTextNode(''));\n", " const url = await google.colab.kernel.proxyPort(port);\n", " const anchor = document.createElement('a');\n", " anchor.href = new URL(path, url).toString();\n", " anchor.target = '_blank';\n", " anchor.setAttribute('data-href', url + path);\n", " anchor.textContent = text;\n", " element.appendChild(anchor);\n", " })(19888, \"/node\", \"https://localhost:19888/node\", window.element)" ] }, "metadata": {} } ] }, { "cell_type": "markdown", "source": [ "### Use ngrok to access the Web UI" ], "metadata": { "id": "qq0i7cnLuSvm" } }, { "cell_type": "markdown", "source": [ "In the free tier of Google Colab this functionality might not be available (see https://research.google.com/colaboratory/faq.html#limitations-and-restrictions). As an alternative, you can use [ngrok](https://ngrok.com/) after signing up for a free account.\n", "\n", "Check the NGROK box below if you want to use ngrok.\n", "\n" ], "metadata": { "id": "z6c_QA-fsJib" } }, { "cell_type": "code", "source": [ "# you should set this to True\n", "NGROK = False #@param {type:\"boolean\"}" ], "metadata": { "id": "jD7pB1dHGaMB" }, "execution_count": 26, "outputs": [] }, { "cell_type": "markdown", "source": [ "We are going to use the Python ngrok client `pyngrok` (see the [Colab example](https://pyngrok.readthedocs.io/en/latest/integrations.html#colab-http-example))." ], "metadata": { "id": "24l7XugFGsfQ" } }, { "cell_type": "code", "source": [ "if NGROK:\n", " !pip install pyngrok\n", " from pyngrok import ngrok, conf\n", " import getpass\n", "\n", " print(\"Enter your authtoken, which can be copied from https://dashboard.ngrok.com/get-started/your-authtoken\")\n", " conf.get_default().auth_token = getpass.getpass()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Ed-77ALaqlel", "outputId": "9d6e8bda-bd81-4f79-f324-d10e9a7d9ba1" }, "execution_count": 27, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Collecting pyngrok\n", " Downloading pyngrok-7.2.0-py3-none-any.whl.metadata (7.4 kB)\n", "Requirement already satisfied: PyYAML>=5.1 in /usr/local/lib/python3.10/dist-packages (from pyngrok) (6.0.1)\n", "Downloading pyngrok-7.2.0-py3-none-any.whl (22 kB)\n", "Installing collected packages: pyngrok\n", "Successfully installed pyngrok-7.2.0\n", "Enter your authtoken, which can be copied from https://dashboard.ngrok.com/get-started/your-authtoken\n", "··········\n" ] } ] }, { "cell_type": "markdown", "source": [ "After entering the ngrok authorization token, you can open a connection." ], "metadata": { "id": "mI2SrsWBrOeI" } }, { "cell_type": "code", "source": [ "if NGROK:\n", " # Open a ngrok tunnel to the HTTP server\n", " public_url = ngrok.connect(19888).public_url" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "xvvmU6ZArDz_", "outputId": "5e3d79f5-5e51-4861-c9e9-6a4cb921af9d" }, "execution_count": 28, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "04-Aug-24 07:12:03 PM - INFO: Opening tunnel named: http-19888-9ba3fee7-3b4b-40cb-ad20-2d842c826538\n" ] }, { "output_type": "stream", "name": "stdout", "text": [] }, { "output_type": "stream", "name": "stderr", "text": [ "04-Aug-24 07:12:04 PM - INFO: Overriding default auth token\n", "04-Aug-24 07:12:04 PM - INFO: t=2024-08-04T19:12:04+0000 lvl=info msg=\"no configuration paths supplied\"\n", "04-Aug-24 07:12:04 PM - INFO: t=2024-08-04T19:12:04+0000 lvl=info msg=\"using configuration at default config path\" path=/root/.config/ngrok/ngrok.yml\n", "04-Aug-24 07:12:04 PM - INFO: t=2024-08-04T19:12:04+0000 lvl=info msg=\"open config file\" path=/root/.config/ngrok/ngrok.yml err=nil\n", "04-Aug-24 07:12:04 PM - INFO: t=2024-08-04T19:12:04+0000 lvl=info msg=\"starting web service\" obj=web addr=127.0.0.1:4040 allow_hosts=[]\n", "04-Aug-24 07:12:04 PM - INFO: t=2024-08-04T19:12:04+0000 lvl=info msg=\"client session established\" obj=tunnels.session\n", "04-Aug-24 07:12:04 PM - INFO: t=2024-08-04T19:12:04+0000 lvl=info msg=\"tunnel session started\" obj=tunnels.session\n", "04-Aug-24 07:12:04 PM - INFO: t=2024-08-04T19:12:04+0000 lvl=info msg=start pg=/api/tunnels id=1cc987793bc5e340\n", "04-Aug-24 07:12:05 PM - INFO: t=2024-08-04T19:12:04+0000 lvl=info msg=end pg=/api/tunnels id=1cc987793bc5e340 status=200 dur=447.85µs\n", "04-Aug-24 07:12:05 PM - INFO: t=2024-08-04T19:12:05+0000 lvl=info msg=start pg=/api/tunnels id=7f6c4a0097fbee1f\n", "04-Aug-24 07:12:05 PM - INFO: t=2024-08-04T19:12:05+0000 lvl=info msg=end pg=/api/tunnels id=7f6c4a0097fbee1f status=200 dur=160.467µs\n", "04-Aug-24 07:12:05 PM - INFO: t=2024-08-04T19:12:05+0000 lvl=info msg=start pg=/api/tunnels id=756a04f173da4cf6\n", "04-Aug-24 07:12:05 PM - INFO: t=2024-08-04T19:12:05+0000 lvl=info msg=\"started tunnel\" obj=tunnels name=http-19888-9ba3fee7-3b4b-40cb-ad20-2d842c826538 addr=http://localhost:19888 url=https://3a1d-34-74-204-234.ngrok-free.app\n", "04-Aug-24 07:12:05 PM - INFO: t=2024-08-04T19:12:05+0000 lvl=info msg=end pg=/api/tunnels id=756a04f173da4cf6 status=201 dur=48.830762ms\n" ] } ] }, { "cell_type": "code", "source": [ "if NGROK:\n", " print(f'Click on {public_url} to open the MapReduce JobHistory Server Web UI')" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "uzpDDM-xrbHu", "outputId": "3f228a4c-655c-4dd2-a4f9-61ce2e2f68f8" }, "execution_count": 29, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Click on https://3a1d-34-74-204-234.ngrok-free.app to open the MapReduce JobHistory Server Web UI\n" ] } ] }, { "cell_type": "markdown", "source": [ "You can safely ignore the warning since we are not disclosing any confidential information and proceed with clicking on the \"Visit site\" button." ], "metadata": { "id": "WV2BBzEwvv_X" } }, { "cell_type": "markdown", "source": [ "![ngrok_warning.png](data:image/png;base64,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)" ], "metadata": { "id": "PTN1yVvhwYUr" } }, { "cell_type": "markdown", "source": [ "## Stop the MiniCluster subprocess\n", "\n", "To stop the MiniCluster subprocess use `process.kill()` (remember: `process` is the variable name for the MiniCluster subprocess)." ], "metadata": { "id": "7UQg9PjpNJRj" } }, { "cell_type": "code", "source": [ "process.kill()" ], "metadata": { "id": "9_UGJUPYNWuH" }, "execution_count": 30, "outputs": [] }, { "cell_type": "markdown", "source": [ "The Java process should now be gone." ], "metadata": { "id": "F5nVzcd2NcgZ" } }, { "cell_type": "code", "source": [ "!lsof -n -i -P +c0 -sTCP:LISTEN" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "PGJ0Bs0ENbDZ", "outputId": "32bf4e82-d198-43c4-d745-648b5a79d7e3" }, "execution_count": 31, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\n", "node 7 root 21u IPv6 20065 0t0 TCP *:8080 (LISTEN)\n", "kernel_manager_ 25 root 6u IPv4 19487 0t0 TCP 172.28.0.12:6000 (LISTEN)\n", "colab-fileshim. 70 root 3u IPv4 19330 0t0 TCP 127.0.0.1:3453 (LISTEN)\n", "jupyter-noteboo 91 root 7u IPv4 20298 0t0 TCP 172.28.0.12:9000 (LISTEN)\n", "python3 2301 root 21u IPv4 84721 0t0 TCP 127.0.0.1:37185 (LISTEN)\n", "python3 2340 root 3u IPv4 86086 0t0 TCP 127.0.0.1:35717 (LISTEN)\n", "python3 2340 root 5u IPv4 86087 0t0 TCP 127.0.0.1:45663 (LISTEN)\n", "ngrok 3698 root 6u IPv4 116605 0t0 TCP 127.0.0.1:4040 (LISTEN)\n" ] } ] }, { "cell_type": "markdown", "source": [ "In case there are still some `java` processes lingering around, kill them with" ], "metadata": { "id": "Nc5RhrAl8o_F" } }, { "cell_type": "code", "source": [ "!pkill -f java" ], "metadata": { "id": "p62GHDXh1fiU" }, "execution_count": 32, "outputs": [] }, { "cell_type": "markdown", "source": [ "Verify that the Java processes are gone." ], "metadata": { "id": "F9H_aFvWARei" } }, { "cell_type": "markdown", "source": [ "# Start the MiniCluster with your own ports\n", "\n", "This time we will also set the ports for various services:\n", "\n", " mapred minicluster -format -jhsport 8900 -nnhttpport 8901 -nnport 8902 -rmport 8903\n", "\n", "Ports:\n", "\n", "port number | description\n", "--- | ---\n", "8900 | JobHistoryServer port\n", "8901 | NameNode HTTP port\n", "8902 | NameNode port\n", "8903 | ResourceManager port\n", "\n", "\n", "**Note:** we chose these port numbers (8900, 8901, 8902, 8903) arbitrarily, you can pick other numbers as long as they do not conflict with ports that are already is use." ], "metadata": { "id": "Tn6kOUmvA0FS" } }, { "cell_type": "code", "source": [ "import subprocess\n", "with open('out.txt', \"w\") as stdout_file, open('err.txt', \"w\") as stderr_file:\n", " process = subprocess.Popen(\n", " [\"mapred\", \"minicluster\", \"-format\", \"-jhsport\", \"8900\", \"-nnhttpport\", \"8901\", \"-nnport\", \"8902\", \"-rmport\", \"8903\"],\n", " stdout=stdout_file,\n", " stderr=stderr_file\n", " )" ], "metadata": { "id": "fvmYd5HhvTjX" }, "execution_count": 33, "outputs": [] }, { "cell_type": "code", "source": [ "if not IN_COLAB:\n", " time.sleep(30)\n", "else:\n", " time.sleep(10)" ], "metadata": { "id": "UzhdeackOYAa", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "f147bd51-4fcd-42fd-8070-dd0fdf605c9d" }, "execution_count": 34, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "04-Aug-24 07:12:10 PM - WARNING: t=2024-08-04T19:12:10+0000 lvl=warn msg=\"failed to open private leg\" id=3f1ee8ca6795 privaddr=localhost:19888 err=\"dial tcp 127.0.0.1:19888: connect: connection refused\"\n", "04-Aug-24 07:12:10 PM - WARNING: t=2024-08-04T19:12:10+0000 lvl=warn msg=\"failed to open private leg\" id=166fe8e39b26 privaddr=localhost:19888 err=\"dial tcp 127.0.0.1:19888: connect: connection refused\"\n" ] } ] }, { "cell_type": "markdown", "source": [ "List the Java ports. These should be all ports associated with the MIniCluster `java` process.\n", "\n", "Note: `grep \"^COMMAND\\|java\"` means \"filter out the lines that begin with the string `COMMAND` or that contain the string `java`\". This is to preserve the header line." ], "metadata": { "id": "kmW_0xbWPb8k" } }, { "cell_type": "code", "source": [ "!lsof -n -i -P +c0 -sTCP:LISTEN | grep \"^COMMAND\\|java\"" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "4f7d404c-2269-4dd3-acdc-35ba4775ab25", "id": "5w_SHSeSvTjX" }, "execution_count": 35, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\n", "java 3727 root 341u IPv4 119325 0t0 TCP 127.0.0.1:8901 (LISTEN)\n" ] } ] }, { "cell_type": "markdown", "source": [ "You should now see\n", "\n", "```\n", "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\n", "java 30246 root 347u IPv4 671659 0t0 TCP 127.0.0.1:8901 (LISTEN)\n", "java 30246 root 357u IPv4 672029 0t0 TCP 127.0.0.1:8902 (LISTEN)\n", "java 30246 root 367u IPv4 674008 0t0 TCP 127.0.0.1:44721 (LISTEN)\n", "java 30246 root 370u IPv4 672082 0t0 TCP 127.0.0.1:36789 (LISTEN)\n", "java 30246 root 399u IPv4 674082 0t0 TCP 127.0.0.1:37975 (LISTEN)\n", "java 30246 root 400u IPv4 674085 0t0 TCP 127.0.0.1:37675 (LISTEN)\n", "java 30246 root 423u IPv4 681319 0t0 TCP *:8031 (LISTEN)\n", "java 30246 root 440u IPv4 680955 0t0 TCP *:10033 (LISTEN)\n", "java 30246 root 450u IPv4 681014 0t0 TCP *:19888 (LISTEN)\n", "java 30246 root 455u IPv4 681987 0t0 TCP 127.0.0.1:8900 (LISTEN)\n", "java 30246 root 465u IPv4 682035 0t0 TCP *:8088 (LISTEN)\n", "java 30246 root 470u IPv4 681313 0t0 TCP *:8033 (LISTEN)\n", "java 30246 root 490u IPv4 681325 0t0 TCP *:8030 (LISTEN)\n", "java 30246 root 500u IPv4 682046 0t0 TCP 127.0.0.1:8903 (LISTEN)\n", "java 30246 root 510u IPv4 681370 0t0 TCP 127.0.0.1:34521 (LISTEN)\n", "java 30246 root 520u IPv4 682057 0t0 TCP 127.0.0.1:36981 (LISTEN)\n", "java 30246 root 530u IPv4 681373 0t0 TCP *:46657 (LISTEN)\n", "java 30246 root 531u IPv4 682061 0t0 TCP 127.0.0.1:39897 (LISTEN)\n", "```\n", "\n", "Our ports $8900$, $8901$, $8902$, and $8903$ are included in the list." ], "metadata": { "id": "oIt1BO5EPRIE" } }, { "cell_type": "markdown", "source": [ "The log messages are in the file `err.txt`. The last 10 lines should look like this:\n", "\n", "```\n", "2023-12-27 21:36:08,820 INFO server.MiniYARNCluster: All Node Managers connected in MiniYARNCluster\n", "2023-12-27 21:36:08,820 INFO v2.MiniMRYarnCluster: MiniMRYARN ResourceManager address: localhost:8903\n", "2023-12-27 21:36:08,821 INFO v2.MiniMRYarnCluster: MiniMRYARN ResourceManager web address: 0.0.0.0:8088\n", "2023-12-27 21:36:08,821 INFO v2.MiniMRYarnCluster: MiniMRYARN HistoryServer address: localhost:8900\n", "2023-12-27 21:36:08,822 INFO v2.MiniMRYarnCluster: MiniMRYARN HistoryServer web address: 26769af38ddc:19888\n", "2023-12-27 21:36:08,823 INFO mapreduce.MiniHadoopClusterManager: Started MiniMRCluster\n", "```" ], "metadata": { "id": "W19UpXR5NXbu" } }, { "cell_type": "code", "source": [ "!tail err.txt" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "B6K9s-A9NdBa", "outputId": "3f270543-87f5-4468-b61d-afbf06715e63" }, "execution_count": 36, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "2024-08-04 19:12:16,167 INFO util.GSet: capacity = 2^17 = 131072 entries\n", "2024-08-04 19:12:16,183 INFO common.Storage: Lock on /content/target/test/data/dfs/name-0-1/in_use.lock acquired by nodename 3727@446a375b7fe4\n", "2024-08-04 19:12:16,191 INFO common.Storage: Lock on /content/target/test/data/dfs/name-0-2/in_use.lock acquired by nodename 3727@446a375b7fe4\n", "2024-08-04 19:12:16,195 INFO namenode.FileJournalManager: Recovering unfinalized segments in /content/target/test/data/dfs/name-0-1/current\n", "2024-08-04 19:12:16,195 INFO namenode.FileJournalManager: Recovering unfinalized segments in /content/target/test/data/dfs/name-0-2/current\n", "2024-08-04 19:12:16,195 INFO namenode.FSImage: No edit log streams selected.\n", "2024-08-04 19:12:16,195 INFO namenode.FSImage: Planning to load image: FSImageFile(file=/content/target/test/data/dfs/name-0-1/current/fsimage_0000000000000000000, cpktTxId=0000000000000000000)\n", "2024-08-04 19:12:16,348 INFO namenode.FSImageFormatPBINode: Loading 1 INodes.\n", "2024-08-04 19:12:16,360 INFO namenode.FSImageFormatPBINode: Successfully loaded 1 inodes\n", "2024-08-04 19:12:16,383 INFO namenode.FSImageFormatPBINode: Completed update blocks map and name cache, total waiting duration 0ms.\n" ] } ] }, { "cell_type": "markdown", "source": [ "Check the NameNode's HTTP port." ], "metadata": { "id": "OdzAzlPmcB0h" } }, { "cell_type": "code", "source": [ "!wget http://localhost:8901" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "025b4bc8-6dc4-47a4-cb88-f5814900e236", "id": "M8S8O_4WvTjY" }, "execution_count": 37, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "--2024-08-04 19:12:16-- http://localhost:8901/\n", "Resolving localhost (localhost)... 127.0.0.1, ::1\n", "Connecting to localhost (localhost)|127.0.0.1|:8901... connected.\n", "HTTP request sent, awaiting response... 302 Found\n", "Location: http://localhost:8901/index.html [following]\n", "--2024-08-04 19:12:16-- http://localhost:8901/index.html\n", "Reusing existing connection to localhost:8901.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 1079 (1.1K) [text/html]\n", "Saving to: ‘index.html.2’\n", "\n", "index.html.2 100%[===================>] 1.05K --.-KB/s in 0s \n", "\n", "2024-08-04 19:12:17 (117 MB/s) - ‘index.html.2’ saved [1079/1079]\n", "\n" ] } ] }, { "cell_type": "markdown", "source": [ "## Start the NameNode Web UI\n", "\n", "Serve the NameNode UI in the browser through Google Colab (path should be set to `/index.html` as in the output of `wget` otherwise the URL won't work)." ], "metadata": { "id": "aKA3MLV5cIEX" } }, { "cell_type": "code", "source": [ "if IN_COLAB and not NGROK:\n", " # serve the Web UI on Colab\n", " print(\"Click on the link below to open the NameNode Web UI 🚀\")\n", " output.serve_kernel_port_as_window(8901, path='/index.html')\n", "else:\n", " if NGROK:\n", " # disconnect previous tunnels (note: you can have max 3 tunnels open!)\n", " # see: https://pyngrok.readthedocs.io/en/latest/index.html#get-active-tunnels\n", " tunnels = ngrok.get_tunnels()\n", " for t in tunnels:\n", " ngrok.disconnect(t.public_url)\n", " # Open a ngrok tunnel to the HTTP server on port 8901\n", " public_url = ngrok.connect(8901).public_url\n", " print(f'Click on {public_url} to open the NameNode Web UI 🚀')" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "8f1a1bff-a2eb-45d8-92eb-fcc08da112be", "id": "k-LdeVwBvTjY" }, "execution_count": 38, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "04-Aug-24 07:12:17 PM - INFO: t=2024-08-04T19:12:17+0000 lvl=info msg=start pg=/api/tunnels id=618f6ef4fc692b19\n", "04-Aug-24 07:12:17 PM - INFO: t=2024-08-04T19:12:17+0000 lvl=info msg=end pg=/api/tunnels id=618f6ef4fc692b19 status=200 dur=265.638µs\n", "04-Aug-24 07:12:17 PM - INFO: Disconnecting tunnel: https://3a1d-34-74-204-234.ngrok-free.app\n", "04-Aug-24 07:12:17 PM - INFO: t=2024-08-04T19:12:17+0000 lvl=info msg=start pg=/api/tunnels/http-19888-9ba3fee7-3b4b-40cb-ad20-2d842c826538 id=26cf928d2ad02baa\n", "04-Aug-24 07:12:17 PM - INFO: t=2024-08-04T19:12:17+0000 lvl=info msg=end pg=/api/tunnels/http-19888-9ba3fee7-3b4b-40cb-ad20-2d842c826538 id=26cf928d2ad02baa status=204 dur=36.380055ms\n", "04-Aug-24 07:12:17 PM - INFO: t=2024-08-04T19:12:17+0000 lvl=info msg=\"failed to accept connection: Listener closed\" obj=tunnels.session clientid=cf31c5d7baff4c19c11cf349a9ee2705\n", "04-Aug-24 07:12:17 PM - WARNING: t=2024-08-04T19:12:17+0000 lvl=warn msg=\"Stopping forwarder\" name=http-19888-9ba3fee7-3b4b-40cb-ad20-2d842c826538 acceptErr=\"failed to accept connection: Listener closed\"\n", "04-Aug-24 07:12:17 PM - INFO: t=2024-08-04T19:12:17+0000 lvl=info msg=\"Error handling the forwarder accept error\" error=\"no tunnel found with requested name\"\n", "04-Aug-24 07:12:17 PM - INFO: Opening tunnel named: http-8901-dbbf6775-d1b1-4b5c-ad30-fc781622caef\n", "04-Aug-24 07:12:17 PM - INFO: t=2024-08-04T19:12:17+0000 lvl=info msg=start pg=/api/tunnels id=3d43722d46a8ba3a\n", "04-Aug-24 07:12:17 PM - INFO: t=2024-08-04T19:12:17+0000 lvl=info msg=\"started tunnel\" obj=tunnels name=http-8901-dbbf6775-d1b1-4b5c-ad30-fc781622caef addr=http://localhost:8901 url=https://f668-34-74-204-234.ngrok-free.app\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "Click on https://f668-34-74-204-234.ngrok-free.app to open the NameNode Web UI 🚀\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "04-Aug-24 07:12:17 PM - INFO: t=2024-08-04T19:12:17+0000 lvl=info msg=end pg=/api/tunnels id=3d43722d46a8ba3a status=201 dur=46.18765ms\n" ] } ] }, { "cell_type": "markdown", "source": [ "By clicking on the above link you should see the NameNode's Web UI in your browser:\n", "\n" ], "metadata": { "id": "zya4FAgnTGHz" } }, { "cell_type": "markdown", "source": [ "![namenodeUIoverview.png](data:image/png;base64,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)" ], "metadata": { "id": "GXZifg7YhvBa" } }, { "cell_type": "markdown", "source": [ "# Test the HDFS filesystem" ], "metadata": { "id": "PWLoLFJabAev" } }, { "cell_type": "markdown", "source": [ "## Create a directory\n", "\n", "**Note:** in order to use the MiniCluster's Hadoop filesystem you need to specify the full path prepending `hdfs://localhost:8902/` otherwise `hdfs` will write to the local filesystem." ], "metadata": { "id": "9jA_tBoV647p" } }, { "cell_type": "code", "source": [ "%%bash\n", "# create a folder my_dir\n", "hdfs dfs -mkdir hdfs://localhost:8902/my_dir" ], "metadata": { "id": "wCYTzNvlfzRO" }, "execution_count": 39, "outputs": [] }, { "cell_type": "markdown", "source": [ "List the contents of `my_dir` (should be empty)." ], "metadata": { "id": "NiIBxgBi8KQh" } }, { "cell_type": "code", "source": [ "!hdfs dfs -ls hdfs://localhost:8902/my_dir" ], "metadata": { "id": "yATUZZ5hbEHh" }, "execution_count": 40, "outputs": [] }, { "cell_type": "markdown", "source": [ "Upload the local folder `sample_data` to `my_dir` on HDFS" ], "metadata": { "id": "5vKshDCX8Sc2" } }, { "cell_type": "code", "source": [ "!ls -lh sample_data" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "PiVF1RFzeLXd", "outputId": "77ff6b8e-af93-41a4-9b57-846d5b4a693c" }, "execution_count": 41, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "total 55M\n", "-rwxr-xr-x 1 root root 1.7K Jan 1 2000 anscombe.json\n", "-rw-r--r-- 1 root root 295K Aug 1 13:24 california_housing_test.csv\n", "-rw-r--r-- 1 root root 1.7M Aug 1 13:24 california_housing_train.csv\n", "-rw-r--r-- 1 root root 18M Aug 1 13:24 mnist_test.csv\n", "-rw-r--r-- 1 root root 35M Aug 1 13:24 mnist_train_small.csv\n", "-rwxr-xr-x 1 root root 930 Jan 1 2000 README.md\n" ] } ] }, { "cell_type": "markdown", "source": [ "Check the total size of the local folder `sample_data` using the command `du` (\"du\" stands for \"disk usage\" and the `-h` option stands for \"human\" as it will format file sizes in a “human-readable” fashion, e.g 55M instead of 55508) ." ], "metadata": { "id": "ayePcxZ7TuXm" } }, { "cell_type": "code", "source": [ "!du -h sample_data" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Kp119M2bTrzy", "outputId": "b16cff16-1d95-468a-f93f-1ac802305fe5" }, "execution_count": 42, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "55M\tsample_data\n" ] } ] }, { "cell_type": "markdown", "source": [ "Upload `sample_data` to HDFS." ], "metadata": { "id": "4zer_jX7T2ZD" } }, { "cell_type": "code", "source": [ "!hdfs dfs -put sample_data hdfs://localhost:8902/my_dir/" ], "metadata": { "id": "WfV62y1yeu6O" }, "execution_count": 43, "outputs": [] }, { "cell_type": "markdown", "source": [ "Check" ], "metadata": { "id": "gP1gYl7t8Sh9" } }, { "cell_type": "code", "source": [ "!hdfs dfs -ls hdfs://localhost:8902/my_dir" ], "metadata": { "id": "mL8pfXzVUBS_", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "83f6dd1d-c0dd-48b2-9eb7-86a1e96e7d4e" }, "execution_count": 44, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Found 1 items\n", "drwxr-xr-x - root supergroup 0 2024-08-04 19:12 hdfs://localhost:8902/my_dir/sample_data\n" ] } ] }, { "cell_type": "markdown", "source": [ "Check the size of `my_dir` on HDFS using the [HDFS equivalent of `du`](https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/FileSystemShell.html#du)." ], "metadata": { "id": "7h7gL8tOlS17" } }, { "cell_type": "code", "source": [ "!hdfs dfs -du -h hdfs://localhost:8902/my_dir" ], "metadata": { "id": "1zCBrlOEUKpU", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "813e3030-27bc-4deb-b058-8e288fabbce6" }, "execution_count": 45, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "54.2 M 162.6 M hdfs://localhost:8902/my_dir/sample_data\n" ] } ] }, { "cell_type": "markdown", "source": [ "Check the contents of the HDFS folder `my_dir`" ], "metadata": { "id": "IQDzG-TOEB9a" } }, { "cell_type": "code", "source": [ "!hdfs dfs -ls -R -h hdfs://localhost:8902/my_dir" ], "metadata": { "id": "U1XOv7NZhY9F", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "91925578-7e05-4296-a538-2f2842d1bb7a" }, "execution_count": 46, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "drwxr-xr-x - root supergroup 0 2024-08-04 19:12 hdfs://localhost:8902/my_dir/sample_data\n", "-rw-r--r-- 3 root supergroup 930 2024-08-04 19:12 hdfs://localhost:8902/my_dir/sample_data/README.md\n", "-rw-r--r-- 3 root supergroup 1.7 K 2024-08-04 19:12 hdfs://localhost:8902/my_dir/sample_data/anscombe.json\n", "-rw-r--r-- 3 root supergroup 294.1 K 2024-08-04 19:12 hdfs://localhost:8902/my_dir/sample_data/california_housing_test.csv\n", "-rw-r--r-- 3 root supergroup 1.6 M 2024-08-04 19:12 hdfs://localhost:8902/my_dir/sample_data/california_housing_train.csv\n", "-rw-r--r-- 3 root supergroup 17.4 M 2024-08-04 19:12 hdfs://localhost:8902/my_dir/sample_data/mnist_test.csv\n", "-rw-r--r-- 3 root supergroup 34.8 M 2024-08-04 19:12 hdfs://localhost:8902/my_dir/sample_data/mnist_train_small.csv\n" ] } ] }, { "cell_type": "markdown", "source": [ "You should now see in the Web interface that the \"DFS used\" has increased (you might need to refresh the NameNode UI Web page):" ], "metadata": { "id": "tuI4QmYnCyvp" } }, { "cell_type": "markdown", "source": [ "![dfs_used.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAACQ4AAAEECAYAAABj6TuGAAAMa2lDQ1BJQ0MgUHJvZmlsZQAASImVVwdYU8kWnluSkJDQAqFICb0JIr1ICaFFEJAONkISSCgxJgQVOyIquHYRxYquiii6FkAWFbGXRbH3xYLKyrpYUBSVNyEBXfeV753vmzv/PXPmP+XO3HsHAM1erkSSi2oBkCfOl8aFBzNTUtOYpOcAAVRABkygzeXJJKzY2CgAZbD/u7y/Ca2hXHNScP1z/L+KDl8g4wGAjIc4gy/j5UHcDAC+gSeR5gNAVOgtp+ZLFHguxLpSGCDEqxU4S4l3KXCGEjcN2CTEsSG+AoAalcuVZgGgcR/qmQW8LMij8RliFzFfJAZAczjEATwhlw+xIvbheXmTFbgCYjtoL4EYxgO8M77jzPobf8YQP5ebNYSVeQ2IWohIJsnlTv8/S/O/JS9XPujDBjaqUBoRp8gf1vB2zuRIBaZC3CXOiI5R1BriXhFfWXcAUIpQHpGotEeNeTI2rB9gQOzC54ZEQmwMcZg4NzpKpc/IFIVxIIarBZ0myuckQGwA8SKBLDReZbNFOjlO5Quty5SyWSr9Oa50wK/C10N5TiJLxf9GKOCo+DGNQmFCMsQUiK0KREnREGtA7CzLiY9U2YwqFLKjB22k8jhF/FYQxwnE4cFKfqwgUxoWp7IvzZMN5ottEYo40Sp8IF+YEKGsD3aKxx2IH+aCXRGIWYmDPAJZStRgLnxBSKgyd+yFQJwYr+LpleQHxynn4hRJbqzKHrcQ5IYr9BYQu8sK4lVz8aR8uDiV/HimJD82QRknXpjNHR2rjAdfDqIAG4TA3SeHLQNMBtlA1NpV3wXvlCNhgAukIAsIgJNKMzgjeWBEDK/xoBD8CZEAyIbmBQ+MCkAB1H8Z0iqvTiBzYLRgYEYOeAZxHogEufBePjBLPOQtCTyFGtE/vHNh48F4c2FTjP97/aD2m4YFNVEqjXzQI1Nz0JIYSgwhRhDDiPa4ER6A++FR8BoEmyvujfsM5vHNnvCM0EZ4TLhBaCfcmSQqkv4Q5RjQDvnDVLXI+L4WuA3k9MCDcX/IDplxBm4EnHB36IeFB0LPHlDLVsWtqArzB+6/ZfDd01DZkV3IKFmfHES2+3GmhoOGxxCLotbf10cZa8ZQvdlDIz/6Z39XfT7sI3+0xBZhB7Gz2AnsPNaE1QMmdhxrwC5hRxV4aHU9HVhdg97iBuLJgTyif/jjqnwqKilzqXHpdPmsHMsXTMtXbDz2ZMl0qShLmM9kwa+DgMkR85yHM11dXN0AUHxrlK+vt4yBbwjCuPBNV/QOAH9+f39/0zddFNzrhxbA7f/sm872GHxN6ANwrownlxYodbjiQoBvCU240wyBKbAEdjAfV+AJ/EAQCAWjQQxIAKlgIqyyEK5zKZgKZoJ5oASUgeVgDVgPNoNtYBfYCw6AetAEToAz4CK4Am6Ae3D1dICXoBu8B30IgpAQGkJHDBEzxBpxRFwRbyQACUWikDgkFUlHshAxIkdmIvORMmQlsh7ZilQjvyBHkBPIeaQNuYM8QjqRN8gnFEOpqC5qgtqgI1BvlIVGognoBDQLnYIWosXoUrQCrUL3oHXoCfQiegNtR1+iPRjA1DEGZo45Yd4YG4vB0rBMTIrNxkqxcqwKq8Ua4XO+hrVjXdhHnIjTcSbuBFdwBJ6I8/Ap+Gx8Cb4e34XX4afwa/gjvBv/SqARjAmOBF8Ch5BCyCJMJZQQygk7CIcJp+Fe6iC8JxKJDKIt0QvuxVRiNnEGcQlxI3EfsZnYRnxC7CGRSIYkR5I/KYbEJeWTSkjrSHtIx0lXSR2kXjV1NTM1V7UwtTQ1sVqRWrnabrVjalfVnqv1kbXI1mRfcgyZT55OXkbeTm4kXyZ3kPso2hRbij8lgZJNmUepoNRSTlPuU96qq6tbqPuoj1UXqc9Vr1Dfr35O/ZH6R6oO1YHKpo6nyqlLqTupzdQ71Lc0Gs2GFkRLo+XTltKqaSdpD2m9GnQNZw2OBl9jjkalRp3GVY1XmmRNa02W5kTNQs1yzYOalzW7tMhaNlpsLa7WbK1KrSNat7R6tOnaI7VjtPO0l2jv1j6v/UKHpGOjE6rD1ynW2aZzUucJHaNb0tl0Hn0+fTv9NL1Dl6hrq8vRzdYt092r26rbraej566XpDdNr1LvqF47A2PYMDiMXMYyxgHGTcYnfRN9lr5Af7F+rf5V/Q8GwwyCDAQGpQb7DG4YfDJkGoYa5hiuMKw3fGCEGzkYjTWaarTJ6LRR1zDdYX7DeMNKhx0YdtcYNXYwjjOeYbzN+JJxj4mpSbiJxGSdyUmTLlOGaZBptulq02OmnWZ0swAzkdlqs+NmfzD1mCxmLrOCeYrZbW5sHmEuN99q3mreZ2FrkWhRZLHP4oElxdLbMtNytWWLZbeVmdUYq5lWNVZ3rcnW3tZC67XWZ60/2NjaJNsstKm3eWFrYMuxLbStsb1vR7MLtJtiV2V33Z5o722fY7/R/ooD6uDhIHSodLjsiDp6OoocNzq2DScM9xkuHl41/JYT1YnlVOBU4/TImeEc5VzkXO/8aoTViLQRK0acHfHVxcMl12W7y72ROiNHjywa2TjyjauDK8+10vW6G80tzG2OW4Pba3dHd4H7JvfbHnSPMR4LPVo8vnh6eUo9az07vay80r02eN3y1vWO9V7ifc6H4BPsM8enyeejr6dvvu8B37/8nPxy/Hb7vRhlO0owavuoJ/4W/lz/rf7tAcyA9IAtAe2B5oHcwKrAx0GWQfygHUHPWfasbNYe1qtgl2Bp8OHgD2xf9ix2cwgWEh5SGtIaqhOaGLo+9GGYRVhWWE1Yd7hH+Izw5ghCRGTEiohbHBMOj1PN6R7tNXrW6FOR1Mj4yPWRj6McoqRRjWPQMaPHrBpzP9o6WhxdHwNiODGrYh7E2sZOif11LHFs7NjKsc/iRsbNjDsbT4+fFL87/n1CcMKyhHuJdonyxJYkzaTxSdVJH5JDklcmt6eMSJmVcjHVKFWU2pBGSktK25HWMy503JpxHeM9xpeMvznBdsK0CecnGk3MnXh0kuYk7qSD6YT05PTd6Z+5Mdwqbk8GJ2NDRjePzVvLe8kP4q/mdwr8BSsFzzP9M1dmvsjyz1qV1SkMFJYLu0Rs0XrR6+yI7M3ZH3Jicnbm9Ocm5+7LU8tLzzsi1hHniE9NNp08bXKbxFFSImmf4jtlzZRuaaR0hwyRTZA15OvCn/pLcjv5AvmjgoCCyoLeqUlTD07Tniaedmm6w/TF058XhhX+PAOfwZvRMtN85ryZj2axZm2djczOmN0yx3JO8ZyOueFzd82jzMuZ91uRS9HKonfzk+c3FpsUzy1+siB8QU2JRom05NZCv4WbF+GLRItaF7stXrf4aym/9EKZS1l52eclvCUXfhr5U8VP/Uszl7Yu81y2aTlxuXj5zRWBK3at1F5ZuPLJqjGr6lYzV5eufrdm0prz5e7lm9dS1srXtldEVTSss1q3fN3n9cL1NyqDK/dtMN6weMOHjfyNVzcFbardbLK5bPOnLaItt7eGb62rsqkq30bcVrDt2fak7Wd/9v65eofRjrIdX3aKd7bvitt1qtqrunq38e5lNWiNvKZzz/g9V/aG7G2odarduo+xr2w/2C/f/8cv6b/cPBB5oOWg98HaQ9aHNhymHy6tQ+qm13XXC+vbG1Ib2o6MPtLS6Nd4+FfnX3c2mTdVHtU7uuwY5Vjxsf7jhcd7miXNXSeyTjxpmdRy72TKyeunxp5qPR15+tyZsDMnz7LOHj/nf67pvO/5Ixe8L9Rf9LxYd8nj0uHfPH473OrZWnfZ63LDFZ8rjW2j2o5dDbx64lrItTPXOdcv3oi+0XYz8ebtW+Nvtd/m335xJ/fO67sFd/vuzb1PuF/6QOtB+UPjh1W/2/++r92z/eijkEeXHsc/vveE9+TlU9nTzx3Fz2jPyp+bPa9+4fqiqTOs88of4/7oeCl52ddV8qf2nxte2b069FfQX5e6U7o7Xktf979Z8tbw7c537u9aemJ7Hr7Pe9/3obTXsHfXR++PZz8lf3reN/Uz6XPFF/svjV8jv97vz+vvl3Cl3IFfAQw2NDMTgDc7AaClAkCH5zbKOOVZcEAQ5fl1AIH/hJXnxQHxBKAWdorfeHYzAPths5kLuYMAUPzCJwQB1M1tqKlElunmquSiwpMQobe//60JAKRGAL5I+/v7Nvb3f9kOg70DQPMU5RlUIUR4ZtgSoEA3DFK2gh9EeT79Lscfe6CIwB382P8LRN2PY8nL7lUAAACKZVhJZk1NACoAAAAIAAQBGgAFAAAAAQAAAD4BGwAFAAAAAQAAAEYBKAADAAAAAQACAACHaQAEAAAAAQAAAE4AAAAAAAAAkAAAAAEAAACQAAAAAQADkoYABwAAABIAAAB4oAIABAAAAAEAAAkOoAMABAAAAAEAAAEEAAAAAEFTQ0lJAAAAU2NyZWVuc2hvdL9VossAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAHXaVRYdFhNTDpjb20uYWRvYmUueG1wAAAAAAA8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJYTVAgQ29yZSA2LjAuMCI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOmV4aWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vZXhpZi8xLjAvIj4KICAgICAgICAgPGV4aWY6UGl4ZWxZRGltZW5zaW9uPjI2MDwvZXhpZjpQaXhlbFlEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlBpeGVsWERpbWVuc2lvbj4yMzE4PC9leGlmOlBpeGVsWERpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6VXNlckNvbW1lbnQ+U2NyZWVuc2hvdDwvZXhpZjpVc2VyQ29tbWVudD4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CidKQukAAAAcaURPVAAAAAIAAAAAAAAAggAAACgAAACCAAAAggAAUN9677UQAABAAElEQVR4AezdCbxV8/7/8W8DSZEmIa66KEMUwi+Uoswumefpyg0hIVKhmzFDSDIUERmvebqEa/jF5afENaQBl4Qk6QoJ/97f67P+373O2tM5e5+zz9mv7+Nx715r7bXWXuu51unxWF/v9fnW+21FczQEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBAoK4F6BIfK6npzsggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIeAGCQ9wICCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAgiUoQDBoTK86JwyAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIEh7gHEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBAoQwGCQ2V40TllBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQIDnEPIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCBQhgIEh8rwonPKCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggQHOIeQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEECgDAUIDpXhReeUEUAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBAgOMQ9gAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAGQoQHCrDi84pI4AAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCBAcIh7AAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQACBMhQgOFSGF51TRgABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEECA4BD3AAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACZShAcKgMLzqnjAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAQYNDc+fORRQBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQSKJPDHP/6xYHsmOFQwSnaEAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggEBxBUo+OLTuuusWV4C9I4AAAggggAACCCCAAAIIIIAAAggggAACaQQ+++wz/w39lGmAWIwAAggggAACCCCAAAIIIFArBex5l+BQrbx8HDQCCCCAAAIIIIAAAggggAACCCCAAAIIVIeAdaQSHKoObX4DAQQQQAABBBBAAAEEEECgugTseZfgUHWJ8zsIIIAAAggggAACCCCAAAIIIIAAAgggUOsErCOV4FCtu3QcMAIIIIAAAggggAACCCCAQAYBe94lOJQBia8QQAABBBBAAAEEEEAAAQQQQAABBBBAoLwFrCOV4FB53wecPQIIIIAAAggggAACCCBQ1wTseZfgUF27spwPAggggAACCCCAAAIIIIAAAggggAACCBRMwDpSCQ4VjJQdIYAAAggggAACCCCAAAIIlICAPe8SHCqBi8EhIIAAAggggAACCCCAAAIIIIAAAggggEBpClhHKsGh0rw+HBUCCCCAAAIIIIAAAggggEDlBOx5l+BQ5fzYCgEEEEAAAQQQQAABBBBAAAEEEEAAAQTKQMA6UgkOlcHF5hQRQAABBBBAAAEEEEAAgTISsOddgkNldNE5VQQQQAABBBBAAAEEEEAAAQQQQAABBBDIT8A6UgkO5efG2ggggAACCCCAAAIIIIAAAqUtYM+7BIdK+zpxdAgggAACCCCAAAIIIIAAAggggAACCCBQgwLWkUpwqAYvAj+NAAIIIIAAAggggAACCCBQcAF73iU4VHBadogAAggggAACCCCAAAIIIIAAAggggAACdUXAOlIJDtWVK8p5IIAAAggggAACCCCAAAIISMCedwkOcT8ggAACCCCAAAIIIIAAAggggAACCCCAAAJpBKwjleBQGiAWI4AAAggggAACCCCAAAII1EoBe94lOFQrLx8HjQACCCCAAAIIIIAAAggggAACCCCAAALVIWAdqQSHqkOb30AAAQQQQAABBBBAAAEEEKguAXveJThUXeL8DgIIIIAAAggggAACCCCAAAIIIIAAAgjUOgHrSCU4VOsuHQeMAAIIIIAAAggggAACCCCQQcCedwkOZUDiKwQQQAABBBBAAAEEEEAAAQQQQAABBBAobwHrSCU4VN73AWePAAIIIIAAAggggAACCNQ1AXveJThU164s54MAAggggAACCCCAAAIIIIAAAggggAACBROwjlSCQwUjZUcIIIAAAggggAACCCCAAAIlIGDPuwSHSuBicAgIIIAAAggggAACCCCAAAIIIIAAAgggUJoC1pFKcKg0rw9HhQACCCCAAAIIIIAAAgggUDkBe94lOFQ5P7ZCAAEEEEAAAQQQQAABBBBAAAEEEEAAgTIQsI5UgkNlcLE5RQQQQAABBBBAAAEEEECgjATseZfgUBlddE4VAQQQQAABBBBAAAEEEEAAAQQQQAABBPITsI5UgkP5ubE2AggggAACCCCAAAIIIIBAaQvY8y7BodK+ThwdAggggAACCCCAAAIIIIAAAggggAACCNSggHWkEhyqwYvATyOAAAIIIIAAAggggAACCBRcwJ53CQ4VnJYdIoAAAggggAACCCCAAAIIIIAAAggggEBdEbCOVIJDdeWKch4IIIAAAggggAACCCCAAAISsOddgkPcDwgggAACCCCAAAIIIIAAAggggAACCCCAQBoB60glOJQGiMUIIIAAAggggAACCCCAAAK1UsCedwkO1crLx0EjgAACCCCAAAIIIIAAAggggAACCCCAQHUIWEcqwaHq0OY3EEAAAQQQQAABBBBAAAEEqkvAnncJDlWXOL+DAAIIIIAAAggggAACCCCAAAIIIIAAArVOwDpSCQ7VukvHASOAAAIIIIAAAggggAACCGQQsOddgkMZkPgKAQQQQAABBBBAAAEEEEAAAQQQQAABBMpbwDpSCQ6V933A2SOAAAIIIIAAAggggAACdU3AnncJDtW1K8v5IIAAAggggAACCCCAAAIIIIAAAggggEDBBKwjleBQwUjZEQIIIIAAAggggAACCCCAQAkI2PNu2QaHvv76a/fWW2+5OXPmuFmzZrn58+e75s2buxYtWrgtttjCdevWzbVt27YELlVuh/DTTz+5F154wc2bN8998803TvPdu3d3O+20k5s9e7Z74oknoh2pk+OAAw6I5plIFpDb22+/HX3ZqlUr16NHj2g+34m6ds/le/5VWf+XX35xY8eOdb/99lu0m0MPPdS1adMmmmcCAQQQQAABBBBAAAEEEEAAAQQQKIaAdaQSHCqGbs3tU/3C7733nu8bfv/9992CBQt8//Caa67pNt10U9e7d++s/cOvvPKKW7x4ccaTWH311V27du3cOuus4xo0aJBxXb5EAAEEEEAAAQQQQAABBKpTwJ53yy44pODB448/7i699NKs3rvvvrsbMGCADxNlXbkGV/j888/dySef7L766quUozjqqKPcSSed5P7xj3+48847L/quc+fObty4cdE8E8kCd999txszZkz0pQJlN954YzSf60RdvOdyPfdCracgXK9evVJ2N378eN+JYws/+ugjt3TpUpt1f/jDH9xqq60WzTOBAAIIIIAAAggggAACCCCAAAIIVEbAOlILHRx655133IwZM3x4RZ9qG220kWvfvr3ba6+93IYbbpjz4aof65lnnnEbbLCBGzZsWMbtJk+e7L799tuM6+jLDh06+PBM1hVzWOHVV191Z555pl/zggsucLvttlvard544w337rvvun/9619OgZ411ljD9/N07NjR9e3b1zVr1izttrl88fPPP7tbbrnF3XnnnVlX33XXXd2QIUNco0aNEtc94ogjnPqkcm1av3///gSIcgVjPQQQQAABBBBAAAEEECiqgD3vllVw6D//+Y8bPny4++c//5kzrqoQKaCw9tpr57xNda944YUX+o6B+O8SHIqL5DdfiOBQXb3n8pOs+tq5BIf69evnO5Xs10aMGOH69Oljs3wigAACCCCAAAIIIIAAAggggAAClRKwjtRCBocefPBBd+WVV2Y8Hr0QqKBJ/fr1M67366+/uv3339+/VKhwzW233ZZx/e233z7j9/blLrvs4kaOHGmzlf5cuHChO+SQQ6IXvvSC49577524v5tvvtlNnDgx8TtbmC14ZOslff773/922n7mzJkVvtZLaPo+3vQS5qhRoxJfUMs3OKR9b7XVVu7yyy93TZo0if8U8wgggAACCCCAAAIIIIBAtQrY825ZBYdGjx7t7r///ryhVUZWb6CsssoqeW9bHRskPewr8KTgkIZzouJQ5a5CIYJDdfWeq5xo5bciOFR5O7ZEAAEEEEAAAQQQQAABBBBAAIGqCVhHaqGCQ/fee6+79tpro4NaddVV3eabb+5WWmklN23atChgoxWGDh3qqw9FKydM3H777e6mm27y32QLDn3zzTdpQzvxXRciOKRQ09lnn+1UcchauuCQzkHnYs1cPvzwQ7do0SJb7D8VjtK55tOWLVvmDj/8cKfq7daOPPJI77veeutFAa1PP/3UPfzww059g9Y22WQTN2HCBJuNPsPg0FVXXeXWWmut6DtN/PDDDz7Q9dRTT7mXX345+u4vf/mLO+aYY6J5JhBAAAEEEEAAAQQQQACBmhCw592yCQ598MEH7vjjj69grXKz+p/GmdbbLyqFqwpD8XbKKaf4N3ziy2t6XmNo77HHHimHEe9Q0Doas9uaxtXOp9SxbVdun1UNDtXVe64m7gMN96ZKYfq0pqHjwjezqDhkMnwigAACCCCAAAIIIIAAAggggEAhBawjtRDBIfU/7rPPPtHhHX300e7EE0+MQiuqXq1KRBp2TE3hmYceeiil2o2GGfvkk0/8EFnPPfece/PNN6P9ZQsOaQgw9aGoqVqz+lfSNf12VYeBj4ek9FtJwSGFeQ488MDoUAYPHuz2228/P6/wkfrZFMzR0GVqlQk1TZo0yY0bN85vr3O75JJL3Lbbbuvnk/5PQZ9zzjkn+ioprBQGh/72t7+lrVqvPi29YPjAAw/4/Wk4urvuuivaNxMIIIAAAggggAACCCCAQE0I2PNuWQSHfvnlF3fCCSdUKEGrh/Jjjz22gr/GF9dbH2HTw+Tf//73xPGn58+f74M5c+fO9Q/sCuZoPHE9AGpc8qRKRXpY1PjXevBVa9CggV9f8wpIaF8//vija9WqlV8ef4jXet99951/Q0bnFjaN0d22bVv/u/pt7efrr7+OVtGY3K1bt47mwwk9pOstno8//thvr/NQ+Vwd7+zZs6NVGzZsmBI+0nY6HmstWrRwa665ps36T40fHgaYtFCdGfXq1fPff/nllylvD+kc1Dmhfb/++us+2NWrVy8Xv2nVWTJr1ix/fHr7SBWitF8d+8orr+z3ne7/dG+oBLHOed68ed5Nb3hpH1UJDhXznlu6dKnvHNJx2x+y7hN1XnXp0iXxHpXRF198ETG0bNnS3wNLlizx95vsdV/oftX49Y0bN47WTZrQ22n6fb2BJTetr2Ow7ZO2CZd9//33/h7T/aDtNVa9hgPUdUs3LKBKSIfBIf196ZjVobZ8+XJ3xhlnpPyNn3XWWW7nnXf294DMwr8BHYvOM6nUtzqiwqY3xXR8NAQQQAABBBBAAAEEEEAAAQQQKE8B638pRHBI4RIFYNQUfvnrX/8a9Y2ZrvryVEX8q6++8ou0frdu3exrpz6PqVOnRvPhRLbg0LPPPuuH6tI2CrGoD6xYTf1tSX2vScEhVXu/4YYb/KGoCtDJJ59c4bDCcJGO20I4FVZMWCBLCyLpa7n37t07Yc3URWPHjo0CPromp512WsoKuQaHtFH8JcN01zDlB5hBAAEEEEAAAQQQQAABBIooYM+78QxGVX6y3or/qP//y4FUZU8rtlVwRq0QD+RJQSAFcW688Ub/G0n/N2zYMPf888+nfKW3QBRWsKZwiErUZhp3Ww+xF110kdt4441tM/+psIMqHYVND7uDBg1KO5a2HqpVNldt+vTpTlWQMrW99trLlzOOD1Wm8brvueeelE01FNSll14avc0UfqlSvP3793enn356tFhBqilTpkTzOjb9jjW9IaRzCZuCR3qLKmwKY9mbSxrb+5FHHom+VuUkBT70No61yy67zPXo0cPPKjylN66ss8XWCT/V0aBKU0nhLQVJdJ3ffvvtcBM/3bdvX99xos4Ba9nuGVtPn8W65/Smk94Gk0tS03U57rjjKlTHCjultN1BBx3kOnXq5MdTj+9L+9D49WGHlP2W7nm9naXx5tM13V+6V5K21za65jqHdE1/FwruhQGiTEOV6V5Tx1G6ttlmm/mOuOuuuy5lFQXs9F3YFIQ65JBDwkXu4osvdgqsqSkkGJbM1jJ5t2nTRpM0BBBAAAEEEEAAAQQQQAABBBCogwLWkVqIfkr1bT366KNe6YILLnC77bZbotjVV18dBWMUolEfl7WqBIdUNUd9ImrqZ9LLjMVoGqJLfSZ68ax58+Z+iDDrZ0sKDoUu8aBUeHzbb799NPu///u/FUJX0ZexCfUv3n///X6p+jplkPRCWWwz/+KbhjdT03k88cQTKavkExxSf7ddx6R9peyYGQQQQAABBBBAAAEEEECgGgTsebcsgkN6oNN//A9bGEAJl9v0xysq7jz99NM26z/33nvvKMikSi0qmTtjxoyUddLNxIcPSwoOKXChh+l0TcOLKahk450PGDAg3ap+ea7BIVV/OfPMMxMDNOl+oDqCQ+oIiL95Y9dNARb5h+OjpztWBVhGjRqV0hGiak/yi4+Pnm4fWp5PcKgY99ytt96aOIxe0jFrjPSwalY8OKTOiWznrvBPGKJRUEvLwvLXSb9ty1RWO+zMUa5QJaDjHSy2fvipvwUNGdi0aVO/uKrBIYX3FAYLmwJl8WpdCqJdccUV4WpOJb+tAlNYzttW0nWJBwPtOz4RQAABBBBAAAEEEEAAAQQQQKD2C1hHaiGCQ6qYrGrjaqqyk65zdsyYMb4attZTH4/6eqwtXrzYKZhjbcGCBVE/ULaKQ6q0oz7PYg+VFQaB9DKXql1b/2xScEjrmIsqDzVr1sxOL/rUPqx/J9+KQ3op0l4eVN/PDjvsEO23KhP5BIfCqkrdu3f3L/RV5bfZFgEEEEAAAQQQQAABBBCoqoA976Z7Nq3M/ku24pAqC91xxx0p5/Tiiy/6AE7Kwjxmwof3XDcLx7lOCg7lsh97E0kPunrgzdT23XdfPw53topDsslUfSnpN6ojOJT0uxYc0ptZms61nXrqqe6www6LVg87aaKFWSbyCQ4V+p7TMGP7779/hSPUdYhXDLKVdN1tqLZ4cMjWyfapII1V01EFLlVoird0x7D11ls7/Z1Yi48Lb8vTfVrwTd9nCg6pTHSmwJ1dt5NOOikl6JfUQaYw2iuvvBId0u677+7OP//8aJ7gUETBBAIIIIAAAggggAACCCCAAAJlI2AdqYUIDr311ltOQ8Cr7bTTTikvuhmoXphT1W69+KaWLegSDsOVLTj05z//2b3//vv+Za+uXbv6vhLNq69SLy1qe1Wqrsq5vvDCC74Kuo5dwRpVTQ9fsksKDmndTE3Dt6mPxvptdIzq38u1aVgy60Mr5BBt2YJDCnh98skn7rXXXkup4K3KT7KmIYAAAggggAACCCCAAAI1KWDPu2URHBoyZIhTUMhaVUvBhuNp2z71louGX9IDnx609QCqSiRhC0MI6YJDKlerykZNmjTxw3ap6krYjjrqKKcAhLWFCxe6ffbZx2b95+OPP+5atGgRLcsUHNID85/+9Kfowdk26tevn9tqq618VRqFYOLBjOoODqnjYq211vLjomu4Nr1dZA/7OmaFQ4YPH+5atmzpOxDkFh6zro/KEderVy9xGDHdExqjvHXr1k5ljjVkWrh/+41cA1aFvud0TVWtJ2w21JY6TjT8l4Z6C1tYCSddcEidGwr46H7UUHwzZ84Md+HC8I69kWYr6JqodLTMvvvuO6dy04899ph97T+t5PXy5ct9KebwmmgFOek+07BxGh4tHHJM99gzzzzjy0ZnCg6pkpH+p7fvFOyxppBdnz59/DXXdU8Kmz344IP+vtI2y5Ytcz179rTN/We8NDbBoRQeZhBAAAEEEEAAAQQQQAABBBAoCwHrSK1KmCYfqHHjxvmh4m2bJ5980q2xxho2W+Ezn+BQGKCpsKNggV5YVD+k+lTyaaoKpP4m9aup70h9dHqxrTLBoYcffth9++23bvbs2W769OlR9WxVqpaR+vNyadrHnnvuGa360ksvuYYNG0bzNqE+NvVhZWqqSh0O7xYGh9SX1ahRo2hz9WfF+xe1jvrAVCGdhgACCCCAAAIIIIAAAgjUtIA975ZFcEhv6OgB09pmm20WjeVty/L5VLlclZYNW1iZxZaHY5HbMgUrFG5JCg7tsssu/sHR1tVn/Nj1JtKll14arVLV4NCUKVNSKqpox2effXZU9lfzOlYNWRUObVVdwSGFWlRZSEEqa/EglJarapI6I6xpCDMNvxY2C9rILx5wue+++1LepFJ4SA5hs8o14bJ00/HrVtV7buLEiSn3nMJeCjpZ09tLun/CZtWZtCwpOKQOIB2nNV1nBdfU2WQtDNnpLa533nnHvvJvjvXq1Suaf/31193AgQOjeU1Yx5Y6d/R2WdhU3We//faLFr3xxht+KLRowYoJnXeHDh0yVhyy9RV2C4NDCvIpOGQt3kmk5eeee64Pzml62rRpfvg6TavpHn/qqadSKpMp+KS/67CdddZZKfdO+B3TCCCAAAIIIIAAAggggAACCCBQ+wWsI7XYwSG9mHXNNdf4ocRMbejQof7FLptP+sw1OJTUN6KX7bp06eKWLFnih6cPgy7qWzvggAOSfjJxmSolDRgwIKr4rJfUVPFZrTLBIfUbhf1U9qNhVXdblukzfBFszTXXdAokJTUdu/qHMjUNtxb2h4XBoUzbhd+pj00vRSaFl8L1mEYAAQQQQAABBBBAAAEEii1gz7tlERyKP8BtsskmbsKECZU2VlBg6tSp0fZhJaFo4YoJhQw0jFLYFDrSw3hScEgVXfTWT9j0MKoHa2t6G0VVUKxVNTikYMbNN99su/NhCYWJ4i0cg1vfVUdwSL+hSjurrLJKyuEkHUtoopWtoyLc8Pjjj3cnnHCCr9g0Y8aM6CsFjuJD2enL+HBm+QSHCn3PRQf7+4TuH/0Rz58/382aNctpGLF4NZ9MwSHZWjWfcN+jR4/2lZnCZc8995zT21TxpipB8+bN88egkta6T8POJa1vwaGwc8j2Ex8uUNdMgS5VD7Km+12VpjJVHLJ1swWHtF58KLIdd9zRjRo1yu8i/jafhobT3zoNAQQQQAABBBBAAAEEEEAAAQTKW8A6UosVHPr11199P82VV16Z0rdy2GGH+SBOtqo/uQaH1H+jocrU1Dekl6PU32Vt8eLFTn1D6jOyds899zhV+Mmlhf2M8dBR2DeU61Bl8Rfz7Bh07Ko8rhcsc2nqB7QK7pmCQ/Fh7pP2nSk4tOuuu7pmzZqlbKa+srlz5/rh4cIvOnfu7Kt3169fP1zMNAIIIIAAAggggAACCCBQrQL2vFsWwSE9jKpKjTU9XCaFY+z7bJ/xt11OPfVUpwf5eNNDv4IJYbMKJ0nBIauuEq6v4Z/0do61QgeH4sEkDRt1/fXX289FnxqHe9CgQdF83DBufOCBB6asrw1V9SmscKNlGmJrtdVW06QfaktDhFkLQx22TJ9JFYPC79NN2zFp+K2wepJCPvFqONqHhiULA0X5BIfiHnGvdMeYafnPP//sK+Co8ybb20/aT6bgULoKSCrVrHs0bApq2T8UCqop3PP0009XCCqF29i0BYcUTtP9bU1vs2k4v1xboYJDSRW2FLpSOC0e9rKQX67HyHoIIIAAAggggAACCCCAAAIIIFA3BawjtRjBIVXDUYBHoR5rqgB9zjnnuB49etiijJ+5BodUcUjVpBVmUd9Q0vmo/0nhIqverorX8Rcjkw5G+9Uw8mrqv7ziiiv88PO2bmWCQ7atqiHJSX2kb775pi3281bRKFqYMKGX31S929rLL7+cMtyYLX/22Wf9C3I2b5/qTzKPiy66yO288872VUp/UqZKSHpRThXrFQ6zphfW9OIaDQEEEEAAAQQQQAABBBCoKQF73rU8QCGOo96KB6D/XyqkinvUmxhqSQ+w+e46HgDR9umqqNi+Naa1qrmErW3btn7Yoh122CFc7IdsUhglqcVDKieffLIfDiopOJT0cFns4JDe/tGwXtb0ZsyFF15os9FnWNJXC+NBmHhQxkI60Q5WTOQbHNpnn33ckCFDwl346XgloAorpFmgylDaX/xtpPgDv22uENPll19us/4NLN1LubRC3nMaB14hNB2nAju5tkzBoXyqZNkQb+qk0fBmH330Ua6HEFUcUjWt8NjTBdTS7bhQwaGkId3UYbPRRhu5fffdN/p5ddApIMVbXxEJEwgggAACCCCAAAIIIIAAAgiUrYB1pBain9IQFdC59dZb3e23326L/KeGkT/mmGNckyZNUpZnmsk1OJRpH+F3YcgnXR9SuL6mFS6yatjqw2rdunXKKgrr6OU0Nb2A2bNnTz+tzulcz1VmeoHz7bff9tvKSn2t2Zq6rMP+XAV42rRpk22z6Pthw4b5at9aEO9HDF9ES+rbjXby+4TCT+rvVdtuu+18haffv+IDAQQQQAABBBBAAAEEEKh2AXveLYvgkIa7uuSSS1KQrfJPysJgZtKkSU5DF4Xt7rvvduuvv37Kg7C+Vxnbo446KlzVT2vope7du6csP//8850euEslOKRgTFjlJ92wXarYpHCQtWzBoaRhnl5//XU3cOBA24X/zFRxKCl8pI3iFYdUYjh8+E/5gWCmY8eOTmGk+LoKE2l5vMWHRMun4lCh7zkNrRcfXk/XQG84derUyYea9JbS559/Hp1GpuDQ9ttvn/KGk200c+ZMd9xxx9ms/9T90apVK98REw7xpi9VOUhBLA3/p2kNBRc2qzgUHwJNJa5V6jrXVqjgkH5vxIgRvtKV/bbuMx3/yJEjbZEP9+XS8RRtwAQCCCCAAAIIIIAAAggggAACCNRZAetILVRwSC8sqo/MAjCCU//KgAEDnF5czLcVOjgUDu2V68tfvXv3ThlmLddzuOaaa9zmm2/u/u///s9voj4o9dOka0899VTUh6N+1/Clv3TbaLmqKFlVp6FDh7p0L4Em7SMeiqpMxSHb7wcffOCOP/54P6sX1xTSoiGAAAIIIIAAAggggAACNSVgz7tlERz68MMP3bHHHptirbDJ/fff7ysIpXyxYkYhBT08qmyvtTDooKDJiy++aF/54chGjRoVzdtE+CBoy6x6S6kEh8K3XOwYVRlm9dVXt1n/qRDKo48+Gi2LB4fiYYykYcbuu+8+p86AsFUmOBQ/5qTfCn8jPq1gjAIy1lSqOD48l74bPHiwe+WVV2y1vCoOFfqeiw+Pp2M+++yzo7LKSSG1TMEhdUwo3FSvXr3o/DSh4cNUHjtsMliwYIHr27dvuNiPJb/HHntEy+JVqfSFBYf0t6bwUNjiZaFV0SgM72hdlbjeYIMN/N9kr169ws3d+PHj3aabbhot69evny9bbQt0T/bp08dmo8+pU6c6haysyUKdYKpCZk1v/G288cY2yycCCCCAAAIIIIAAAggggAACCJSxgHWkFiI4pKrSqmCjl/TU1MemfikFbyrbcg0OKZyjqj0rrbSS69q1a9qfU5+NhkpTU3+Q+qCytaoEh/Qy2sEHH+x/ItuLe2+88YY7/fTT/brpXoxLOtbwRUT1806ePDmnStOqohQO1VbVikNhvxTBoaQrxTIEEEAAAQQQQAABBBCoTgF73i2L4JBghw8fnhIM0DKFBRRU0EOaNQ1lpBCQAi1hUyUVextEoQKFFsJ22223OVW0saZOAL29EgaM9J0FZUolOKRQiAIyYdNDtwxsmKakSkHx4FC8ooxMVammYcOGftd6k0qVmcLAjr4wD03Hqx+lqzgUdl5oO7V7773Xrbfeev+dWfH/8tUQVMuXL4+WKXyjTpH4sFlaIV6iOCn0la3jIvqh3ycKdc8pwBbvPNJQaDoea3pjSm9OhS1TcEjraZi6Aw44INpEZirxrM4maxaYe+2119ygQYNssf+MB39UkWvMmDEp61hwKOwUsRXkEwaPwjLYto5dl8pUHIrv3/apDjL9bhgMtO/0qc4qBaiS2nfffed0LmFTBavVVlstXMQ0AggggAACCCCAAAIIIIAAAgjUIQHrSC1EcGjatGm+spB41L+mPsWwT6sybLkGh8IX09T3oT6QpBaGbNQfpD66bE1D26vPJV179dVX3U033eS/1lBs9oKYzl1Bph49ekSbPv/8826VVVaJ5sMJ9QFee+21fpH6auPVr8N1w2kdn4YVs6b+wXh/m31nn+rfVUXqsDJUVYNDV1xxhe+H1G9069bNXXXVVfZzfCKAAAIIIIAAAggggAAC1S5gz7tlExzSEE5JD7l6QNeDavv27d0XX3zhQwHhcE+6MlpHwyqpVK7aokWLKpSz1TpnnHGGL6X7/fff+yCLHnLDpvG7NQ63WqkEh1SpRg/NNga5Ha8qMnXp0sWHK8KqO/a9znfKlCk2632uu+66aF4TKrGsyjgKW6i6zZtvvpnyvWYqExyS/0EHHZQS/FDARR0FKm2saj/qRFBHTNgmTpzoOnTo4MI3k+x7na/KQWv89Y8//tgHYOLBknyDQ4W655YtWxaN+27Hq6HxFMTS9VOlHw3FF7+GWmbjxWuM9aSOCP1NqJNCgTkNhaZOlLCpbLbe+Jo+fbo75ZRTwq/8/mxbdf7obbl403Vv0aKF37+Gg4ub6o06VfbRNdGbXrq21sJh8yoTHFLVsP79+/u/38aNG9tu/adCZQ8++GDKMpsJQ4K2zD6TqipRnch0+EQAAQQQQAABBBBAAAEEEECgbgpYR2ohgkPhC4nqn9ALfFVtuQaHwtCK+oTUlxmvRv3ee++lhHFURTocPk19OL/99ps/ZPUdrrzyyjkdvvpJre/ovPPOc3vvvXfKduFQYieeeGKF6vFa+csvv/T9mNa/pPPRC125Nr2Id8cdd0SrZwpFqTL2DTfc4F+MjDZYMVHZ4JBCSLfffrtTNXpruYSXbF0+EUAAAQQQQAABBBBAAIFiCNjzbtkEh4SoBzO9xZNvu/766311onC7O++80z88hssyTStoo/BGs2bN/GqlEhzSwSRV8Ml0LvouHhyaO3eur1aTbbv495UJDmkfCi2df/758d2lndcbRHoYt6ZqOwq75NPyDQ5p34W65xTuiod6VNVJgRrrLImfSzhUV7rgUHybcF77V7imUaNGiWE5ravAVjywFO7DKgZpWb7HoLfHttlmG7+7XIJDSRWetPFmm22W0imjZTNmzPDBK03Hmyonrb/++vHFfp7gUCILCxFAAAEEEEAAAQQQQAABBBCo0wLWkVqI4JBeXLOX3fTSUzy4kwSpoditjyTp+1yDQ2G1I+1n11139UOR6YXKb7/91mkoM4WZrKkytSruWNMLbN27d7dZd99997lcTbIFh+IVzzVEmvrztH+9pKljV5DH+sHUTzd27FjXoEGD6HiyTejFOb3YGVbb1ktxW265pdtggw38C4Xz5893c+bMcer7td8K95spOKSXKONVqVUNXS8Xzp49O2V/qoSvlzCt4nv4G0wjgAACCCCAAAIIIIAAAtUlYM+7ZRUcEq4qoKgSS65tyJAhTpVS4k1VYFTB5bHHHot/VWFeIRuV+A0f8EspOKS3hBTquPrqqyscuy1Q5Robe13L4sEhLVPFGv0vXVMFGT0kh62ywSHtIyybHO4zPq0OAIVomjZtGn2lPwBV04lXl4pWWDGx9dZbp1RJqkxwSPsrxD33wgsv+KHvwuMLp3U9LOBjy/fdd99oPPp8QzvaxzXXXOO23XZb252/P9IN4aWVkkJEYXhJfzP6e8olsBX/u8slOJQuTJYUHNJbXvq7Disc6RzCKkeajzeCQ3ER5hFAAAEEEEAAAQQQQAABBBCo+wLWkZprSCadiIbyUrgk33baaae5Qw89NO1muQaHtIO77rrLB27S7uz3LxRsueyyy1L604oZHNLP6iXBsMJ5umNUP5gqB6Ubai3ddlquvsmLL77YzZw5M9Nq0XdyUMVsVeRWyxQcijbKMqHwkqpka4g2GgIIIIAAAggggAACCCBQkwL2vFt2wSGhf/rppz48pKoj6Zoe4hUsadOmTbpV/PJnn33WXX755SlvjIQbKHihMrw2zJl9pzdcdtllF5v1nw8//LDTkFlhGzdunJs0aVK0aMcdd3SjRo2K5vU20J577hnNa+LJJ590a6yxRrQsXlEoXTji/fffdyo/rJLEVkWmY8eOTsNiKXQjD2uqRvPEE0/YbPSp4JCq1MQDGSo3fMghh/g3maKVV0zIr0mTJn5RfPgorX/66aeHq1eY1ttICjzZ8cZXUGUhvaGU9PaOhlBTFaKpU6fGN3PaTmOsh+fcuXNnp+tRmVaIe07hH/1+/G0ndWAMHjzYd6yMHz8+5fDsza94cEj3kYIz6gCKXytdc7no/MP2448/OlXfShriS2/Iyeqss87y1Xxsu/h9osCOhv3TfpKa1h85cmSFCl9JHWvxIcJ0fHobTPsPjZKCQ/rt+N+WlmkoQXXepGsffPCBO/7441O+tiHwUhYygwACCCCAAAIIIIAAAggggAACdUbAOlKrGhxSaOXoo4/O2yXTkFra2cKFC6MXHzfZZJOML/ZpfYVzNGxXuhfqVGXo8MMPr9CfFg8O6QWzXMM7eiFRQ5SpDR061KkvKd70cqOqV4dVj+LraIg1DTO/+uqrx7/KeV7noX7YpH4224n6aNU3qcCQqhrpuun66UXGMPxly227pE/1d+m6qKqRXizt2rVr0mosQwABBBBAAAEEEEAAAQSqXcCed8syOGTaChoocKIhoATSsmVLXzVFlVPiQR/bJulTYQiVsf3kk0/8/1SSViV+NdxRWOUmadtSXaYyugrbWOBGD9NhYEnhkkzDvmnMcXkowKROFb0JVKwmf3V0fPzxx/5TD/bt2rXzv9uwYcOsP6vOFb1ltHjxYn/d9BBfrDd+qnrPKeykY9WbZK1bt/bDcFnwKtOJJgWHdD11PArDfP311/5e3WijjfzfQaZ9yVolm3Uscta9kItzuE9z0D2ie0V/K/ptBfVyKdEd7is+rX3rfPSpjh39Dcoq3lR+W2/shS0pvBd+zzQCCCCAAAIIIIAAAggggAACCJSfgHWkVjU4VEpyCs/MmjXL94mqb2zttdf2/aJt27YtWr9YruevSu3qs9WLeAsWLHAK3she/1P/baGaDNSnqz5F/U/9W+oTloWCPtYvWqjfYz8IIIAAAggggAACCCCAQKkJ2PNuWQeHSu2i1MTxqLrQ5MmTU35aFVdUpcWahonSm0aqSGRN45mr0hKtdgikCw7VjqMvzlGOHTvWl+e2vW+33XZu9OjRNssnAggggAACCCCAAAIIIIAAAggg4AWsI7UuBYe4tAgggAACCCCAAAIIIIAAAgjY8y7BoTK/F7744gu3//77pyioxLCCQnqDR5VtHnnkETdt2rSUddKVFE5ZiZmSESA49N9LoZLSGqJw7ty5vvR1eIEuueQS17Nnz3AR0wgggAACCCCAAAIIIIAAAggggICvyiMGgkPcDAgggAACCCCAAAIIIIAAAnVJgOBQXbqaVTyXAQMGVAgGZdqlgkWTJk1yjRs3zrQa35WQAMGh/16Mu+66y6nSULxpeLsHHngg7yHX4vthHgEEEEAAAQQQQAABBBBAAAEE6p6AdaQSHKp715YzQgABBBBAAAEEEEAAAQTKWcCed6k4VM53we/nvmTJEjdw4MCUocjSsWiIsuHDh7umTZumW4XlJShAcOi/FyVdcGjEiBGuT58+JXjlOCQEEEAAAQQQQAABBBBAAAEEEKhpAetIJThU01eC30cAAQQQQAABBBBAAAEEECikgD3vEhwqpGot3tfy5cvd1KlT3aOPPuoDRIsWLfJns+qqq7oNN9zQtW/f3nXq1Mntsccern79+rX4TMvz0KdMmeLGjx8fnfy2227rBg0aFM2Xy8Tdd9/txowZ40/X7u0jjjjCKRBHQwABBBBAAAEEEEAAAQQQQAABBJIErCOV4FCSDssQQAABBBBAAAEEEEAAAQRqq4A97xIcqq1XsMjH/csvv7ilS5e61VZbrci/xO4RqF4B3dtqDRo0qN4f5tcQQAABBBBAAAEEEEAAAQQQQKBWClhHKsGhWnn5OGgEEEAAAQQQQAABBBBAAIE0Ava8S3AoDRCLEUAAAQQQQAABBBBAAAEEEEAAAQQQQAAB60glOMS9gAACCCCAAAIIIIAAAgggUJcE7HmX4FBduqqcCwIIIIAAAggggAACCCCAAAIIIIAAAggUVMA6UgkOFZSVnSGAAAIIIIAAAggggAACCNSwgD3vEhyq4QvBzyOAAAIIIIAAAggggAACCCCAAAIIIIBA6QpYRyrBodK9RhwZAggggAACCCCAAAIIIIBA/gL2vEtwKH87tkAAAQQQQAABBBBAAAEEEEAAAQQQQACBMhGwjlSCQ2VywTlNBBBAAAEEEEAAAQQQQKBMBOx5l+BQmVxwThMBBBBAAAEEEEAAAQQQQAABBBBAAAEE8hewjlSCQ/nbsQUCCCCAAAIIIIAAAggggEDpCtjzLsGh0r1GHBkCCCCAAAIIIIAAAggggAACCCCAAAII1LCAdaQSHKrhC8HPI4AAAggggAACCCCAAAIIFFTAnncJDhWUlZ0hgAACCCCAAAIIIIAAAggggAACCCCAQF0SsI5UgkN16apyLggggAACCCCAAAIIIIAAAva8S3CIewEBBBBAAAEEEEAAAQQQQAABBBBAAAEEEEgjYB2pBIfSALEYAQQQQAABBBBAAAEEEECgVgrY8y7BoVp5+ThoBBBAAAEEEEAAAQQQQAABBBBAAAEEEKgOAetIJThUHdr8BgIIIIAAAggggAACCCCAQHUJ2PMuwaHqEud3EEAAAQQQQAABBBBAAAEEEEAAAQQQQKDWCVhHKsGhWnfpOGAEEEAAAQQQQAABBBBAAIEMAva8S3AoAxJfIYAAAggggAACCCCAAAIIIIAAAggggEB5C1hHKsGh8r4POHsEEEAAAQQQQAABBBBAoK4J2PMuwaG6dmU5HwQQQAABBBBAAAEEEEAAAQQQQAABBBAomIB1pBIcKhgpO0IAAQQQQAABBBBAAAEEECgBAXveJThUAheDQ0AAAQQQQAABBBBAAAEEEEAAAQQQQACB0hSwjlSCQ6V5fTgqBBBAAAEEEEAAAQQQQACBygnY8y7Bocr5sRUCCCCAAAIIIIAAAggggAACCCCAAAIIlIGAdaQSHCqDi80pIoAAAggggAACCCCAAAJlJGDPuwSHyuiic6oIIIAAAggggAACCCCAAAIIIIAAAgggkJ+AdaQSHMrPjbURQAABBBBAAAEEEEAAAQRKW8CedwkOlfZ14ugQQAABBBBAAAEEEEAAAQQQQAABBBBAoAYFrCOV4FANXgR+GgEEEEAAAQQQQAABBBBAoOAC9rxLcKjgtOwQAQQQQAABBBBAAAEEEEAAAQQQQAABBOqKgHWkEhyqK1eU80AAAQQQQAABBBBAAAEEEJCAPe8SHOJ+QAABBBBAAAEEEEAAAQQQQAABBBBAAAEE0ghYRyrBoTRALEYAAQQQQAABBBBAAAEEEKiVAva8S3CoVl4+DhoBBBBAAAEEEEAAAQQQQAABBBBAAAEEqkPAOlIJDlWHNr+BAAIIIIAAAggggAACCCBQXQL2vFvywaHqAuF3EEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBAoJwGCQ+V0tTlXBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQR+Fyj54FAhD5CrjgACCCCAAAIIIIAAAggggAACCCCAAAII5CMwd+5cvzr9lPmosS4CCCCAAAIIIIAAAggggECpCxTjebfebytaoU68GAdYqGNjPwgggAACCCCAAAIIIIAAAggggAACCCBQHgL0U5bHdeYsEUAAAQQQQAABBBBAAIFyEyjG8y7BoXK7izhfBBBAAAEEEEAAAQQQQAABBBBAAAEE6rhAMTpS6zgZp4cAAggggAACCCCAAAIIIFALBIrxvEtwqBZceA4RAQQQQAABBBBAAAEEEEAAAQQQQAABBHIXKEZHau6/zpoIIIAAAggggAACCCCAAAIIFEegGM+7BIeKc63YKwIIIIAAAggggAACCCCAAAIIIIAAAgjUkEAxOlJr6FT4WQQQQAABBBBAAAEEEEAAAQQigWI87xIciniZQAABBBBAAAEEEEAAAQQQQAABBBBAAIG6IFCMjtS64MI5IIAAAggggAACCCCAAAII1G6BYjzvEhyq3fcER48AAggggAACCCCAAAIIIIAAAggggAACMYFidKTGfoJZBBBAAAEEEEAAAQQQQAABBKpdoBjPuwSHqv0y8oMIIIAAAggggAACCCCAAAIIIIAAAgggUEyBYnSkFvN42TcCCCCAAAIIIIAAAggggAACuQgU43mX4FAu8qyDAAIIIIAAAggggAACCCCAAAIIIIAAArVGoBgdqbXm5DlQBBBAAAEEEEAAAQQQQACBOitQjOddgkN19nbhxBBAAAEEEEAAAQQQQAABBBBAAAEEEChPgWJ0pJanJGeNAAIIIIAAAggggAACCCBQSgLFeN4lOFRKV5hjQQABBBBAAAEEEEAAAQQQQAABBBBAAIEqCxSjI7XKB8UOEEAAAQQQQAABBBBAAAEEEKiiQDGedwkOVfGisDkCCCCAAAIIIIAAAggggAACCCCAAAIIlJZAMTpSS+sMORoEEEAAAQQQQAABBBBAAIFyFCjG8y7BoXK8kzhnBBBAAAEEEEAAAQQQQAABBBBAAAEE6rBAMTpS6zAXp4YAAggggAACCCCAAAIIIFBLBIrxvEtwqJZcfA4TAQQQQAABBBBAAAEEEEAAAQQQQAABBHITKEZHam6/zFoIIIAAAggggAACCCCAAAIIFE+gGM+7BIeKd73YMwIIIIAAAggggAACCCCAAAIIIIAAAgjUgEAxOlJr4DT4SQQQQAABBBBAAAEEEEAAAQRSBIrxvEtwKIWYGQQQQAABBBBAAAEEEEAAAQQQQAABBBCo7QLF6Eit7SYcPwIIIIAAAggggAACCCCAQO0XKMbzLsGh2n9fcAYIIIAAAggggAACCCCAAAIIIIAAAgggEAgUoyM12D2TCCCAAAIIIIAAAggggAACCNSIQDGedwkO1cil5EcRQAABBBBAAAEEEEAAAQQQQAABBBBAoFgCxehILdaxsl8EEEAAAQQQQAABBBBAAAEEchUoxvMuwaFc9VkPAQQQQAABBBBAAAEEEEAAAQQQQAABBGqFQDE6UmvFiXOQCCCAAAIIIIAAAggggAACdVqgGM+7BIfq9C3DySGAAAIIIIAAAggggAACCCCAAAIIIFB+AsXoSC0/Rc4YAQQQQAABBBBAAAEEEECg1ASK8bxLcKjUrjLHgwACCCCAAAIIIIAAAggggAACCCCAAAJVEihGR2qVDoiNEUAAAQQQQAABBBBAAAEEECiAQDGedwkOFeDCsAsEEEAAAQQQQAABBBBAAAEEEEAAAQQQKB2BYnSkls7ZcSQIIIAAAggggAACCCCAAALlKlCM512CQ+V6N3HeCCCAAAIIIIAAAggggAACCCCAAAII1FGBYnSk1lEqTgsBBBBAAAEEEEAAAQQQQKAWCRTjeZfgUC26AThUBBBAAAEEEEAAAQQQQAABBBBAAAEEEMguUIyO1Oy/yhoIIIAAAggggAACCCCAAAIIFFegGM+7BIeKe83YOwIIIIAAAggggAACCCCAAAIIIIAAAghUs0AxOlKr+RT4OQQQQAABBBBAAAEEEEAAAQQqCBTjebdWBYcWLFjgpk+f7mbPnu0+/PBD9/nnn7vmzZu7li1bui5durjtt9/erbvuuhXgSnXBTz/95J577jn32WefuYULFzrN77TTTq5Xr15u1qxZ7rHHHosOXed18MEHR/NMJAvI7a233oq+bN26tevZs2c0n23ioYcecj/88EO21VzDhg3dGmus4e+3jh07ugYNGmTdhhWqT+C3337z/1boftC/FTNnzvQ/vuaaa/prpn8rttpqK7fyyitX30HVol+67777/L9Ldsj6d2nrrbe2WT4RQAABBBBAAAEEEEAAAQQQKHmBYnSkFuuk33vvPTdnzpyMu2/UqJFr166dW3/99Z2maQgggAACCCCAAAIIIIAAAuUpUIzn3VoRHFII4NFHH3UjR47MeuX33HNPN3DgQNeiRYus69bkCvPmzXP9+vVzX331VcphHHvssW7AgAHu+eefd4MHD46+23LLLd0tt9wSzTORLHDXXXe50aNHR1927tzZTZgwIZrPNtGjRw+3dOnSbKulfK97bdSoUT68lvJFGc3oH6fvv/8+OmN1Yq2++urRfHVOfPHFF+7iiy92r776asaf1XU799xz3c4775xxvXL88s9//rObMWNGdOr6N/XII4+M5vU3EnZorrLKKm6jjTaKvmcCAQQQQAABBBBAAAEEEEAAgZoWKEZHqs5JLzLec889/iUlveTYvn17/3LSFlts4TbbbDNXv379vE/96quvdpMnT855O70QNWLECP9CZc4bsSICCCCAAAIIIIAAAggggECdECjG827JB4eWLFnizjvvvKwhgPAKKxAwceJEt84664SLS2p62LBh7umnn65wTASHKpDktaAmgkN2gEOHDnV9+/a12bL6PO6449w777wTnbOCO7vttls0X10TU6ZM8WGgfH7vhBNOcP37989nkzq/brbg0Ouvv+5OPvnkyEGVnJ588slongkEEEAAAQQQQAABBBBAAAEEalqgGB2pjzzySMYXGw8//HA3aNCgvE893+CQfkDP4tdff7374x//mPfvsQECCCCAAAIIIIAAAggggEDtFSjG827JB4euuOIKd++99+Z91dq2beu3UyWMUmxdu3atcFgKPCk4pE4GKg5V4MlpQU0Gh3SAqoxVyoG1nBArsVIpBIf0xt+f/vSnShy9c+eff36lt63UD5b4RgSHSvwCcXgIIIAAAggggAACCCCAAAJZBQrdkfryyy+7M844I+V3Naz3p59+mlJRXBXG//KXv6Ssl20mDA7pRZ2ePXumbLJs2TL37bff+hcr1fdlbZtttnHjxo2zWT4RQAABBBBAAAEEEEAAAQTKQKDQz7siK+ngkMb3Pvrooytc2t13393pf3qj5uuvv3b//Oc/3U033VRhvdNOOy1x+worVvOCxYsXu1122SXlVy+44AK3zz77RMu0zuzZs6N5DfvEUEARR9qJQgeH+vTpU6FyznfffeevjSpGffPNNynHcswxx7hTTz01ZVk5zJRCcOjMM890L774Ygr3iIc7ogAAEJ9JREFUqquu6k4//XTXqVMnpxDhxx9/7If8++CDDyqs99RTT7kmTZqkLC/XmX/9619O97m1du3apQTiqDhkMnwigAACCCCAAAIIIIAAAgiUqkAhO1J/+eUXt//++7t58+b50+3du7cfKqxRo0Z+ftq0ae7EE0+MKK677jqn4cRybWFw6K9//avbc8890276zDPP+OrstsKzzz7LkGWGwScCCCCAAAIIIIAAAgggUAYChXzeNa6SDQ7pgVwhjPh/4NdbN8cff7wdf/T59ttvV1iu0MALL7zgGjRoEK1nE6pOomDOnDlz3EcffeQUzNlwww19GKlDhw4+ZGDr2udvv/3mdBF+/fVXv0j7VXhJ86+99prf348//uhatWrlNthgA9e5c2fb1H9qPf3HeHUy6NzCdtttt7n11lvP/64CDtqPxkm3po4IlSBOajoXOek8Gjdu7M9DbzzpeD/88MNok5VWWiklfKTt9LaSNR13/Df0RlMYYKpXr57beOONnT7VvvzyS7dw4ULbhVt33XW9pfYtEwW7FJKSR9gWLVrkZs2a5f+n8I0qRGm/ugYrr7xyuGqFad0bn3zyiT9nWWrbLl26+GBDoYNDAwYM8FWgKhzEigU6hgMOOCDlq+22286NHTs2ZZlmdO3tfvv3v//t/XS++l/c3Db+z3/+4+bPn2+zrlmzZn5declWxtpW11oGYdN27777rvvss8/c2muv7YMz8XXC9TX9008/+ftF97j+LnRvKDCia6f/6drGm45x+fLlTk7h3+o555zjFLrStdTfYdgqYxFunzT90ksvVSgFrvO94YYbKtj8/PPPTsenbcI2ePBgd/DBB4eL/LQMdc30qfu9efPm3l1/323atKmwfvxvRn+T7du3d7pvX331VffxivBS/fr1va2uvyqNZWry1TZ6g1HHIfPWrVv731blsmxhJ/07oGPXvw+6B7W/tdZay/+9bLnllon/Ptrv2HHpHtJ5a1v9voJDGkLSms7hvvvu87NNmzb1f9f6XWstW7ZMtNK/D1999ZWt5uL/RkVfMIEAAggggAACCCCAAAIIIIBAngKF7EgNwzrqC7zjjjsq9B1OnjzZKQCkpuCPAkC5tnyCQ+pfUP+TtUmTJrlNNtnEZvlEAAEEEEAAAQQQQAABBBCo4wKFfN41qpINDiUFgfQf6idMmGDHXuHz3HPPdVOmTElZrv+YHY71rYfrm2++OeN+FDi47LLLKjx06z+Yx0sFa2gqhSb0H9rjTf9Rfvjw4e4Pf/iD/yr+9lF8fc2r6pCqD8WHKtM+HnzwwZRNFPQYOXKkU+WbeNt00039cSloZU0BjjAsoaCEfseaQhNaFjaFew477LBwkd9GQSu1Sy65JOW4dOxLly51GmLO2pVXXhm5KTTywAMPuFGjRtnXFT4VqlJZ56Rh5hSm0nWeMWNGhe0U4tG101td1rLdM7aeffbo0cMfv81nCg5pnfiQTknXSaENuSQds/ah+1P3yeabb67ZqD322GP+7TVboLfZevXq5YYOHWqLok/tY/z48T6oo8o7qsIVb+mCMVpP11lhmqT72Paj6l8nnXSSD3fYsn333Td6286WhZ86J4XirFXWwrZP93nKKadUOGeFhrbddtvETZLuawWdLr300mh9hfw0rzf30jWFtoYNG+ZDf7ZOfN+6J7Qf+dubibauPlUZ7cgjj/RhonC5pvWPvq639pmuaXg27Tvp70XBnBEjRvjAUtL2Cp6pfLquY9ji9/XAgQP9MYYdpeH64bT+/vQ3qn8HrHXr1s2NGTPGZqNPDRH35JNPRvPxvx/9+x2eu0KdBx10ULQ+EwgggAACCCCAAAIIIIAAAgikEyhkR6qerdVPo5auf0X9CDvvvHN0OK+88kris3q0QjCRT3BIL+rstNNO0XP3I488UuGlqWDXTCKAAAIIIIAAAggggAACCNQxgUI+7xpNyQaH4qEJHXAYQLETCD9VUSP8j9D6Tv9RXZV81PQAr1DF9OnT/Xy2/9N/1Nb21pKCQ/oP3ZnCFhpe7Pbbb/eBjjfffDPrGOe5Boe+//57HzhIF0axYw4/qyM4tOOOOzp1jITNrptCWxoLfurUqeHXidMq5zx69OiUaij6A+jfv3+F4cESd/D7wmIHhxSm0ZB61uz62Xx8SCdbnvSp4fYURLEW/xvQ9QvDGLaefcreqtrYsvinAh0HHnhgymIN0aXgUi5NQSB1Zqn6jFo+waGqWGQ7tl133TXlvlCQ6t57740qYyVtr1BKWNVLVXVUdlxNVXAU5okPRZe0H1XbUTjKKjrFg0PaRutk2pc6/K666qqU3auqlIJruTTdNwrmhNW6VHFKQa9M94ztW9WD7Ny1rCrBoeuvv95Xevvb3/5mu/efGkYurI6kEKGCmOHxxSvKKVQV/nuhYJ+9vZmyc2YQQAABBBBAAAEEEEAAAQQQiAkUsiM17HfQi33qD0xq6kuwisy33nqr22KLLZJWq7Asn+DQO++84zRkvJr6itJVW6/wIyxAAAEEEEAAAQQQQAABBBCoEwKFfN41kJINDmm4p7BSiQ5Yw/xoKJvKtmuuucbdeeedeW2uikLrrLOO3yYpOJTLzmxscoV89B/kMzX9x3v9R/xsFYdkkzQkVqZ9V0dwKOn3LTj08MMPu4suuihplcRlVuXEvjz11FPTVk6xdeKfxQwOvfHGGz6YEf6m3kDba6+9/CJVhOrbt2/KUEzhuvFpXR9VdLHKMfHgUHz9ysyrwoz2a8P3KTizxx575LUrVXxRdSI13a+ZgnPmX1WLTAeoEJ2CN2FTwOyEE04IF+U1ffnll7v7778/523CwEtScCiXHalKlypKqSlUo4BXJtv4Pm+55RanKme2vUJt1lkZXzdpXkGf9ddf33+VLjikim4Kn2VqqvSk+0uVjMKmYFR4nd5//3131FFHhav46mVh5yvBoRQeZhBAAAEEEEAAAQQQQAABBPIQKFRHqoZyVxVotXjfWvxwVMFclbbVFAbSCzC5tGzBIQ0driHM9Syt37CXcNJVP8rlN1kHAQQQQAABBBBAAAEEEECgdgoU6nk3PPuSDQ6dffbZ/o0ZO1hV7FCoorJNQwTFh+NRhRAFWTQO+JIlS5wqkOg/voctHJM8XXBIQ2upMlHTpk39f/hW5ZiwHXvssSmVQxYuXOh22223cBV/bjpHa5mCQ+oc2H333aNOAttGYQlVHlm0aJFT1Y946CDeuaHOhUIPVWbHok9VW1IVF4UQVPVp7733TjlmhUoUtGnVqpUfQu3GG29MOWZdH4WN6tWr55KGrpOXwkVt2rTx2z/00EMp+9cxWHBF07m0+FBlqrATVgHSPuSrP0a94RU2+eqtM52Pmt4sU4gibKpipWunIbtUSvquu+4Kv/ZDv+ktNrWk4NDGG2/sK03pXlPQQ/uIN+3/8MMP99WHNJRcONST1lUgpn379n4zDaEVrwyjwM0hhxziNBydqilpKK74EFvqBGvXrp1TeWz9T9c49FBYTseha6f/VdUifo7h/MyZM90RRxwRLvJDw6n6U2Vb+Cah9qF9KSylUJeqEakSkP2DrO/DSjjpgkMqV66/+0aNGvnhBeNDDCrUpaBiw4YN3SeffOI09F7YFNhRUEveOmcFg8I2aNAgf921LKmKlI5RQR0Lj2lou7CFnY3pgkNaX6EmVY8KqyFpn48//rjfXf369f29p0BaWGVJIbpwmL2JEyf6f6fsGHRvx4OdBIdMh08EEEAAAQQQQAABBBBAAIF8Bey5XVWJq9IU2NEzrVp8iO34fseNG+cmTJjgF6s/Zb/99ouvkjgfBoe0QthHqPnw+VrzapmGPv/vGvw/AggggAACCCCAAAIIIIBAXRQo1PNuaFOywaHDDjssJfCgAEe8AlF4ItmmNYyPhgwL2xNPPOFDJ+GyUaNG+QBRuOzvf/+7a9mypUsKDvXp08cpfBG2+LGrioiqiViranBIASpVJQrbkCFDUoIGCkIpeBB2LFRXcGibbbbxw8qFwxLFg1A69smTJ7sOHTpEp6EhidTpETaFCzp16uRGjhxZISSjoJANQ6dtXn75ZT8UWrh9VYND4b4yTSs4obBM165do9Xi1Xji94FWjA91piHarrvuOr+PpOBQWAEraagnha0U6rHKXEmBK/0d6e9JQ/cpzBK2gw8+2ClAErYvv/wyqqJkyw899FB31lln2awvkR0Ghy6++OKUcFxVLaIfSph46aWXnEIzYVNw7n/+53/CRTlPWzDPNlBY6I477nBrrbWWLXJhR6AWqhNSwUO1pOBQt27d3LXXXusUqlHTtdPfsCr4hM2q/qialYZVtKaOyUmTJqUMvaay5KG5wmLmoGo/GhrRmu6Lu+++278Zacvi4aBwuLT4d/HqX/Fh53T/x4eJ1H0sN2vq9FRYygz69euXMmykzlf/doZNYcLwHPX3fOKJJ4arMI0AAggggAACCCCAAAIIIIBAokChOlL1UpW9vJOtn0kvxKjiuVpYnTjxAIOF8eBQ8FXaSfXh6Pm/WbNmadfhCwQQQAABBBBAAAEEEEAAgbonUKjn3VCmZINDevi1E9YBb7rppin/ETo8iVym9R++X3nllWjVsJJQtHDFRFKlj5tvvtlttdVWicEhVXSxCjG2H1XRUejDWhgG0bKqBof05pKCC9bigSBbrqCUAlPW4usVo+KQfiMcbst+O+lYFKQI2y+//OJUNSlsCheoEyQeMlA1IwUh4i0+nFm2Dp349vGKQ/Hv081rDHv9tg0BpnPZbrvtUlZX5akddtghZZmCQOG9oi8VhJFjPDikZS+++GJKeCQe8FBVpwsvvDD6jaRwkKogbbvttu7dd991qpYVNlVMCoeKsu9UKSkMhqgKU1hZKx5iCYNDhbCw40j6lEkYstE6VQkOxX9DIR9VXJo/f76viKUwVmih9bMFh1RZqmPHjim7TgrTpTvuZcuW+ZLkOgb9u6hhGxUuClsYHIpXTDrppJMqDJOojk+VOLfWvHnzKEgWv68qExxKGopMQSL9W550X8pUASQaAggggAACCCCAAAIIIIAAAoUQsH7FqlYc0os5Nhz3jjvuGAWDko5RL8kpBKRW2eCQ+lw23HDDlN1rqDJVFp8zZ06FlwT1ElLr1q1T1mcGAQQQQAABBBBAAAEEEECg7goU6nk3FCrZ4FA81BIPvYQnkcu0gkIaYsha/D+E23KFBBSqCJuVFk6qOJQUCIhX2ih0cCgeTIqHOOzY4xV84oZx46RqM0nVUxR40DBWagpOKWxiLRyyyZbpM6liUPh9umk7pngQQm96xasTaR9jx45NqUxVXcEh/XYY3Pj888/98HVanm+zqkLx4FBSOez4NdQwY2H46scff3Tq1AqbBYcU1FAgKGyqJGMVYcLlqnYTBr3i91Km4FAhLMJjiU8n3aPDhw+vMDRhfLts89qvroGq5ISVu5K2yxYcUjWsxo0bp2yqfcZDh/HKYQo76jrlMkyj3X8//PCD6969e8pvJQUcU1aIzRQiOKQh1VSSPRzmTvem7tF//OMfKRWr0v0bFjssZhFAAAEEEEAAAQQQQAABBBDIWaBQHalhv0O251e9ZHXLLbf4Y1SlYVVgzqWFFYdU0Vr9mOna9OnT/XDq1lfRu3dvd9lll6VbneUIIIAAAggggAACCCCAAAJ1TKBQz7shy/8DAAD//+gFJdgAAEAASURBVO3dB7QURdrG8UIEE2IARHQNLGYXRcG0ChhWjIA5IZhQXIIBFQMqKKjAroKCAuoawCyomDO46iLGFUyoa2LNmFBMoHw+9fn21vTtmTvDTF/m3vnXOTA93dXp1z2cU8Vbb9Vb9FtxJSrvvPOOP9If//jHoo94+eWXu2uvvTbjOE8++aRbbrnlMtaFX3788Uf30UcfhavcH/7wB9egQQO31VZbZaw/99xzXZcuXTLW2ZdOnTq5L7/80r66fv36uSOOOMJ99913bscdd4zWa+Huu+92a6yxRsa6yy67zE2YMCFa9+c//9lpnZUvvvjC7bbbbvbVfz788MNu1VVXjdY9/vjjbsCAAdH3tdde291xxx3++wknnOD+9a9/Rdt23313N3To0Oi7LcyaNcsdddRR9tUtv/zy7p///Gf0XcfXeawcdNBBGefU+rfeessdeuihVsV/ap/GjRv75QsvvDC6Lq3o2rWrO+ecc/y28C8ZTp8+PVyV1/Kee+7pj7fddttl1B82bJj7y1/+krFOX2Ska7Ky+eabu3/84x/2tdrPDh06uO+//z6qd+SRR7rDDjss+q6fy1dffeVefPFFN2LEiGi9LTzxxBNuhRVWcDNnznRHH320rS7oc/LkyW6dddZx99xzjzvvvPOifcN3wFbGn+Gxxx7revXqZZudfhM77LBD9F0LY8eO9b+HiRMnuksvvTTapvdP72FS0Xt+/vnnZ2x69tln3VJLLeXX6T3T+2blggsuiN7xUljYcZM+9bz03MLSs2dPd/zxx4erqix//PHH7ocffojW67k1b97cf3/jjTfc4YcfHm2rbkH/5t12222+Wvw3k8s1/r6deOKJrnv37v44d911V+LvOtu16D3t37+/e//9993++++fUe3KK690W265Zca6XF+OOeYY9/LLL0dVTjrppAwPPfvevXtH21dbbTV3//33R99t4eqrr3bjxo2zr26jjTZyN9xwg9Pvd9KkSdF6/ZuhfzsoCCCAAAIIIIAAAggggAACCJRKoFT9lHPnznXqe1NZf/313c0335z1EocPH+5uv/12v139RjvvvHPWuuGGSy65xN10001+lfpf1B+Wq8T7/GbMmOHq16+faxe2IYAAAggggAACCCCAAAII1BGBUrV3Q4565Ro4lBSocPbZZ7t99tknvP6M5euuu86NGTMmY53+c3rdddd1++23n/vggw+ibX379nUKComXX375xW2zzTYZq63BXi6BQ/FgnWydFvHgo+oChw488EB3+umnZ9z7M88842QVllyBQ0nBR9p3yJAhbsqUKdFhFGjQvn376Hu2hY033tgHFMQDv7IFGlx//fVu9OjR0eGKDRzK9p7oBAqIUGBEWBQwtskmm/gAtnhgmjp9cgW+2XH69OnjA7PSDhx69NFH3RlnnGGn9Z/ZOpoUxKdgPivxYJhcgUMK5ivWws6b7TMe7Kf3S++bggaTioKN1OkXBolZAN7nn3/uA2/CbTpG69atnYIA9U6q0zAM1ssVOKR9wyArfbfSrl07W/Sf+m3rXuKBOVZJgUbaZ9NNN3X33nuvu/POO22TD3BT4JCCHnWMsKjjcpdddglX5VwuVeBQUhCTAowUlBUGZz722GNupZVWynlNbEQAAQQQQAABBBBAAAEEEECgEIFSdaQuXLjQbbvttv7U6lubNm1aNJAqfj1nnnmme+SRR/zqQgbxFBo4FO+/VP/AWmutFb8cviOAAAIIIIAAAggggAACCNRBgVK1d0Oasg0cmj17tuvWrVt4rU7BAMrC0bBhw4z1+vLTTz+5XXfdNSMQIMzQctppp7mpU6dG++k/4NUoj5fXXnvN9ejRI2O1giYUNFAugUMKTgkzGOliw2Aeu3hlfQkDC+KBQ8q6FGYJSTLRKKqLL77YDuk/w3PFg5iyBQ7FrznpXBkniX1RoIGywFjZd9993cCBA+1r9KnAiTCrUpqBQ0899ZRTJpawKHBNnUnxDhzVUYYfBZ3kW9IKHFLAk4JPkn5j2a4x7qoMUGGAVq7AoVJYVGcW/32rfq5AQ2UHimeMspGADz30UMa7pd+NslYpQM9KPFtTdYFD+ndL2c/CkuRv/9bEf1fK1HPFFVdEmb50nHjmMcs4pKxY8UC7pAA4ZefSO2ylVatWTkFrKqUKHNKx4r9dXaeNotT2Qv8t0D4UBBBAAAEEEEAAAQQQQAABBKoTKGVHqgaDffbZZ/6U6lNIyrau/o+ddtop6pu0rNTVXae2Fxo4NG/evIxsRkn9DvmclzoIIIAAAggggAACCCCAAAK1T6CU7V27+7INHNIFhqN07ILbtm3rLrroooxpvTTdkNaFQTCqrymbNHWTylVXXeXGjx/vl+0vTZmj/5C38uuvv/qMO2GAkbZZoEy5BA4pMEaBHGHRdFTqZLCpo5IyBcUDh/7+97+7W265JTqMssjIcOmll/brNM2VpnwKA3a0wTy0HA9wyBY4pM6SU045RbtERYELCu6yIl9NYaSRXFaUKWrrrbd28SAnbVfGldVXX92quqSgrzQDh5LOp2egQAgVWdiPVt8POOCAKhl+5B0GOmm6LJvqLa3AIf0O9DtKmuJLHVzKTmPvka47adouZesKM1HFA4c0xdpee+2l3X0p1sKOk+0zPj2Y1bNsYfZdn8rmc+qpp0YdebZNz0G/kfg0icpAFmZbUn0FjIVBN9UFDmlaPb3bVvRvzVlnneWU9SksDz74oGvatKkPXtT7ZUUBPTK2on/zNN1hmBXJAodUJx6so9+ZgnWWXXZZfwidXxmWwqw/mt5M/+aqFBo4FM9A5Q/y+19JwYfhdsuyFK6z5eeffz7qmNU6/d4LmXLNjsMnAggggAACCCCAAAIIIIBA5QlYn0xSkE+hGmFfgdrMf/3rX6scIswerIzF8UF/VXYIVhQaOKSp5tWvYCVbBmnbzicCCCCAAAIIIIAAAggggEDdEShle9dUyjpw6MMPP/TTVNnF2qf+c1/T7qjh//HHH7unn37aqW5YVGfy5MmuWbNmfnXS9D2qo0wlmlpq/vz5/j/W4/+Rr6xHJ598sj9GuQQOaQSTphULp17TBSojk/5TXcEEYTCKv/jf/tL9husVSKCOibAocETZfL7++munwJXnnnsu3OyXFydwSP6aZi4MdFAww/HHH+8U3KPsKzfeeKN74YUXMs6ndRtuuGHi1E26XwVw6FM/jlGjRmUcXwdKM3AoKWOMsjN17NjR34MCdBSwFha9Twr40LOQo7LIhEX+f/vb3/yqtAOHdJKxY8f6bDrhNSjIRUEoCmJS0JACicLnproPPPBA9NvS93jgUOfOnX1gke5T07MVa6FzVFcUPKjffLwoSKpNmzY+U5nuJx4YqPrHHXec/6NlTT+nrExhUZrxVVZZxX3xxRdOAW/xIMQwu1m2ICa9F3r2jRo1cpqKMf5vjbZbdi8FPYa/BWU803XVr1/fvfvuu/656f0JyyGHHOIDorQu229bdZSdTSMR4/uPHDkymj6w0MAhnVO/1ebNm/spx+rVq6dVvmhEpkZmZisWsJW0PZ5ViexESUqsQwABBBBAAAEEEEAAAQQQSBIoZUdqvK2vgXjrrbdedFoN8FEb9qWXXvLrFNSjwXD5lkICh9SOVpZl66sJBwLlez7qIYAAAggggAACCCCAAAII1F6BUrZ3TaGsA4d0kfoPfP2HeaHFsqqE+11//fUZ0yuF25KWFfSg4I2VVlrJby6XwCFdTFIGn6R7CNfFA4f+85//uIMPPjisktfy4gQO6cDx0VDVnaxTp04+o5HViwcR2Ppcn2kGDr3//vtOnTNh0fRwCg5R+fnnn33mF/vhhvWyLSs7i02JlVbg0JVXXhllbfn22299ZiDrbMp2XeH6MMjG1idlB9M2Bbxo+q1iLew8uT7nzp3rO+UKuRcdTxmFNApQQTkq06ZNiwJw/Irf/1JwUDxYz7YreM0ynsU7E61OdZ/hsw87DG0//X6VMSjMEmTb9KkOSRttqGxhXbp0yVo33E/L+p3o31kL+KkucCjXvx0KhlOWsLBoJGZSEKKyHg0dOjSsmrEc/80TOJTBwxcEEEAAAQQQQAABBBBAAIEcAtYfU4qMQzqNsgErs4/Kmmuu6bp37+6ngv/oo4/8oKyXX3452qbpzJZZZhn/PZ+/wn4A9aW0bNmyym6ffvqpU59D2C+gDMAayGMDJ6vsxAoEEEAAAQQQQAABBBBAAIE6J1Dq9q6Ayj5wSBep7ByacijfoqmeunbtWqW6gheUPWXKlClVtsVX6D/pNZVX+B/g5RQ4tGjRInf77be7ESNGxC89+r7zzjtnZBWJBw6pooJI9CdbURCLOiXCsriBQzrGkCFD8vJXSmcF4ay44orRqefMmeOz2MSzS0UVflvYaqutMgIU0gwcSnofFIQyZsyYKABDWYk0XV4+wSx6lnpmVmoicEjnevHFF/0UamHHk11D/FOZYxScYlNe2fZsQWEWOKR6xVjYear7VHabQYMGZbwDufbR+6EMT+pos6J/J44++ugqU/TZdn0mBRHpebVo0cL/Xg499NCwus+KpWvLVnr37u3Padv/+9//+gxd9j3pM34N6gjV9IsNGzb01TWVmjJyVVf0jPRvXZMmTaKq1QUOqaL+jU36Ler933bbbaNjaSHbv+FhlqOMHX7/QuBQkgrrEEAAAQQQQAABBBBAAAEE8hEodUeqspVrYEw4tXjSdSj79BZbbJG0Keu6MHAoa6XYBvVBqZ8t7NOIVeErAggggAACCCCAAAIIIIBAHRQodXtXRLUicEgXqkwfagxbyl+tixdN83TKKae41VdfPb4p4/tDDz3kg1KyBXOo4T148OAqo3VUXxkvwqIsI8o2Ehb9x/l1110XrYpnyfjqq6/crrvuGm3XgqYtWnnllaN18YxCCuBRRpJ4UWeF0iO/8sorUTaUjTbayB155JF+SqS+fftGu6gjQQEe8aLAoUmTJmWMWFIdZZZRAIRcw6Jr0zRWKsOGDfP72nZNcdW/f3/7mvj5zDPP+ICnbNlbBgwY4A444AC31FJLVdl/3rx57txzz3UKiogX7adgivCe1VETny4svl/4XVmOwgAaBS706NEjrJKxnBQ8oVFl4Wg2XbOyuWj6qKSi4BW922ussUbGZr1bulcrOqaOHZZ4ph9NcaVAJSualmr77be3r/4zzDhkG3TPCs5LcrU6CsjRFGRJRRlulNFLo9zC31UYOKT9Ftci6ZzZ1v3666/+t6KsY+G1hPUVRHf66ae7PfbYI/E902hBPZN4lhz9hvSOH3TQQVX+LZCNjJIyDun3pTTimiotLLoO/YYUKBcvzz//vL+GeHCO3nH9xjQFnJ53WOLPSMF2ekfi57V9FAg2cODAKqMg41Ol6Xy677D8+9//9lOmhVOqaXtS4JCeexgUp3q6d/27Z4FOWhcvOm84vWI4lV+8Lt8RQAABBBBAAAEEEEAAAQQQCAXS6Ej95ptvnPqf4m1hnVft9fPOO89nXw6vI5/lUaNG+cFAueqqHb3hhhu6DTbYwG266aZOWXyT+s5yHYNtCCCAAAIIIIAAAggggAACtV8gjfZurQkcssenAAVNEaWpcpSVo2nTpm6dddbxjfNC0vIquEDBAe+9957/07hxY58GeN11183IcmPnrQ2fCxcu9B0G1mlwxx13ZEz1pYAiZSTJVj755BNvscoqq7i11lrL/8d+trrFrpe/AiLeffdd/9m8eXPvr/MuvfTS1R7+iy++cK+//rpTh43SNyuwqkGDBtXutyQrKHhC767uecGCBf66FQwUBowtyevTuZVFSb8J/WMjW/225KugJpvKK9c16vf5+eefux9++ME/x0aNGlUJrNP+NWGhrFy6Ft3L22+/7adL0+9bHXn6kytgxe5RWZL0zH755Ren34/2t+m8rE78MylwSEFAuh69s/p3R++qnr1Sm9vvNX4cfVf2I+2j34pSnG+22WZVAhqT9gvXmYOeq949nVudjOutt16VzFHhfvkua4o4vSv6TesaFUgZz0ilY8WzGB144IE+eCvf81APAQQQQAABBBBAAAEEEEAAgUIE0uhItfOr/2TmzJk+u7L6ddR/0qZNm5xtfNuXTwQQQAABBBBAAAEEEEAAAQSKEUijvVvrAoeKAawr+7766qtu4sSJGbfTrVu3jBFNyjSjzDNh+uSOHTu6iy++OGM/viCAQGkFsgUOlfYstetoCuBSdqewXHPNNT4QKlzHMgIIIIAAAggggAACCCCAAAKlEkijI7VU18ZxEEAAAQQQQAABBBBAAAEEEFhcgTTauwQOLe7TWIL7ffzxx1WmjFLmkn79+rkmTZq4zz77zCnbUDxtcnwaoyV4C5wagTorQODQ/x7tXXfd5bMR3XfffT7zk21RtqVbb7212uxNVp9PBBBAAAEEEEAAAQQQQAABBAoVSKMjtdBroD4CCCCAAAIIIIAAAggggAACpRZIo71L4FCpn1INHa9Xr15VAoNynVqBRTfffHOq04/lOj/bEKgUAQKH/vek27Vr978vwdK5557runTpEqxhEQEEEEAAAQQQQAABBBBAAIHSCqTRkVraK+RoCCCAAAIIIIAAAggggAACCBQukEZ7l8Chwp9DWewxb94817dv34ypyLJdmKYoGzx4sFtxxRWzVWE9AgiUSIDAof9BJgUOrb322j7bUIMGDf5XkSUEEEAAAQQQQAABBBBAAAEESiyQRkdqiS+RwyGAAAIIIIAAAggggAACCCBQsEAa7V0Chwp+DOWzw8KFC91TTz3lNB3Qa6+95r788kt/ccsvv7xbf/31XatWrVzr1q3dXnvt5ZZaaqnyuXCuBIE6LDBnzhx34oknRne4zDLL+Gxf0YoKWggDhxQwtM0227jjjjvOrbLKKhWkwK0igAACCCCAAAIIIIAAAggsCYE0OlKXxH1wTgQQQAABBBBAAAEEEEAAAQRCgTTauwQOhcK1fPmXX35x8+fPd40bN67ld8LlI4BAXRBYtGiR079L9evXd/Xq1asLt8Q9IIAAAggggAACCCCAAAII1BKBNDpSa8mtc5kIIIAAAggggAACCCCAAAJ1WCCN9i6BQ3X4heHWEEAAAQQQQAABBBBAAAEEEEAAAQQQqESBNDpSK9GRe0YAAQQQQAABBBBAAAEEECgvgTTauwQOldcz5moQQAABBBBAAAEEEEAAAQQQQAABBBBAoEiBNDpSi7wkdkcAAQQQQAABBBBAAAEEEECgaIE02rsEDhX9WDgAAggggAACCCCAAAIIIIAAAggggAACCJSTQBodqeV0f1wLAggggAACCCCAAAIIIIBAZQqk0d4lcKgy3yXuGgEEEEAAAQQQQAABBBBAAAEEEEAAgTorkEZHap3F4sYQQAABBBBAAAEEEEAAAQRqjUAa7V0Ch2rN4+dCEUAAAQQQQAABBBBAAAEEEEAAAQQQQCAfgTQ6UvM5L3UQQAABBBBAAAEEEEAAAQQQSFMgjfYugUNpPjGOjQACCCCAAAIIIIAAAggggAACCCCAAAI1LpBGR2qN3wQnRAABBBBAAAEEEEAAAQQQQCAmkEZ7l8ChGDJfEUAAAQQQQAABBBBAAAEEEEAAAQQQQKB2C6TRkVq7Rbh6BBBAAAEEEEAAAQQQQACBuiCQRnuXwKG68GZwDwgggAACCCCAAAIIIIAAAggggAACCCAQCaTRkRodnAUEEEAAAQQQQAABBBBAAAEElpBAGu1dAoeW0MPktAgggAACCCCAAAIIIIAAAggggAACCCCQjkAaHanpXClHRQABBBBAAAEEEEAAAQQQQCB/gTTauwQO5e9PTQQQQAABBBBAAAEEEEAAAQQQQAABBBCoBQJpdKTWgtvmEhFAAAEEEEAAAQQQQAABBOq4QBrtXQKH6vhLw+0hgAACCCCAAAIIIIAAAggggAACCCBQaQJpdKRWmiH3iwACCCCAAAIIIIAAAgggUH4CabR3CRwqv+fMFSGAAAIIIIAAAggggAACCCCAAAIIIIBAEQJpdKQWcTnsigACCCCAAAIIIIAAAggggEBJBNJo7xI4VJJHw0EQQAABBBBAAAEEEEAAAQQQQAABBBBAoFwE0uhILZd74zoQQAABBBBAAAEEEEAAAQQqVyCN9i6BQ5X7PnHnCCCAAAIIIIAAAggggAACCCCAAAII1EmBNDpS6yQUN4UAAggggAACCCCAAAIIIFCrBNJo7xI4VKteAS4WAQQQQAABBBBAAAEEEEAAAQQQQAABBKoTSKMjtbpzsh0BBBBAAAEEEEAAAQQQQACBtAXSaO8SOJT2U+P4CCCAAAIIIIAAAggggAACCCCAAAIIIFCjAml0pNboDXAyBBBAAAEEEEAAAQQQQAABBBIE0mjvEjiUAM0qBBBAAAEEEEAAAQQQQAABBBBAAAEEEKi9Aml0pNZeDa4cAQQQQAABBBBAAAEEEECgrgik0d4lcKiuvB3cBwIIIIAAAggggAACCCCAAAIIIIAAAgh4gTQ6UqFFAAEEEEAAAQQQQAABBBBAYEkLpNHeJXBoST9Vzo8AAggggAACCCCAAAIIIIAAAggggAACJRVIoyO1pBfIwRBAAAEEEEAAAQQQQAABBBBYDIE02rupBA4txr2xCwIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCFQj8Mc//rGaGvlvJnAofytqIoAAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCwRAXKPnDoD3/4wxIF4uQIIIAAAggggAACCCCAAAIIIIAAAgggULkC//3vf/3N009Zue8Ad44AAggggAACCCCAAAII1EUBa+8SOFQXny73hAACCCCAAAIIIIAAAggggAACCCCAAAIlEbCOVAKHSsLJQRBAAAEEEEAAAQQQQAABBMpEwNq7BA6VyQPhMhBAAAEEEEAAAQQQQAABBBBAAAEEEECg/ASsI5XAofJ7NlwRAggggAACCCCAAAIIIIDA4gtYe5fAocU3ZE8EEEAAAQQQQAABBBBAAAEEEEAAAQQQqOMC1pFK4FAdf9DcHgIIIIAAAggggAACCCBQYQLW3iVwqMIePLeLAAIIIIAAAggggAACCCCAAAIIIIAAAvkLWEcqgUP5m1ETAQQQQAABBBBAAAEEEECg/AWsvUvgUPk/K64QAQQQQAABBBBAAAEEEEAAAQQQQAABBJaQgHWkEji0hB4Ap0UAAQQQQAABBBBAAAEEEEhFwNq7BA6lwstBEUAAAQQQQAABBBBAAAEEEEAAAQQQQKAuCFhHKoFDdeFpcg8IIIAAAggggAACCCCAAAImYO1dAodMhE8EEEAAAQQQQAABBBBAAAEEEEAAAQQQQCAmYB2pBA7FYPiKAAIIIIAAAggggAACCCBQqwWsvUvgUK1+jFw8AggggAACCCCAAAIIIIAAAggggAACCKQpYB2pBA6lqcyxEUAAAQQQQAABBBBAAAEEalrA2rsEDtW0POdDAAEEEEAAAQQQQAABBBBAAAEEEEAAgVojYB2pBA7VmkfGhSKAAAIIIIAAAggggAACCOQhYO1dAofywKIKAggggAACCCCAAAIIIIAAAggggAACCFSmgHWkEjhUmc+fu0YAAQQQQAABBBBAAAEE6qqAtXcJHKqrT5j7QgABBBBAAAEEEEAAAQQQQAABBBBAAIGiBawjlcChoik5AAIIIIAAAggggAACCCCAQBkJWHuXwKEyeihcCgIIIIAAAggggAACCCCAAAIIIIAAAgiUl4B1pBI4VF7PhatBAAEEEEAAAQQQQAABBBAoTsDauwQOFefI3ggggAACCCCAAAIIIIAAAggggAACCCBQhwWsI5XAoTr8kLk1BBBAAAEEEEAAAQQQQKACBay9S+BQBT58bhkBBBBAAAEEEEAAAQQQQAABBBBAAAEE8hOwjlQCh/LzohYCCCCAAAIIIIAAAggggEDtELD2LoFDteN5cZUIIIAAAggggAACCCCAAAIIIIAAAgggsAQErCOVwKElgM8pEUAAAQQQQAABBBBAAAEEUhOw9i6BQ6kRc2AEEEAAAQQQQAABBBBAAAEEEEAAAQQQqO0C1pFK4FBtf5JcPwIIIIAAAggggAACCCCAQChg7V0Ch0IVlhFAAAEEEEAAAQQQQAABBBBAAAEEEEAAgUDAOlIJHApQWEQAAQQQQAABBBBAAAEEEKj1AtbeJXCo1j9KbgABBBBAAAEEEEAAAQQQQAABBBBAAAEE0hKwjlQCh9IS5rgIIIAAAggggAACCCCAAAJLQsDauwQOLQl9zokAAggggAACCCCAAAIIIIAAAggggAACtULAOlIJHKoVj4uLRAABBBBAAAEEEEAAAQQQyFPA2rsEDuUJRjUEEEAAAQQQQAABBBBAAAEEEEAAAQQQqDwB60glcKjynj13jAACCCCAAAIIIIAAAgjUZQFr7xI4VJefMveGAAIIIIAAAggggAACCCCAAAIIIIAAAkUJWEcqgUNFMbIzAggggAACCCCAAAIIIIBAmQlYe5fAoTJ7MFwOAggggAACCCCAAAIIIIAAAggggAACCJSPgHWkEjhUPs+EK0EAAQQQQAABBBBAAAEEEChewNq7BA4Vb8kREEAAAQQQQAABBBBAAAEEEEAAAQQQQKCOClhHKoFDdfQBc1sIIIAAAggggAACCCCAQIUKWHuXwKEyfQF+/PFHt+yyy5bp1XFZCCCAAAIIIIAAAggggAACCCCAAAIIVIaAdaQSOFQZz5u7RAABBBBAAAEEEEAAAQQqRcDauxUROPTrr7+6yZMnu19++SXn823YsKFr0qSJa9WqlVtzzTVdvXr1stZ/8skn3eeff551e7YNq6yyittpp50yNi9atMg98cQT7vHHH3dz5szxf77//nu3/PLLu5YtW7oNNtjA7b///m5xH9bcuXPdo48+mnHOjh07uhYtWmSssy96OZ566in76j87derkVl111Yx15fzl7bffdjNnzowusWnTpq5Dhw7RdxYQQAABBBBAAAEEEEAAAQQQQAABBBDIR8A6UgkcykcrnToLFixwDz/8cMbB1de34oorZqzL9mX69Onuyy+/jDZvuummbt11142+qy/0m2++ib4nLTRu3Njvs8Yaa7j69esnVSl43fz5893QoUOd7m/QoEF530/BJ6qQHW677Tb37LPPus6dOzv1f1MQQAABBBBAAAEEEEAgt4C1dxc3FiXp6PV+C4BZlLRhcda98847frdSNMjV8Cq0obDhhhu64447zm233XaJl//Xv/7Vvfzyy4nbcq1cb7313IQJE6IqCnD5+9//nhHkEm2MLSh456STTnIrr7xybEvury+++KLr27dvRiWd889//nPGOvsybdo0d9ZZZ9lX/3nVVVc5NahrS7n55pvd6NGjo8vdbLPN3Lhx46LvLCCAAAIIIIAAAggggAACCCCAAAIIIJCPgHWklqKfUuf74Ycf3LXXXpvPqX2fZlKfnAZI3nfffe65555z6kf99NNP3VprreUDW3bccceC+0LtYkpxbXYs+zz33HP9QMm9997bD4609YV8fvXVV26vvfbK2OWMM85wXbp0yViX9EWZ3XfeeeeMTSeccII75JBDonXdunVz7777bvS9ugXVP/7444sOIFL/pfoxt9lmGzdy5Mgqp/3oo4/cpEmT3Jtvvuk0OHSdddZxbdq0cerr3Hjjjd1SSy1VZZ98V+gd0kBWDWj94IMPXIMGDfxxdWydQwNgsxWZ/utf/3JvvPGG79fWYNjVV1/dv4Pt2rVzu+22mz9etv1/+ukn995777mFCxf6Abz59HdfdNFF3kGfOldSeemll1yfPn38gNw77rjDKdiLggACCCCAAAIIIIAAAtkFrL1L4FB2I7/l6KOPdj179qxSqxSBQ2rwHn744U6f+ZbNN9/cXXbZZTkbXvFjETjkfKOXwKH4m8F3BBBAAAEEEEAAAQQQQAABBBBAAIHqBKwjtVSBQwoCOfLII6s7rd8+YMAAt88++2TU1fWcc845bvbs2Rnrwy9t27Z1F1xwQcGBE8VeW3gNWta1HnTQQX61+kF79+4dr5LX96TAoS233NKNGTOm2v0VGHPmmWdm1Cs2cEgH0/mHDx/uVlhhhYxj5/vlP//5j+vevbuvPnbsWKd+37Dcc889TkEy2YoCn3Qfi1PmzZvnTjzxxKzvkDLhX3PNNW7ttdeucngFDSloS5l9spXVVlvNjRgxwmfSD+soWOmmm25yut+w7LDDDu7000/3swGE623Z+rc1EFYDYnMVDaBV/a5du/pj5qrLNgQQQAABBBBAAAEEKl3A2rsEDuXxJpx66qluv/32y6hZisAhHVcjM5KKUt5qRElSOeCAA1z//v2TNiWus4ZVuJGMQ6EGywgggAACCCCAAAIIIIAAAggggAACCCQLWEdqqQKHkrJ9J5/ZuXjgkDKrK0t6GDSkICFlbFHmoTBrTvv27d2wYcNcvXr1sh2+yvpiri1+MGWTUTCIpglTKXXgkI559913u6ZNm2oxa1HGo0cffTRje67AoYsvvrhKRhtlYvrss8/cAw884J588snoWL169XJHHHFE9D3fBSXuVxCVMtonBUA9/fTT7rTTTss4nOrpXdR1WMk26NW2J33quahv+9VXX402qy9aWXzUj2xFGYeuvvpq16JFC1vllClIfdovvPBCtE5BQi1btnQzZsyI1mlBx7zuuutco0aNovUKhFJAVFLR+W655ZYq07X9+uuv7phjjvHv/MSJE12rVq2Sdo/WWdYhrRg/frxr3bp1tI0FBBBAAAEEEEAAAQQQyBSw9m7FBg4p+EZpU1XUUNMc12pYK5AnHrCjERb333+/a9iwYaQYDxzS6AsbIRJVSlhYaaWVnEZQfPvttz5la1hFKXOV5naDDTbwaW41x7XSDcenDdM+aqDmO5c2gUNkHArfM5YRQAABBBBAAAEEEEAAAQQQQAABBPIXsI7UUgUO3Xjjje7yyy/3F6BAiWWWWSbrxagvcdlll422K1BGwUAqCthQxp3wuhQgo0AZK1dccYWfdsq+V/dZzLXp2OpXlZemsFJ/qqbAspJG4FDSgE87nz4V8LPLLruEq/xyrsChyZMnZwTLhDurH1lTimn6MBUFzMis0KJgqlNOOcXvdskll7htt902OoSy8hx88MFRH7X6jJVhyt6TMDBGO8X3jw6UZeHBBx90559/frQ1zHakbELnnXeen75MFTQd2j/+8Y+o7kMPPeS3a4X6zC+99FJnU+n9/PPP7vnnn/fv3/fff+/3CQPftM0yJOmZKDOQgop0PQrWUtHgXT3TsNg73blz5yqZo8J64fJRRx3lA4023HDDvKcFDPdnGQEEEEAAAQQQQACBShGw9m7FBg6pAbTrrrtWed4K1hk0aFCVTEBqcO++++5R/XjgkIKBlH4135IUzKO0uZpLOl6S0ulqtIYCjPIpSecqVcahTz75xM2aNSsa7aJ5o5s3b+7WX3/9vEZzfPjhh05pefVHI6bU2NZ9aU726uboViNanQ9KoazjrLnmmv6cGs2iucE1R7gVzc3NVGWmwScCCCCAAAIIIIAAAggggAACCCCAQL4C1pEaBujku29SPU1vNWXKFKcMK/fdd19SlazrNP2Y7aPMQ0lTnimQxAJb+vTp4wcqZj1gbEMx16ZDaSqpbKVUgUMawGkBSdX1+U2dOtUNHDjQX1K43+IGDulACopSph8r2TLK2/b4p4KPevbs6V5//XUf/HXHHXdk9INaoIz2U1+pAnfC4DGtV8DZZZddpkXfZx0Gi/mVOf7SgFobOKt+8N122y2jtga8aho0TQ+nonPZlGUnn3xylFkoW/9yGJi07777RpmTFMR2ww03+Hu6/vrr3dJLLx2dV/eoP/HfhIKRNNWdsizddddd3ivaKceCfiP6ragouE7ZmigIIIAAAggggAACCCBQVcDauwQOVbVx3333nevUqVPGlvXWW89NmDAhWlds4FA4OkMH1QgNrUvKIqSRHuoIUKCMFTX6czXErZ4+0wgc0mgdNfBCk/CcWlbDVil127RpE9/kNOpEI6vuvPPOKtu0Qh4adaNgraR0ynPnznVnn322mzlzZpX91SBV8JCN3FKFpE4EjR566623ov0VsBSfki7ayAICCCCAAAIIIIAAAggggAACCCCAQEUKWEdqqQKHlGlF/XXbbLONz15TCKqmbFLAiUq2gYVhViJlSFc/Zr6lmGvTOXL1V5YqcEj9fMpUYwE76l/UQMakov7Dxx9/3G9SsI6m3lIpJnBIU8LpXlTigS5+ZTV/aRCmpjhT0bOJZ7EPg8P69+/vFOgTL/Fs9rrHeHBRfB9917usQByVXP3RFuSjeuF0bPvss080VdrDDz+cMQ2Z6qpokKcFtIXvuDIJ6ZkpKMkyD/3/Hs738R5//PH+a3jc2267zY0aNcopg9Cxxx5r1av9DDNNdezY0WmKNAoCCCCAAAIIIIAAAghUFbD2LoFDVW38msGDBzs1UsISNsCKDRxSA18N/bDsuOOOTg0kG8ERbitmOY3AoaS5wbNd4zXXXOM22mijaLNGiCgQKpyPO9oYWwgbprZJU8qpE8NGvdj6XJ9JgUMKTLI51rVvoVmjcp2PbQgggAACCCCAAAIIIIAAAggggAACdUPAOlJLFTi01157+X6tpACK6sQ0ZdVjjz3mq2m6qb/85S9Vdgn7Nc844wzXpUuXKnWyrSjm2nTMzz//PGPwozKpazorlVIFDmlqLAXTKKO8ykknnRQFw/gVv/+lgYvms/nmm7u99947ykJTTOCQsuYosEalffv2TlmaCikKXlJ/qYqy7Gg6sLDYM9C6W2+91WdmD7fbsk3Hpe/jx4/PK/v7Aw884IYMGeIPoQGb2TIVKcDHpgwLg3/Un61Brsr8ni37fpgxKcw4pAxFyq609dZb+2Aguw993nPPPT64R8FMjzzyiB9IquAo7a+ibEMKFiukhP33yjxlU70VcgzqIoAAAggggAACCCBQ1wWsvUvgUJYnrWw0NreyVdEIB+sgCBse2q75kuMjJWw/+9TIF2XCUVEDS/NTJxUFDqlBpkw9f/rTn1yzZs2SquW9rtSBQ9OmTXNnnXVWxvnVqFMDXJ0Db7/9dsa2tm3bZkwbFnZeZFTM8kWN6U022STaGqbEjVZWs0DgUDVAbEYAAQQQQAABBBBAAAEEEEAAAQQQSBSwjlTrF0yslOfKMJjFMs3Mnj3bvfLKKz6wQYPvFBijrDBJgRLhNFDqj1NGHfUjLrfccj5gR/2Xo0ePjq5G2YeaNm0afc+1UOy1JR07DCIpVeCQ+mE1TZdNsaXAGwXgxEt4bgXBaGqsYcOG+WqFBg4pg83777/vnnnmGXfllVdGp7r22mt9v3C0Io+FMOBHgVUNGjSI9vr666/dnnvu6b/r+eoeshULxNF2BS8piKm6IjdNPaYyYMAApwxCSUUDPm1bPBN/Un1bpynQZGtToV144YVOg2VVwgz8/fr185mHlGleU79pkKjev3Bg59ixY93EiRN9Vvr999/fH6OQv2z6M+2j+27Xrl0hu1MXAQQQQAABBBBAAIGKELD2LoFDWR63sgup4R0WTX21xRZb+FXxwKGwXrbleONYjfibb745W/VovYKNlFK1Q4cOfsqtpKm7osoJC6UOHAobpTpdfGRNOMe2XY5GQqkD4+WXX66SHlnTgynT0k8//eQbw1dddZVvKNq+2m4jXMJUvrZdKYHVIFWA1dNPP+3niFdDMywEDoUaLCOAAAIIIIAAAggggAACCCCAAAII5CtgHamlCBzSgLsePXpUe2r1d2ng3vbbb59Rd9GiRT5jjAKIwqJgGgV7hBm6lZFn1113DavlXC722pIOHgbvxPtGk+pnW6f7UiYeFd2rAnZOP/109+STT/p1kyZNigZs+hW//XXmmWc6BeaoKIBKWXTyCRxSwE6YnUZ9lvG+RtVR5p7tttvOHz/fv8L70CBMBceERe+aTSWmwaUW5BPWsWUFMGm6OpV8M0sNHTrU3X///X4fTYm20047+eX4X+FUX7kCmOSiLELz58/3U5SF2d01aFZG1pf966+/ut69e/tpyXS+1VZbzU+v9sEHH0SntwxLn376qc82pH5x9Z+HwVVR5WoWnnvuOXfiiSf6WsW8e9Wchs0IIIAAAggggAACCNRqAWvvEjiU5TGqkaOprMKigBmbp7sUgUO//PKL7wCwBm54rmzLalCq0VvIdGalDhxSkM/MmTOjS9S1qNGp0ScqalhqFIc6MqwcffTRvjE4cuRId/vtt9tqP5e2UuSGjT8bTWKV1Di97777fINd81ErdW1YwkxQWq/godNOOy2s4gOuxo0bl7FOAUqvvvpqtK5169ZVpo+LNrKAAAIIIIAAAggggAACCCCAAAIIIFCRAtaRWorAIfUDKuAlLMqYo341BUs8++yz4SYfIKNAmbCoT7Fnz55OmYqyFU3RNWjQIFe/fv1sVaqsL8W1xQ+aZuBQeGxlrDnssMOi03/33XeuU6dO/vuWW27pxowZ44OH8gkcig5SzYKyomsqLWUyyrcou476SVU6d+7s+3nDfV9//fWofzJpIGRYVwE1ll2qV69e7ogjjgg3Jy5rcKYCqFSqy8Jj/eCqq3cj6V1SZiFNGxcvLVu29EFNYZ+v6nzxxRc+O9JTTz2VsYuCiPS+2qBdBTWpPzhXcFPGARK+hEFYCvCKzy6QsAurEEAAAQQQQAABBBCoOAFr7xI4lOXRa6SEAoXCormnlS5YpRSBQzqORlr885//9MEw4YgMbctWNNJCo0mS0hUn7VPqwCGNVlJq2XhRA2+rrbbyU5apQW7TsoX14tOMaU5rpecNy3vvvVdlbnDNha5jx92zpcqNn6e6hnZ4fpYRQAABBBBAAAEEEEAAAQQQQAABBBAwAetILUXgUBjsoX6tSy65JGMqsXfffdcHUCj7j4oG7Gm6JgvAUKDGOeec4xRgYkWD7po3b+60b1jUH6bja3s+pdhrSzpHGNxTTNaXMFOPZRxSthsFSKnYOruGRx55xDvqu2XjUdahfAKHFHC00kor2aH8p871zjvvZLhrgwZ5Kkv9UkstlVE/2xcFhp100kl+c7du3VyfPn0yqob9uArcifdPh5WVnUd9pirHHXecO/LII/1yrr/CvlVN5aWgtWwln8Chzz//3B166KFVMjLpmHq/FQzUqlWrjFNosOlrr73mMxTJVf9BIUd7Ty3zla7t6quv9hmLtM/DDz/sZsyY4adB0/R7bdq0cV27do1+Gxkn+e3LN9984/bYYw+/OlsfcnwfviOAAAIIIIAAAgggUGkC1t4lcCjLk1ejWiluwxLOCR42slRHQTOWLjfcJ1xWA0iBMtmKMvW89NJL7t///rf/DLPhxPcJp++Kb4t/Dxucti3MnmTr7HPatGk+E5J916ey82h+dZWpU6e6gQMH+uVcf6m+goLCRqbmxlba5EKLGpmat1zGYcrlpAa2jq3sQhMmTIhOQ+BQRMECAggggAACCCCAAAIIIIAAAggggEABAtaRWorAIU3LpAAf9QO2b9/erbDCClWuJJ7FJRzMeOyxx0YZtBVUpOnM1O+logGKCpj529/+FgVyKKijX79+Vc6RtKLYa0s6ZpqBQzqfgqgee+wxf2pN62VZ2sNpzO6991636qqr5p1xaPLkya5FixZJt+MzrN95550ZAT3K4qO+2nyKBmNqUKZKUpYgC5rRdsuUpOWkoqAavRsqAwYMcOp3ra7ofVHfr8oVV1zhg2/8l9hfP/74o9NUYyoK6NFzzFX07qnP9plnnvFZsvQOq2jKvbvuuitrcE/SMW1AqLLSqz9d16IM/AoaihcFBCmTULNmzeKbnDJz6TemoutQBiMKAggggAACCCCAAAIIZApYe5fAoUyX6Fs8MEgbwpSs8e077LCDGzFiRLR/KRY04kJBRGpcxdO3qhGca47r8PyzZs3yDdFwnaYWs8ZfuF7LYQPWtmne8DAt8vXXX+/Gjx9vm3N+du/e3WcKUgNSTotT1KhV4FDHjh0zds92H1OmTMnIWkTgUAYbXxBAAAEEEEAAAQQQQAABBBBAAAEE8hSwjtRSBA7leUp3/vnnuwcffNBXV7/Y3nvv7QOGFDhk5fbbb3drrrmmfY0+FbzRv3//6PsTTzxRUOBGtGOWhaRry1LVB5yce+65fnOpMw7poOEAyOOPP9716NHDffvtt74fUds1iHPUqFFaLEngkD/Qb3/deOONPtOQvm+zzTZu5MiRtinnp4KSbMosZR466KCDMuprKi9NYaZSXZYcDQxV1nyVCy+80O24445+Oddf4WBZBZhtv/32idXnzp3runTp4rcV0g+tHT755BOnZ62+bZVcA1h9heCv5557zp144ok+4Gf48OF+i6ZUs37wtm3b+qz0b731VhQwJn/dV7169YIj/f9iOKDVpmirUokVCCCAAAIIIIAAAghUsIC1dwkcSngJ4qN6VEXZc5R1x0qxgUMapaEpuaysu+66UWpdWxd+ho06W6/RNMstt5x9zfqp0UKHHHJIxvbTTjvNz8GdsfL3L2qIqUEWFo2kUcrjsChzkBqnaqDrHLmKjRCJZxxSQE88XW3Scfbcc0+3ySabVGnMarSJNabD/W644QY/asbWEThkEnwigAACCCCAAAIIIIAAAggggAACCBQiYB2pNRk4FA7as2molDlHASIqu+yyixsyZEjW2zjggAP8lE6qoCnI1llnnax1C92QdG3ZjpF2xqEwM07Lli19QE84KFJZ0y1LfL5TleXKOGT3+cYbb7ijjz7afy0km80999zjLrroIr+fgsCUrT0sCxcudB06dPCrlOlH03NlmwYtzLaUK3tQePzrrrvOXXnllX6Vgsv0niQVTcum4B8Vy3z08ccfO5tCT/25a6yxRtKuft0FF1wQZfhRBqEDDzwwa13boEGnmm5N57jpppuc+svDILCDDz7YnXDCCVGAkPqrFfykkjTtWjiIVbMFaHAuBQEEEEAAAQQQQAABBDIFrL1L4FCmi1uwYIHT6JRwnnBVCRuZ+l5s4JBGoWhUkBU1BB944IGso3/Chq3to4Cdhg0b2tesn/PmzXO77757xnbN/63RQUklTOVr2x9//HG37LLL+pTH3333na32n40bN/YjSV5++WX3/PPPR43CsJIa0j179nSnnHKKmz59erRJI0jU6Mu3qDE9e/bsqLpGvmie8nhRet4wSxOBQ3EhviOAAAIIIIAAAggggAACCCCAAAII5CNgHanFBg5pejJlF1dp0qSJ22CDDbKePsyyoj489eUpAGj06NF+n+qmIFM2m2effdbXTQqqiJ+42GuLH8++px04pPNo6i8FC6lYJiDLLnP//fe7lVde2W8L+1cVgBIOtOzWrZufQk4V8wkc0vE1RZlKIYFD6s9VBikVnV/XES/hwEvdjwKi4kXTcCk7u2X10RR1SdPexfcLg6pyBZ9psKgyBalYv66m+lJAkMoxxxzj//gvCX+F06ipP3j//fdPqJW5yq5t3333dRr0qqL+ZvXDqyiIqlGjRn5Zfy1atMhn4tIUaeoftgxJVkF92J06dfJfN954Yx9cZNv4RAABBBBAAAEEEEAAgf8XsPYugUO/vxEKGNKUXhqpYPNihy+LGrkK7rFSbOCQgoTio4Kyjb5Qw10jQNRQslJIY0eNKI3qsLml7RhJKWzVyBw0aJBV8Z9hOlrNwa6GdFjCeda1Xg1WnU+NNisa2aPgq7DTQ9uUclejXBSUZEWBQRMnTrSv/lOdHU2bNs1I02wV4tmQwhE/VicpcOjFF190yppkRRmVtthiC/vKJwIIIIAAAggggAACCCCAAAIIIIAAAs46UosNHPr000+jDODKgKI+raTplRQUooF21penLDEKMgqDVcIpuJIeURh8kk9QSbHXlnQNWlcTgUMaPKhBhCrKoDNp0iS/vN1220XTgmlFKQOHlOlGz08lfh6/Mstfb775ps+qo80a6GnTuIXVx40b5yZMmOBXKQOPMk7Fi03ppfWFnD/M4KO+7ttuu82tuuqq8cP7gbUzZ87065WFX9n49V0DblWqe//CQZ1jxozxWYv8jln++umnn9x+++3n+5OVlUmBdSrhfU6dOtUts8wyGUewzFoK4tL+YdGUabZuhx12cCNGjAg3s4wAAggggAACCCCAAAK/CVh7t2IDhzQSRA10K2EWG1tnn0lpY4sNHJozZ05iph01YjS3dIsWLZxGRXz44YduypQpUUeBXVOhc4JrZJH+xItGlmy00UZ+hIYCbpRZKF50r927d/erFWDVsWPHjCqaK1pThlmDTtOWaSSKjXhRZUupHDb27CDaX/N5K2XyjBkznAKRwoAeNWI14qR+/foZjUXbX8+xb9++rlmzZn76N428Cs+tekmBQ/HsRzQgTZRPBBBAAAEEEEAAAQQQQAABBBBAAAETsI7UYgOHdDwLdNDy0KFD3c4776zFjHLLLbf4wXdaqQF9yjqjfrEwuEfbLr30UrfVVltpMaNY5hat1HRSFkij7wpGsvtRX1qYzaaYa9Oxk0pNBA79/PPPbs8996zSH6ipvPbYY4/oskoROKTprzRVm4JprFhGKPue6zPMFJRtYKim6urRo0d0GA2w1NRgVuKDTJU9vmvXrrbZ9ym/9tpr/rsCbTbffPNomxbOPvvsqA84KSt9GIilPnQF8mi6tDDoSMe5/PLLEwdhhgFuqhdmfdL3pKKpyRRgpIz1NgWc6n3xxReuc+fOfhcNLFUfshVltVf/rsrYsWOr3KcGjarPWCVbdie/kb8QQAABBBBAAAEEEKhgAWsfVmzgUL7PXqMnLr74Yt84D/cpNnBIx1Kj/ZJLLgkPm9eyOgyuvfZat9xyy+VVX5UUiHPYYYdVaUBXdwA1DjXCxYKCVD+cPzvcX3U1OiQetKM6YQM3HJET7p9tOd74jQf8ZNsvXE/gUKjBMgIIIIAAAggggAACCCCAAAIIIIBAvgLWkVqKwCENmNM0TlY0YNEGEX788cdO00HdfvvtttlPF6VBd1Y0zZWmu7LSu3dvv78ydX/55Zd+8J0yFFmJZxzXNmX/VlGwjYJIrBR7bXac8LMmAod0Pt3nvffeG57aW6y44orRunwDhzRoMtxPB1i4cKEPulJQT9j3ueWWW/ogLwXW5FvCbDzxLPd2jHCqOQV/qV+3bdu2Tu+InqFlA9I2BZaFmXg0HZ7eCxX11+qdCku4Xes1xZem9GrcuLEftGnT4Wmb3re9995bi77o3dH5rfTr188HD+n9U5CP7kfXY6W6Kc1U75tvvommMtMzCrP+a3v4ziu4Tf28GrhqvyNltNeA2QYNGqh6VNQfrYAiFU27Fv6OokosIIAAAggggAACCCBQ4QLW3iVwKMeLoEaTGmnhNFpWvRSBQzqWGi2aMzrfosbeFVdc4bPz5LuP1QtHWdi6XJ9qpI0cOdK1bt06o5pGlygDUZgVKKNC7ItlG7LV8+fP93NTq6FdXdF5lAI3TNusl1fPxdI1Jx1DDekXXngh2kTgUETBAgIIIIAAAggggAACCCCAAAIIIIBAAQLWkVqKwCFlnFHmbmV1qa4kZUlRv5qCMRQ4UV1RMMjgwYMzqinoI1vgULHXlnGi37/UVODQM8884/r37x9dQlJm8XwDh6KDVLNw6KGH+n7LeMBKNbu5W2+91WeLUj0F6agfM170nE844QT3+uuvxzdlfE/KtBMGBiUFDukAmr5u0KBBGceKf5HhsGHDfLYh26YM+Zo+LVe/rNXV9Gbqx67ORwY333yziw8eteN89dVXvi856Z1X//X48eMzMjLZfmGA1mOPPVZE4y/WAAAPF0lEQVTQIFw7Bp8IIIAAAggggAACCNR1AWvvVkTgkEaEdOjQodpnqoaGRmm0adPGp7FVuthsRaMpwsCU9u3bu+HDh2ernnO9pgjTiJ5cHQa6tqOOOsqPvkgKZMp5gmCjUhor7asaS7mKOhb69Onjp/9KqqcRJGqUxUfyhHWVGUlBQzvttFNG4I/qqCNCU7Cp8RiO0rH91agdMmRI1vmv582b55QGWKlv40UZidZaay0fXGTblJLXRpjYurDxqHUaTXTRRRfZZj4RQAABBBBAAAEEEEAAAQQQQAABBBCIpvYqReCQOH/88UefVUhTXiX1i6kfUP1e2TKkaFCfpnbS/klF+yvoRJli4plwwiws2q5sLmEp9trCY2l56tSpbuDAgX61pt/SAMHFKcpKY9OOJU3xtWDBAr/dPBUUs9tuu2WcSv2YykykoiAjZa+xomurbpCj+it1bk0bpini2rVrZ7sX9PnOO++4ww8/3O+jabk0PVdS0T3LToNB40X9rsoKr+CceJk1a5br1auXX50tcEgb5TFq1KjEd1BBa8patPTSS8cP7zRVmvqX77zzzirbtELvn57zPvvsk7h/uJMCkPQcdD833HBD1vp6L/Xuqi949uzZvr78ZbfyyiuHh/TLusZddtnFL2+33XZ+RoEqlViBAAIIIIAAAggggAACUXu3IgKHasvzVjphpZtVcI/+NGzY0LVo0SL6U0zAUNxAjehXX33VZw3SqA11IqghqbSyf/rTn/IegaFRJm+++aZ77733fMpeXfNqq63m/+jlindOxK9DU5vNmTPH76/rUAeM5lZv3rx5lWCj+L76rgAmNRbVkNZ+arhXN4ol6TisQwABBBBAAAEEEEAAAQQQQAABBBBAIEnARmCWKnDIzqGsMgpW0fEVGKGBcPqjfrHq+tR0jK+//tq99dZbfn/1K2o/BWCoT65Ro0Z2msX6LPbaFuukFbSTDUpVf6wyIdWvXz/r3av/9ZVXXvF9sAqS0TNWdvV83pGsB/19w6JFi3y/rIKNFJCmvmgNwGzSpEl1u7q5c+f6fl1lAlJfc7NmzXzfrq5PwUP5FA2oVbYoBWIlBUHlc4ykOpqe7YILLvCbFBy19dZbJ1VjHQIIIIAAAggggAACFS9g7V0Chyr+VQAAAQQQQAABBBBAAAEEEEAAAQQQQAABBLIJWEdqqQOHsp2P9XVfYPr06U5Z01WUxV7Z7CmlE9B0fprmLSk7VenOwpEQQAABBBBAAAEEEKj9AtbeJXCo9j9L7gABBBBAAAEEEEAAAQQQQAABBBBAAAEEUhKwjlQCh1ICrtDDnnzyyW7GjBk+e9C4ceMqVKH0t62p3fr27esPPHr0aNe2bdvSn4QjIoAAAggggAACCCBQRwSsvUvgUB15oNwGAggggAACCCCAAAIIIIAAAggggAACCJRewDpSCRwqvW0lH3HOnDnu4IMP9gSXXnqpn66rkj1Kde82DVynTp3c4MGDS3VYjoMAAggggAACCCCAQJ0UsPYugUN18vFyUwgggAACCCCAAAIIIIAAAggggAACCCBQCgHrSCVwqBSaHCMUmDBhglO2oc0228x/httYLlxg1qxZrlevXn7Hu+++2zVt2rTwg7AHAggggAACCCCAAAIVJGDtXQKHKuihc6sIIIAAAggggAACCCCAAAIIIIAAAgggUJiAdaQSOFSYG7WrF1iwYIEbPny4mz9/vjv11FNdkyZNqt+JGlkFFCw0ffp017FjR7f77rtnrccGBBBAAAEEEEAAAQQQ+H8Ba+8SOMQbgQACCCCAAAIIIIAAAggggAACCCCAAAIIZBGwjlQCh7IAsRoBBBBAAAEEEEAAAQQQQKBWClh7l8ChWvn4uGgEEEAAAQQQQAABBBBAAAEEEEAAAQQQqAkB60glcKgmtDkHAggggAACCCCAAAIIIIBATQlYe5fAoZoS5zwIIIAAAggggAACCCCAAAIIIIAAAgggUOsErCOVwKFa9+i4YAQQQAABBBBAAAEEEEAAgRwC1t4lcCgHEpsQQAABBBBAAAEEEEAAAQQQQAABBBBAoLIFrCOVwKHKfg+4ewQQQAABBBBAAAEEEECgrglYe5fAobr2ZLkfBBBAAAEEEEAAAQQQQAABBBBAAAEEECiZgHWkEjhUMlIOhAACCCCAAAIIIIAAAgggUAYC1t4lcKgMHgaXgAACCCCAAAIIIIAAAggggAACCCCAAALlKWAdqQQOlefz4aoQQAABBBBAAAEEEEAAAQQWT8DauwQOLZ4feyGAAAIIIIAAAggggAACCCCAAAIIIIBABQhYRyqBQxXwsLlFBBBAAAEEEEAAAQQQQKCCBKy9S+BQBT10bhUBBBBAAAEEEEAAAQQQQAABBBBAAAEEChOwjlQChwpzozYCCCCAAAIIIIAAAggggEB5C1h7l8Ch8n5OXB0CCCCAAAIIIIAAAggggAACCCCAAAIILEEB60glcGgJPgROjQACCCCAAAIIIIAAAgggUHIBa+8SOFRyWg6IAAIIIIAAAggggAACCCCAAAIIIIAAAnVFwDpSCRyqK0+U+0AAAQQQQAABBBBAAAEEEJCAtXcJHOJ9QAABBBBAAAEEEEAAAQQQQAABBBBAAAEEsghYRyqBQ1mAWI0AAggggAACCCCAAAIIIFArBay9S+BQrXx8XDQCCCCAAAIIIIAAAggggAACCCCAAAII1ISAdaQSOFQT2pwDAQQQQAABBBBAAAEEEECgpgSsvUvgUE2Jcx4EEEAAAQQQQAABBBBAAAEEEEAAAQQQqHUC1pFK4FCte3RcMAIIIIAAAggggAACCCCAQA4Ba+8SOJQDiU0IIIAAAggggAACCCCAAAIIIIAAAgggUNkC1pFK4FBlvwfcPQIIIIAAAggggAACCCBQ1wSsvUvgUF17stwPAggggAACCCCAAAIIIIAAAggggAACCJRMwDpSCRwqGSkHQgABBBBAAAEEEEAAAQQQKAMBa+8SOFQGD4NLQAABBBBAAAEEEEAAAQQQQAABBBBAAIHyFLCOVAKHyvP5cFUIIIAAAggggAACCCCAAAKLJ2DtXQKHFs+PvRBAAAEEEEAAAQQQQAABBBBAAAEEEECgAgSsI5XAoQp42NwiAggggAACCCCAAAIIIFBBAtbeJXCogh46t4oAAggggAACCCCAAAIIIIAAAggggAAChQlYRyqBQ4W5URsBBBBAAAEEEEAAAQQQQKC8Bay9S+BQeT8nrg4BBBBAAAEEEEAAAQQQQAABBBBAAAEElqCAdaQSOLQEHwKnRgABBBBAAAEEEEAAAQQQKLmAtXcJHCo5LQdEAAEEEEAAAQQQQAABBBBAAAEEEEAAgboiYB2pBA7VlSfKfSCAAAIIIIAAAggggAACCEjA2rtlHzjE40IAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIHSCxA4VHpTjogAAggggAACCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggggAACCCCAQNkLlH3gUCkvsOyfBheIAAIIIIAAAggggAACCCCAAAIIIIAAAmUl8M477/jroZ+yrB4LF4MAAggggAACCCCAAAIIIFCkQBrt3XqLfitFXle0exoXGB2cBQQQQAABBBBAAAEEEEAAAQQQQAABBBBAIA8B+inzQKIKAggggAACCCCAAAIIIIBArRNIo71L4FCtew24YAQQQAABBBBAAAEEEEAAAQQQQAABBBDIJZBGR2qu87ENAQQQQAABBBBAAAEEEEAAgZoQSKO9S+BQTTw5zoEAAggggAACCCCAAAIIIIAAAggggAACNSaQRkdqjV08J0IAAQQQQAABBBBAAAEEEEAgi0Aa7V0Ch7JgsxoBBBBAAAEEEEAAAQQQQAABBBBAAAEEaqdAGh2ptVOCq0YAAQQQQAABBBBAAAEEEKhLAmm0dwkcqktvCPeCAAIIIIAAAggggAACCCCAAAIIIIAAAi6NjlRYEUAAAQQQQAABBBBAAAEEEFjSAmm0dwkcWtJPlfMjgAACCCCAAAIIIIAAAggggAACCCCAQEkF0uhILekFcjAEEEAAAQQQQAABBBBAAAEEFkMgjfYugUOL8SDYBQEEEEAAAQQQQAABBBBAAAEEEEAAAQTKVyCNjtTyvVuuDAEEEEAAAQQQQAABBBBAoFIE0mjvEjhUKW8P94kAAggggAACCCCAAAIIIIAAAggggECFCKTRkVohdNwmAggggAACCCCAAAIIIIBAGQuk0d4lcKiMHziXhgACCCCAAAIIIIAAAggggAACCCCAAAKFC6TRkVr4VbAHAggggAACCCCAAAIIIIAAAqUVSKO9S+BQaZ8RR0MAAQQQQAABBBBAAAEEEEAAAQQQQACBJSyQRkfqEr4lTo8AAggggAACCCCAAAIIIICAS6O9S+AQLxYCCCCAAAIIIIAAAggggAACCCCAAAII1CmBNDpS6xQQN4MAAggggAACCCCAAAIIIFArBdJo7xI4VCtfBS4aAQQQQAABBBBAAAEEEEAAAQQQQAABBLIJpNGRmu1crEcAAQQQQAABBBBAAAEEEECgpgTSaO8SOFRTT4/zIIAAAggggAACCCCAAAIIIIAAAggggECNCKTRkVojF85JEEAAAQQQQAABBBBAAAEEEMghkEZ7l8ChHOBsQgABBBBAAAEEEEAAAQQQQAABBBBAAIHaJ5BGR2rtU+CKEUAAAQQQQAABBBBAAAEE6ppAGu1dAofq2lvC/SCAAAIIIIAAAggggAACCCCAAAIIIFDhAml0pFY4KbePAAIIIIAAAggggAACCCBQBgJptHcJHCqDB8slIIAAAggggAACCCCAAAIIIIAAAggggEDpBNLoSC3d1XEkBBBAAAEEEEAAAQQQQAABBBZPII32LoFDi/cs2AsBBBBAAAEEEEAAAQQQQAABBBBAAAEEylQgjY7UMr1VLgsBBBBAAAEEEEAAAQQQQKCCBNJo7xI4VEEvELeKAAIIIIAAAggggAACCCCAAAIIIIBAJQik0ZFaCW7cIwIIIIAAAggggAACCCCAQHkLpNHeJXCovJ85V4cAAggggAACCCCAAAIIIIAAAggggAACBQqk0ZFa4CVQHQEEEEAAAQQQQAABBBBAAIGSC6TR3v0/jfGT8TDQeIYAAAAASUVORK5CYII=\n", ")" ], "metadata": { "id": "6LX998zzDDaa" } }, { "cell_type": "markdown", "source": [ "Remove the folder `my_dir`" ], "metadata": { "id": "CJd-_xeU8wTH" } }, { "cell_type": "code", "source": [ "!hdfs dfs -rm -r hdfs://localhost:8902/my_dir" ], "metadata": { "id": "fug-vO6d8y00", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "cdf39571-e507-4d86-c84e-743a194609e8" }, "execution_count": 47, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Deleted hdfs://localhost:8902/my_dir\n" ] } ] }, { "cell_type": "markdown", "source": [ "Now the DFS used should be back to ~$4$MB." ], "metadata": { "id": "uJnm8IIdVbXw" } }, { "cell_type": "markdown", "source": [ "\n", "![dfs_used.png](data:image/png;base64,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)\n" ], "metadata": { "id": "CU3gbnQSTL47" } }, { "cell_type": "markdown", "source": [ "## The default filesystem\n", "\n", "By default, `hdfs` will use the local filesystem so you need to prepend `hdfs://...` if you want to use the HDFS filesystem.\n", "\n", "If you do not want to use the prefix `hdfs://localhost:8902/` in the filenames, you could set the property `fs.defaultFS` in `core-site.xml` or else use the option `-fs` like this:\n", "\n", " hdfs dfs -fs hdfs://localhost:8902/" ], "metadata": { "id": "DQQHj14wVnum" } }, { "cell_type": "code", "source": [ "!hdfs dfs -fs hdfs://localhost:8902/ -ls /" ], "metadata": { "id": "iTvSHQntiReX", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "132c3dd4-56ac-415a-988b-157fdefc611b" }, "execution_count": 48, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Found 2 items\n", "drwxrwxrwx - root supergroup 0 2024-08-04 19:12 /content\n", "drwxr-xr-x - root supergroup 0 2024-08-04 19:12 /user\n" ] } ] }, { "cell_type": "markdown", "source": [ "This is the same as" ], "metadata": { "id": "PEteAOIhWOXo" } }, { "cell_type": "code", "source": [ "!hdfs dfs -ls hdfs://localhost:8902/" ], "metadata": { "id": "oh2ddzKYWQEE", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "3a19d10c-d679-4c54-ebb7-521f8a475765" }, "execution_count": 49, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Found 2 items\n", "drwxrwxrwx - root supergroup 0 2024-08-04 19:12 hdfs://localhost:8902/content\n", "drwxr-xr-x - root supergroup 0 2024-08-04 19:12 hdfs://localhost:8902/user\n" ] } ] }, { "cell_type": "markdown", "source": [ "And also the same as" ], "metadata": { "id": "iv1KeqOYWkRx" } }, { "cell_type": "code", "source": [ "!hdfs dfs -D fs.defaultFS=hdfs://localhost:8902/ -ls /" ], "metadata": { "id": "Q67buUSoWmwS", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "65dd651d-22d2-4001-aa28-3c3ae31efb08" }, "execution_count": 50, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Found 2 items\n", "drwxrwxrwx - root supergroup 0 2024-08-04 19:12 /content\n", "drwxr-xr-x - root supergroup 0 2024-08-04 19:12 /user\n" ] } ] }, { "cell_type": "markdown", "source": [ "With the option `-D` we can set any variable on the fly (in this case we set `fs.defaultFS` to be the HDFS filesystem).\n", "\n", "**Note:** the `-D` option should come before any other option." ], "metadata": { "id": "hofC7_S1mmvm" } }, { "cell_type": "markdown", "source": [ "If you configure the property `fs.defaultFS` in `core-site.xml`, you can also use `hdfs dfs -ls /`." ], "metadata": { "id": "ImKd8-1QW5X5" } }, { "cell_type": "code", "source": [ "with open(os.environ['HADOOP_HOME']+'/etc/hadoop/core-site.xml', 'w') as file:\n", " file.write(\"\"\"\n", " \n", " fs.defaultFS\n", " hdfs://localhost:8902/\n", " \n", "\"\"\")" ], "metadata": { "id": "ed3EKZeuBH--" }, "execution_count": 51, "outputs": [] }, { "cell_type": "code", "source": [ "!cat $HADOOP_HOME/etc/hadoop/core-site.xml" ], "metadata": { "id": "CTzAAUV3eaHg", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "23f60115-c315-47da-b3aa-35f108ff2003" }, "execution_count": 52, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\n", " \n", " fs.defaultFS\n", " hdfs://localhost:8902/\n", " \n", "" ] } ] }, { "cell_type": "code", "source": [ "!hdfs dfs -ls /" ], "metadata": { "id": "9NUz2NQpXHzj", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "f985d802-d777-49d5-f5cc-af7a93d03f02" }, "execution_count": 53, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Found 2 items\n", "drwxrwxrwx - root supergroup 0 2024-08-04 19:12 /content\n", "drwxr-xr-x - root supergroup 0 2024-08-04 19:12 /user\n" ] } ] }, { "cell_type": "markdown", "source": [ "Let us set the local filesystem as default (`file:///` means the local filesystem `file://` and the extra slash `/` indicates the root folder)." ], "metadata": { "id": "eg1FRosv9Pp5" } }, { "cell_type": "code", "source": [ "with open(os.environ['HADOOP_HOME']+'/etc/hadoop/core-site.xml', 'w') as file:\n", " file.write(\"\"\"\n", "\n", " \n", " fs.defaultFS\n", " file:///\n", " \n", "\"\"\")" ], "metadata": { "id": "Eak0oQdk9Xap" }, "execution_count": 54, "outputs": [] }, { "cell_type": "markdown", "source": [ "Now run `!hdfs dfs -ls /` as before. This time we are going to be listing the local filesystem and not the HDFS." ], "metadata": { "id": "vzOLLTaP9-3a" } }, { "cell_type": "code", "source": [ "!hdfs dfs -ls /" ], "metadata": { "id": "uftFbN7P-Mfb", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "ccabc915-adb4-4b89-85a4-45083b9904c1" }, "execution_count": 55, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Found 29 items\n", "-rwxr-xr-x 1 root root 0 2024-08-04 18:59 /.dockerenv\n", "-rw-r--r-- 1 root root 17294 2023-11-10 04:55 /NGC-DL-CONTAINER-LICENSE\n", "drwxr-xr-x - root root 20480 2024-08-01 13:20 /bin\n", "drwxr-xr-x - root root 4096 2022-04-18 10:28 /boot\n", "drwxr-xr-x - root root 4096 2024-08-04 19:12 /content\n", "-rw-r--r-- 1 root root 4332 2023-11-10 04:56 /cuda-keyring_1.0-1_all.deb\n", "drwxr-xr-x - root root 4096 2024-08-01 13:41 /datalab\n", "drwxr-xr-x - root root 360 2024-08-04 18:59 /dev\n", "drwxr-xr-x - root root 4096 2024-08-04 18:59 /etc\n", "drwxr-xr-x - root root 4096 2022-04-18 10:28 /home\n", "drwxr-xr-x - root root 4096 2024-08-04 18:59 /kaggle\n", "drwxr-xr-x - root root 4096 2024-08-01 13:20 /lib\n", "drwxr-xr-x - root root 4096 2024-08-01 13:16 /lib32\n", "drwxr-xr-x - root root 4096 2024-08-01 13:16 /lib64\n", "drwxr-xr-x - root root 4096 2023-10-04 02:08 /libx32\n", "drwxr-xr-x - root root 4096 2023-10-04 02:08 /media\n", "drwxr-xr-x - root root 4096 2023-10-04 02:08 /mnt\n", "drwxr-xr-x - root root 4096 2024-08-01 13:54 /opt\n", "dr-xr-xr-x - root root 0 2024-08-04 18:59 /proc\n", "drwxr-xr-x - root root 4096 2024-08-01 13:22 /python-apt\n", "drwx------ - root root 4096 2024-08-04 19:00 /root\n", "drwxr-xr-x - root root 4096 2024-08-01 13:15 /run\n", "drwxr-xr-x - root root 4096 2024-08-04 18:59 /sbin\n", "drwxr-xr-x - root root 4096 2023-10-04 02:08 /srv\n", "dr-xr-xr-x - root root 0 2024-08-04 18:59 /sys\n", "drwxrwxrwt - root root 4096 2024-08-04 19:12 /tmp\n", "drwxr-xr-x - root root 4096 2024-08-01 13:41 /tools\n", "drwxr-xr-x - root root 4096 2024-08-01 13:42 /usr\n", "drwxr-xr-x - root root 4096 2024-08-01 13:41 /var\n" ] } ] }, { "cell_type": "markdown", "source": [ "I advise to get used to the fact that Hadoop interprets a file path as HDFS (`hdfs://`) vs. local (`file://`) depending on the setting of the variable `fs.defaultFS`, since this is often a source of confusion." ], "metadata": { "id": "EFLRoQ9K-vNo" } }, { "cell_type": "markdown", "source": [ "## Show status of HDFS with `hdfs dfsadmin`\n", "\n", "The command `hdfs dfsadmin` allows to run administration tasks on the Hadoop filesystem." ], "metadata": { "id": "-X2Gcpm_rsT3" } }, { "cell_type": "code", "source": [ "!hdfs dfsadmin -h" ], "metadata": { "id": "tVjiDpX6F04B", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "de550d62-4cd9-4aca-c90a-df1e8bb28351" }, "execution_count": 56, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "h: Unknown command\n", "Usage: hdfs dfsadmin\n", "Note: Administrative commands can only be run as the HDFS superuser.\n", "\t[-report [-live] [-dead] [-decommissioning] [-enteringmaintenance] [-inmaintenance] [-slownodes]]\n", "\t[-safemode ]\n", "\t[-saveNamespace [-beforeShutdown]]\n", "\t[-rollEdits]\n", "\t[-restoreFailedStorage true|false|check]\n", "\t[-refreshNodes]\n", "\t[-setQuota ...]\n", "\t[-clrQuota ...]\n", "\t[-setSpaceQuota [-storageType ] ...]\n", "\t[-clrSpaceQuota [-storageType ] ...]\n", "\t[-finalizeUpgrade]\n", "\t[-rollingUpgrade []]\n", "\t[-upgrade ]\n", "\t[-refreshServiceAcl]\n", "\t[-refreshUserToGroupsMappings]\n", "\t[-refreshSuperUserGroupsConfiguration]\n", "\t[-refreshCallQueue]\n", "\t[-refresh [arg1..argn]\n", "\t[-reconfig ]\n", "\t[-printTopology]\n", "\t[-refreshNamenodes datanode_host:ipc_port]\n", "\t[-getVolumeReport datanode_host:ipc_port]\n", "\t[-deleteBlockPool datanode_host:ipc_port blockpoolId [force]]\n", "\t[-setBalancerBandwidth ]\n", "\t[-getBalancerBandwidth ]\n", "\t[-fetchImage ]\n", "\t[-allowSnapshot ]\n", "\t[-disallowSnapshot ]\n", "\t[-provisionSnapshotTrash [-all]]\n", "\t[-shutdownDatanode [upgrade]]\n", "\t[-evictWriters ]\n", "\t[-getDatanodeInfo ]\n", "\t[-metasave filename]\n", "\t[-triggerBlockReport [-incremental] [-namenode ]]\n", "\t[-listOpenFiles [-blockingDecommission] [-path ]]\n", "\t[-help [cmd]]\n", "\n", "Generic options supported are:\n", "-conf specify an application configuration file\n", "-D define a value for a given property\n", "-fs specify default filesystem URL to use, overrides 'fs.defaultFS' property from configurations.\n", "-jt specify a ResourceManager\n", "-files specify a comma-separated list of files to be copied to the map reduce cluster\n", "-libjars specify a comma-separated list of jar files to be included in the classpath\n", "-archives specify a comma-separated list of archives to be unarchived on the compute machines\n", "\n", "The general command line syntax is:\n", "command [genericOptions] [commandOptions]\n", "\n" ] } ] }, { "cell_type": "markdown", "source": [ "The comand `hdfs dfsadmin -report` shows the current status of the Hadoop filesystem. In order to run it on our MiniCluster HDFS we need to pass the option\n", "\n", " -fs hdfs://localhost:8902/\n", "\n", "\n", " \n", "Alternatively, we can configure the default filesystem (the URI of the namenode) in `core-site.xml` (see discussion in [The default filesystem)](#scrollTo=The_default_filesystem)." ], "metadata": { "id": "ZAo3uxzrB7ud" } }, { "cell_type": "code", "source": [ "!hdfs dfsadmin -fs hdfs://localhost:8902/ -report" ], "metadata": { "id": "ZEHoUeoxinbv", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "b9610113-c5f3-4d9f-e2f4-9855cfdaba8e" }, "execution_count": 57, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Configured Capacity: 231316381696 (215.43 GB)\n", "Present Capacity: 159504314437 (148.55 GB)\n", "DFS Remaining: 159501991936 (148.55 GB)\n", "DFS Used: 2322501 (2.21 MB)\n", "DFS Used%: 0.00%\n", "Replicated Blocks:\n", "\tUnder replicated blocks: 0\n", "\tBlocks with corrupt replicas: 0\n", "\tMissing blocks: 0\n", "\tMissing blocks (with replication factor 1): 0\n", "\tLow redundancy blocks with highest priority to recover: 0\n", "\tPending deletion blocks: 0\n", "Erasure Coded Block Groups: \n", "\tLow redundancy block groups: 0\n", "\tBlock groups with corrupt internal blocks: 0\n", "\tMissing block groups: 0\n", "\tLow redundancy blocks with highest priority to recover: 0\n", "\tPending deletion blocks: 0\n", "\n", "-------------------------------------------------\n", "Live datanodes (1):\n", "\n", "Name: 127.0.0.1:39513 (localhost)\n", "Hostname: 127.0.0.1\n", "Decommission Status : Normal\n", "Configured Capacity: 231316381696 (215.43 GB)\n", "DFS Used: 2322501 (2.21 MB)\n", "Non DFS Used: 71778512827 (66.85 GB)\n", "DFS Remaining: 159501991936 (148.55 GB)\n", "DFS Used%: 0.00%\n", "DFS Remaining%: 68.95%\n", "Configured Cache Capacity: 0 (0 B)\n", "Cache Used: 0 (0 B)\n", "Cache Remaining: 0 (0 B)\n", "Cache Used%: 100.00%\n", "Cache Remaining%: 0.00%\n", "Xceivers: 0\n", "Last contact: Sun Aug 04 19:13:22 UTC 2024\n", "Last Block Report: Sun Aug 04 19:12:23 UTC 2024\n", "Num of Blocks: 3\n", "\n", "\n" ] } ] }, { "cell_type": "markdown", "source": [ "The information displayed by `hdfs dfsadmin` corresponds to what is presented in the [NameNode Web UI](#scrollTo=Start_the_NameNode_Web_UI)." ], "metadata": { "id": "_5KPExSrasE9" } }, { "cell_type": "markdown", "source": [ "# Test MapReduce\n", "\n", "Find the MapReduce examples that come with the Hadoop distribution." ], "metadata": { "id": "v1sqv4BItwPZ" } }, { "cell_type": "markdown", "source": [ "## Run the `pi` example" ], "metadata": { "id": "VFrcfoxvo7em" } }, { "cell_type": "code", "source": [ "!find . -name \"*examples*.jar\"" ], "metadata": { "id": "Y6l_P08ovfZ9", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "9770c765-69ce-4028-eabb-b7e5307d9422" }, "execution_count": 58, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "./hadoop-3.4.0/share/hadoop/mapreduce/sources/hadoop-mapreduce-examples-3.4.0-test-sources.jar\n", "./hadoop-3.4.0/share/hadoop/mapreduce/sources/hadoop-mapreduce-examples-3.4.0-sources.jar\n", "./hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar\n" ] } ] }, { "cell_type": "markdown", "source": [ "Check if the cluster is still running, if not you will need to restart it! (from the cell cell [Configure the MiniCluster's ports](#scrollTo=Configure_the_MiniCluster_s_ports))." ], "metadata": { "id": "15uYXe4hgiZl" } }, { "cell_type": "code", "source": [ "!lsof -n -i -P +c0 -sTCP:LISTEN -ac java" ], "metadata": { "id": "RLf3KzXGglLz", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "729403fd-ce8e-494f-ebfd-09bfd2d1ce9c" }, "execution_count": 59, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\n", "java 3727 root 341u IPv4 119325 0t0 TCP 127.0.0.1:8901 (LISTEN)\n", "java 3727 root 346u IPv4 120023 0t0 TCP 127.0.0.1:8902 (LISTEN)\n", "java 3727 root 361u IPv4 120629 0t0 TCP 127.0.0.1:39513 (LISTEN)\n", "java 3727 root 364u IPv4 120632 0t0 TCP 127.0.0.1:39281 (LISTEN)\n", "java 3727 root 393u IPv4 122005 0t0 TCP 127.0.0.1:39089 (LISTEN)\n", "java 3727 root 394u IPv4 122019 0t0 TCP 127.0.0.1:39631 (LISTEN)\n", "java 3727 root 416u IPv4 125902 0t0 TCP *:8031 (LISTEN)\n", "java 3727 root 434u IPv4 125459 0t0 TCP *:10033 (LISTEN)\n", "java 3727 root 444u IPv4 130724 0t0 TCP *:19888 (LISTEN)\n", "java 3727 root 445u IPv4 130725 0t0 TCP *:8088 (LISTEN)\n", "java 3727 root 454u IPv4 130963 0t0 TCP 127.0.0.1:8900 (LISTEN)\n", "java 3727 root 464u IPv4 131073 0t0 TCP *:8033 (LISTEN)\n", "java 3727 root 484u IPv4 132396 0t0 TCP *:8030 (LISTEN)\n", "java 3727 root 494u IPv4 132413 0t0 TCP 127.0.0.1:8903 (LISTEN)\n", "java 3727 root 504u IPv4 132829 0t0 TCP 127.0.0.1:43121 (LISTEN)\n", "java 3727 root 514u IPv4 131545 0t0 TCP 127.0.0.1:41277 (LISTEN)\n", "java 3727 root 524u IPv4 131549 0t0 TCP *:40533 (LISTEN)\n", "java 3727 root 525u IPv4 132834 0t0 TCP 127.0.0.1:40903 (LISTEN)\n" ] } ] }, { "cell_type": "markdown", "source": [ "Here's ChatGPT 3.5's poem inspired by\n", "`lsof -n -i -P +c0 -sTCP:LISTEN`:" ], "metadata": { "id": "-aMDAVoXiGiF" } }, { "cell_type": "code", "source": [ "# @title\n", "from IPython.core.display import HTML\n", "HTML(\"\"\"\n", "
\n", "\n", " \n", " \n", " \n", "\n", "\n", "

\n", "In the realm of networks, where processes twine,
\n", "A command unfolds, a symphony of lines.
\n", "\"Lsof,\" it whispers, with a mystic hum,
\n", "A dance of flags, each one has its own drum.
\n", "

\n", "\"-n -i -P,\" the conductor commands,
\n", "Navigate swiftly, across distant lands.
\n", "\"+c0\" echoes softly, a chorus of glee,
\n", "Embrace all processes, as far as eyes can see.
\n", "

\n", "\"-sTCP:LISTEN,\" a stanza profound,
\n", "Seeking the echoes of ports, a network's sound.
\n", "Processes in repose, in a state so keen,
\n", "A tapestry of LISTEN, a poetic scene.
\n", "

\n", "\"\"\")" ], "metadata": { "id": "y6JlmhVvh_AC", "cellView": "form", "colab": { "base_uri": "https://localhost:8080/", "height": 297 }, "outputId": "2765cd39-c64f-4488-d9f2-31dd6e28aeb8" }, "execution_count": 60, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ], "text/html": [ "\n", "
\n", "\n", " \n", " \n", " \n", "\n", "\n", "

\n", "In the realm of networks, where processes twine,
\n", "A command unfolds, a symphony of lines.
\n", "\"Lsof,\" it whispers, with a mystic hum,
\n", "A dance of flags, each one has its own drum.
\n", "

\n", "\"-n -i -P,\" the conductor commands,
\n", "Navigate swiftly, across distant lands.
\n", "\"+c0\" echoes softly, a chorus of glee,
\n", "Embrace all processes, as far as eyes can see.
\n", "

\n", "\"-sTCP:LISTEN,\" a stanza profound,
\n", "Seeking the echoes of ports, a network's sound.
\n", "Processes in repose, in a state so keen,
\n", "A tapestry of LISTEN, a poetic scene.
\n", "

\n" ] }, "metadata": {}, "execution_count": 60 } ] }, { "cell_type": "markdown", "source": [ "Apart from this poetic digression, I consider `lsof` an exceptionally valuable command." ], "metadata": { "id": "bqwCUH7V-vB9" } }, { "cell_type": "markdown", "source": [ "Use the following command to get the list of available examples in the jar file." ], "metadata": { "id": "seyyW_WskaLB" } }, { "cell_type": "code", "source": [ "!yarn jar ./hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar" ], "metadata": { "id": "MEoD8rs7eV-y", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "d268cbc5-8b0e-40cd-ac6f-b74aec6719a9" }, "execution_count": 61, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "An example program must be given as the first argument.\n", "Valid program names are:\n", " aggregatewordcount: An Aggregate based map/reduce program that counts the words in the input files.\n", " aggregatewordhist: An Aggregate based map/reduce program that computes the histogram of the words in the input files.\n", " bbp: A map/reduce program that uses Bailey-Borwein-Plouffe to compute exact digits of Pi.\n", " dbcount: An example job that count the pageview counts from a database.\n", " distbbp: A map/reduce program that uses a BBP-type formula to compute exact bits of Pi.\n", " grep: A map/reduce program that counts the matches of a regex in the input.\n", " join: A job that effects a join over sorted, equally partitioned datasets\n", " multifilewc: A job that counts words from several files.\n", " pentomino: A map/reduce tile laying program to find solutions to pentomino problems.\n", " pi: A map/reduce program that estimates Pi using a quasi-Monte Carlo method.\n", " randomtextwriter: A map/reduce program that writes 10GB of random textual data per node.\n", " randomwriter: A map/reduce program that writes 10GB of random data per node.\n", " secondarysort: An example defining a secondary sort to the reduce.\n", " sort: A map/reduce program that sorts the data written by the random writer.\n", " sudoku: A sudoku solver.\n", " teragen: Generate data for the terasort\n", " terasort: Run the terasort\n", " teravalidate: Checking results of terasort\n", " wordcount: A map/reduce program that counts the words in the input files.\n", " wordmean: A map/reduce program that counts the average length of the words in the input files.\n", " wordmedian: A map/reduce program that counts the median length of the words in the input files.\n", " wordstandarddeviation: A map/reduce program that counts the standard deviation of the length of the words in the input files.\n" ] } ] }, { "cell_type": "markdown", "source": [ "Let us run the `pi` example (here we call it without arguments in order to get a usage message) through `yarn`." ], "metadata": { "id": "66tQzkuwfOeX" } }, { "cell_type": "code", "source": [ "!yarn jar ./hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar pi" ], "metadata": { "id": "XYumkNgNfSnR", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "24cfebd7-812f-462d-e19c-a03a336de7b5" }, "execution_count": 62, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Usage: org.apache.hadoop.examples.QuasiMonteCarlo \n", "Generic options supported are:\n", "-conf specify an application configuration file\n", "-D define a value for a given property\n", "-fs specify default filesystem URL to use, overrides 'fs.defaultFS' property from configurations.\n", "-jt specify a ResourceManager\n", "-files specify a comma-separated list of files to be copied to the map reduce cluster\n", "-libjars specify a comma-separated list of jar files to be included in the classpath\n", "-archives specify a comma-separated list of archives to be unarchived on the compute machines\n", "\n", "The general command line syntax is:\n", "command [genericOptions] [commandOptions]\n", "\n" ] } ] }, { "cell_type": "markdown", "source": [ "The command takes `[genericOptions]` and `[commandOptions]`.\n", "\n", "The command options are:\n", "\n", "* `nMaps`, the number of mappers\n", "* `nSamples`, the number of iterations per mapper\n" ], "metadata": { "id": "vTGLRYl9GkGw" } }, { "cell_type": "code", "source": [ "!yarn jar ./hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar pi \\\n", " 5 1000" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "PBt5b-JKfiyt", "outputId": "48171141-f7b0-43c6-ee88-96492ce26293" }, "execution_count": 63, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Number of Maps = 5\n", "Samples per Map = 1000\n", "Wrote input for Map #0\n", "Wrote input for Map #1\n", "Wrote input for Map #2\n", "Wrote input for Map #3\n", "Wrote input for Map #4\n", "Starting Job\n", "2024-08-04 19:13:31,625 INFO impl.MetricsConfig: Loaded properties from hadoop-metrics2.properties\n", "2024-08-04 19:13:31,799 INFO impl.MetricsSystemImpl: Scheduled Metric snapshot period at 10 second(s).\n", "2024-08-04 19:13:31,799 INFO impl.MetricsSystemImpl: JobTracker metrics system started\n", "2024-08-04 19:13:31,979 INFO input.FileInputFormat: Total input files to process : 5\n", "2024-08-04 19:13:32,000 INFO mapreduce.JobSubmitter: number of splits:5\n", "2024-08-04 19:13:32,402 INFO mapreduce.JobSubmitter: Submitting tokens for job: job_local2011001580_0001\n", "2024-08-04 19:13:32,402 INFO mapreduce.JobSubmitter: Executing with tokens: []\n", "2024-08-04 19:13:32,687 INFO mapreduce.Job: The url to track the job: http://localhost:8080/\n", "2024-08-04 19:13:32,688 INFO mapreduce.Job: Running job: job_local2011001580_0001\n", "2024-08-04 19:13:32,699 INFO mapred.LocalJobRunner: OutputCommitter set in config null\n", "2024-08-04 19:13:32,715 INFO output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:13:32,717 INFO output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:13:32,717 INFO output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:13:32,719 INFO mapred.LocalJobRunner: OutputCommitter is org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter\n", "2024-08-04 19:13:32,814 INFO mapred.LocalJobRunner: Waiting for map tasks\n", "2024-08-04 19:13:32,815 INFO mapred.LocalJobRunner: Starting task: attempt_local2011001580_0001_m_000000_0\n", "2024-08-04 19:13:32,870 INFO output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:13:32,870 INFO output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:13:32,871 INFO output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:13:32,918 INFO mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:13:32,925 INFO mapred.MapTask: Processing split: file:/content/QuasiMonteCarlo_1722798810530_1260429884/in/part0:0+118\n", "2024-08-04 19:13:33,034 INFO mapred.MapTask: (EQUATOR) 0 kvi 26214396(104857584)\n", "2024-08-04 19:13:33,034 INFO mapred.MapTask: mapreduce.task.io.sort.mb: 100\n", "2024-08-04 19:13:33,034 INFO mapred.MapTask: soft limit at 83886080\n", "2024-08-04 19:13:33,034 INFO mapred.MapTask: bufstart = 0; bufvoid = 104857600\n", "2024-08-04 19:13:33,034 INFO mapred.MapTask: kvstart = 26214396; length = 6553600\n", "2024-08-04 19:13:33,040 INFO mapred.MapTask: Map output collector class = org.apache.hadoop.mapred.MapTask$MapOutputBuffer\n", "2024-08-04 19:13:33,065 INFO mapred.LocalJobRunner: \n", "2024-08-04 19:13:33,066 INFO mapred.MapTask: Starting flush of map output\n", "2024-08-04 19:13:33,066 INFO mapred.MapTask: Spilling map output\n", "2024-08-04 19:13:33,066 INFO mapred.MapTask: bufstart = 0; bufend = 18; bufvoid = 104857600\n", "2024-08-04 19:13:33,066 INFO mapred.MapTask: kvstart = 26214396(104857584); kvend = 26214392(104857568); length = 5/6553600\n", "2024-08-04 19:13:33,075 INFO mapred.MapTask: Finished spill 0\n", "2024-08-04 19:13:33,119 INFO mapred.Task: Task:attempt_local2011001580_0001_m_000000_0 is done. And is in the process of committing\n", "2024-08-04 19:13:33,124 INFO mapred.LocalJobRunner: Generated 1000 samples.\n", "2024-08-04 19:13:33,124 INFO mapred.Task: Task 'attempt_local2011001580_0001_m_000000_0' done.\n", "2024-08-04 19:13:33,149 INFO mapred.Task: Final Counters for attempt_local2011001580_0001_m_000000_0: Counters: 17\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=282496\n", "\t\tFILE: Number of bytes written=997502\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\tMap-Reduce Framework\n", "\t\tMap input records=1\n", "\t\tMap output records=2\n", "\t\tMap output bytes=18\n", "\t\tMap output materialized bytes=28\n", "\t\tInput split bytes=128\n", "\t\tCombine input records=0\n", "\t\tSpilled Records=2\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=0\n", "\t\tGC time elapsed (ms)=23\n", "\t\tTotal committed heap usage (bytes)=354418688\n", "\tFile Input Format Counters \n", "\t\tBytes Read=130\n", "2024-08-04 19:13:33,149 INFO mapred.LocalJobRunner: Finishing task: attempt_local2011001580_0001_m_000000_0\n", "2024-08-04 19:13:33,150 INFO mapred.LocalJobRunner: Starting task: attempt_local2011001580_0001_m_000001_0\n", "2024-08-04 19:13:33,152 INFO output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:13:33,152 INFO output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:13:33,152 INFO output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:13:33,153 INFO mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:13:33,156 INFO mapred.MapTask: Processing split: file:/content/QuasiMonteCarlo_1722798810530_1260429884/in/part3:0+118\n", "2024-08-04 19:13:33,173 INFO mapred.MapTask: (EQUATOR) 0 kvi 26214396(104857584)\n", "2024-08-04 19:13:33,173 INFO mapred.MapTask: mapreduce.task.io.sort.mb: 100\n", "2024-08-04 19:13:33,173 INFO mapred.MapTask: soft limit at 83886080\n", "2024-08-04 19:13:33,173 INFO mapred.MapTask: bufstart = 0; bufvoid = 104857600\n", "2024-08-04 19:13:33,173 INFO mapred.MapTask: kvstart = 26214396; length = 6553600\n", "2024-08-04 19:13:33,174 INFO mapred.MapTask: Map output collector class = org.apache.hadoop.mapred.MapTask$MapOutputBuffer\n", "2024-08-04 19:13:33,178 INFO mapred.LocalJobRunner: \n", "2024-08-04 19:13:33,179 INFO mapred.MapTask: Starting flush of map output\n", "2024-08-04 19:13:33,179 INFO mapred.MapTask: Spilling map output\n", "2024-08-04 19:13:33,179 INFO mapred.MapTask: bufstart = 0; bufend = 18; bufvoid = 104857600\n", "2024-08-04 19:13:33,179 INFO mapred.MapTask: kvstart = 26214396(104857584); kvend = 26214392(104857568); length = 5/6553600\n", "2024-08-04 19:13:33,181 INFO mapred.MapTask: Finished spill 0\n", "2024-08-04 19:13:33,185 INFO mapred.Task: Task:attempt_local2011001580_0001_m_000001_0 is done. And is in the process of committing\n", "2024-08-04 19:13:33,187 INFO mapred.LocalJobRunner: Generated 1000 samples.\n", "2024-08-04 19:13:33,188 INFO mapred.Task: Task 'attempt_local2011001580_0001_m_000001_0' done.\n", "2024-08-04 19:13:33,188 INFO mapred.Task: Final Counters for attempt_local2011001580_0001_m_000001_0: Counters: 17\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=283289\n", "\t\tFILE: Number of bytes written=997562\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\tMap-Reduce Framework\n", "\t\tMap input records=1\n", "\t\tMap output records=2\n", "\t\tMap output bytes=18\n", "\t\tMap output materialized bytes=28\n", "\t\tInput split bytes=128\n", "\t\tCombine input records=0\n", "\t\tSpilled Records=2\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=0\n", "\t\tGC time elapsed (ms)=0\n", "\t\tTotal committed heap usage (bytes)=354418688\n", "\tFile Input Format Counters \n", "\t\tBytes Read=130\n", "2024-08-04 19:13:33,189 INFO mapred.LocalJobRunner: Finishing task: attempt_local2011001580_0001_m_000001_0\n", "2024-08-04 19:13:33,192 INFO mapred.LocalJobRunner: Starting task: attempt_local2011001580_0001_m_000002_0\n", "2024-08-04 19:13:33,193 INFO output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:13:33,193 INFO output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:13:33,193 INFO output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:13:33,194 INFO mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:13:33,196 INFO mapred.MapTask: Processing split: file:/content/QuasiMonteCarlo_1722798810530_1260429884/in/part2:0+118\n", "2024-08-04 19:13:33,239 INFO mapred.MapTask: (EQUATOR) 0 kvi 26214396(104857584)\n", "2024-08-04 19:13:33,239 INFO mapred.MapTask: mapreduce.task.io.sort.mb: 100\n", "2024-08-04 19:13:33,239 INFO mapred.MapTask: soft limit at 83886080\n", "2024-08-04 19:13:33,239 INFO mapred.MapTask: bufstart = 0; bufvoid = 104857600\n", "2024-08-04 19:13:33,240 INFO mapred.MapTask: kvstart = 26214396; length = 6553600\n", "2024-08-04 19:13:33,242 INFO mapred.MapTask: Map output collector class = org.apache.hadoop.mapred.MapTask$MapOutputBuffer\n", "2024-08-04 19:13:33,246 INFO mapred.LocalJobRunner: \n", "2024-08-04 19:13:33,247 INFO mapred.MapTask: Starting flush of map output\n", "2024-08-04 19:13:33,247 INFO mapred.MapTask: Spilling map output\n", "2024-08-04 19:13:33,247 INFO mapred.MapTask: bufstart = 0; bufend = 18; bufvoid = 104857600\n", "2024-08-04 19:13:33,247 INFO mapred.MapTask: kvstart = 26214396(104857584); kvend = 26214392(104857568); length = 5/6553600\n", "2024-08-04 19:13:33,248 INFO mapred.MapTask: Finished spill 0\n", "2024-08-04 19:13:33,252 INFO mapred.Task: Task:attempt_local2011001580_0001_m_000002_0 is done. And is in the process of committing\n", "2024-08-04 19:13:33,256 INFO mapred.LocalJobRunner: Generated 1000 samples.\n", "2024-08-04 19:13:33,257 INFO mapred.Task: Task 'attempt_local2011001580_0001_m_000002_0' done.\n", "2024-08-04 19:13:33,257 INFO mapred.Task: Final Counters for attempt_local2011001580_0001_m_000002_0: Counters: 17\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=284082\n", "\t\tFILE: Number of bytes written=997622\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\tMap-Reduce Framework\n", "\t\tMap input records=1\n", "\t\tMap output records=2\n", "\t\tMap output bytes=18\n", "\t\tMap output materialized bytes=28\n", "\t\tInput split bytes=128\n", "\t\tCombine input records=0\n", "\t\tSpilled Records=2\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=0\n", "\t\tGC time elapsed (ms)=16\n", "\t\tTotal committed heap usage (bytes)=354418688\n", "\tFile Input Format Counters \n", "\t\tBytes Read=130\n", "2024-08-04 19:13:33,258 INFO mapred.LocalJobRunner: Finishing task: attempt_local2011001580_0001_m_000002_0\n", "2024-08-04 19:13:33,258 INFO mapred.LocalJobRunner: Starting task: attempt_local2011001580_0001_m_000003_0\n", "2024-08-04 19:13:33,259 INFO output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:13:33,259 INFO output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:13:33,259 INFO output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:13:33,260 INFO mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:13:33,262 INFO mapred.MapTask: Processing split: file:/content/QuasiMonteCarlo_1722798810530_1260429884/in/part4:0+118\n", "2024-08-04 19:13:33,392 INFO mapred.MapTask: (EQUATOR) 0 kvi 26214396(104857584)\n", "2024-08-04 19:13:33,392 INFO mapred.MapTask: mapreduce.task.io.sort.mb: 100\n", "2024-08-04 19:13:33,392 INFO mapred.MapTask: soft limit at 83886080\n", "2024-08-04 19:13:33,393 INFO mapred.MapTask: bufstart = 0; bufvoid = 104857600\n", "2024-08-04 19:13:33,393 INFO mapred.MapTask: kvstart = 26214396; length = 6553600\n", "2024-08-04 19:13:33,394 INFO mapred.MapTask: Map output collector class = org.apache.hadoop.mapred.MapTask$MapOutputBuffer\n", "2024-08-04 19:13:33,397 INFO mapred.LocalJobRunner: \n", "2024-08-04 19:13:33,397 INFO mapred.MapTask: Starting flush of map output\n", "2024-08-04 19:13:33,398 INFO mapred.MapTask: Spilling map output\n", "2024-08-04 19:13:33,398 INFO mapred.MapTask: bufstart = 0; bufend = 18; bufvoid = 104857600\n", "2024-08-04 19:13:33,398 INFO mapred.MapTask: kvstart = 26214396(104857584); kvend = 26214392(104857568); length = 5/6553600\n", "2024-08-04 19:13:33,399 INFO mapred.MapTask: Finished spill 0\n", "2024-08-04 19:13:33,403 INFO mapred.Task: Task:attempt_local2011001580_0001_m_000003_0 is done. And is in the process of committing\n", "2024-08-04 19:13:33,411 INFO mapred.LocalJobRunner: Generated 1000 samples.\n", "2024-08-04 19:13:33,415 INFO mapred.Task: Task 'attempt_local2011001580_0001_m_000003_0' done.\n", "2024-08-04 19:13:33,415 INFO mapred.Task: Final Counters for attempt_local2011001580_0001_m_000003_0: Counters: 17\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=284875\n", "\t\tFILE: Number of bytes written=997682\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\tMap-Reduce Framework\n", "\t\tMap input records=1\n", "\t\tMap output records=2\n", "\t\tMap output bytes=18\n", "\t\tMap output materialized bytes=28\n", "\t\tInput split bytes=128\n", "\t\tCombine input records=0\n", "\t\tSpilled Records=2\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=0\n", "\t\tGC time elapsed (ms)=0\n", "\t\tTotal committed heap usage (bytes)=354418688\n", "\tFile Input Format Counters \n", "\t\tBytes Read=130\n", "2024-08-04 19:13:33,417 INFO mapred.LocalJobRunner: Finishing task: attempt_local2011001580_0001_m_000003_0\n", "2024-08-04 19:13:33,417 INFO mapred.LocalJobRunner: Starting task: attempt_local2011001580_0001_m_000004_0\n", "2024-08-04 19:13:33,422 INFO output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:13:33,423 INFO output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:13:33,423 INFO output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:13:33,423 INFO mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:13:33,431 INFO mapred.MapTask: Processing split: file:/content/QuasiMonteCarlo_1722798810530_1260429884/in/part1:0+118\n", "2024-08-04 19:13:33,458 INFO mapred.MapTask: (EQUATOR) 0 kvi 26214396(104857584)\n", "2024-08-04 19:13:33,458 INFO mapred.MapTask: mapreduce.task.io.sort.mb: 100\n", "2024-08-04 19:13:33,458 INFO mapred.MapTask: soft limit at 83886080\n", "2024-08-04 19:13:33,458 INFO mapred.MapTask: bufstart = 0; bufvoid = 104857600\n", "2024-08-04 19:13:33,458 INFO mapred.MapTask: kvstart = 26214396; length = 6553600\n", "2024-08-04 19:13:33,462 INFO mapred.MapTask: Map output collector class = org.apache.hadoop.mapred.MapTask$MapOutputBuffer\n", "2024-08-04 19:13:33,465 INFO mapred.LocalJobRunner: \n", "2024-08-04 19:13:33,474 INFO mapred.MapTask: Starting flush of map output\n", "2024-08-04 19:13:33,474 INFO mapred.MapTask: Spilling map output\n", "2024-08-04 19:13:33,474 INFO mapred.MapTask: bufstart = 0; bufend = 18; bufvoid = 104857600\n", "2024-08-04 19:13:33,474 INFO mapred.MapTask: kvstart = 26214396(104857584); kvend = 26214392(104857568); length = 5/6553600\n", "2024-08-04 19:13:33,479 INFO mapred.MapTask: Finished spill 0\n", "2024-08-04 19:13:33,493 INFO mapred.Task: Task:attempt_local2011001580_0001_m_000004_0 is done. And is in the process of committing\n", "2024-08-04 19:13:33,517 INFO mapred.LocalJobRunner: Generated 1000 samples.\n", "2024-08-04 19:13:33,518 INFO mapred.Task: Task 'attempt_local2011001580_0001_m_000004_0' done.\n", "2024-08-04 19:13:33,519 INFO mapred.Task: Final Counters for attempt_local2011001580_0001_m_000004_0: Counters: 17\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=285156\n", "\t\tFILE: Number of bytes written=997742\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\tMap-Reduce Framework\n", "\t\tMap input records=1\n", "\t\tMap output records=2\n", "\t\tMap output bytes=18\n", "\t\tMap output materialized bytes=28\n", "\t\tInput split bytes=128\n", "\t\tCombine input records=0\n", "\t\tSpilled Records=2\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=0\n", "\t\tGC time elapsed (ms)=8\n", "\t\tTotal committed heap usage (bytes)=473956352\n", "\tFile Input Format Counters \n", "\t\tBytes Read=130\n", "2024-08-04 19:13:33,520 INFO mapred.LocalJobRunner: Finishing task: attempt_local2011001580_0001_m_000004_0\n", "2024-08-04 19:13:33,520 INFO mapred.LocalJobRunner: map task executor complete.\n", "2024-08-04 19:13:33,532 INFO mapred.LocalJobRunner: Waiting for reduce tasks\n", "2024-08-04 19:13:33,534 INFO mapred.LocalJobRunner: Starting task: attempt_local2011001580_0001_r_000000_0\n", "2024-08-04 19:13:33,561 INFO output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:13:33,561 INFO output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:13:33,561 INFO output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:13:33,562 INFO mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:13:33,567 INFO mapred.ReduceTask: Using ShuffleConsumerPlugin: org.apache.hadoop.mapreduce.task.reduce.Shuffle@5046a72e\n", "2024-08-04 19:13:33,570 WARN impl.MetricsSystemImpl: JobTracker metrics system already initialized!\n", "2024-08-04 19:13:33,603 INFO reduce.MergeManagerImpl: MergerManager: memoryLimit=2382574336, maxSingleShuffleLimit=595643584, mergeThreshold=1572499072, ioSortFactor=10, memToMemMergeOutputsThreshold=10\n", "2024-08-04 19:13:33,613 INFO reduce.EventFetcher: attempt_local2011001580_0001_r_000000_0 Thread started: EventFetcher for fetching Map Completion Events\n", "2024-08-04 19:13:33,688 INFO reduce.LocalFetcher: localfetcher#1 about to shuffle output of map attempt_local2011001580_0001_m_000004_0 decomp: 24 len: 28 to MEMORY\n", "2024-08-04 19:13:33,696 INFO mapreduce.Job: Job job_local2011001580_0001 running in uber mode : false\n", "2024-08-04 19:13:33,696 INFO reduce.InMemoryMapOutput: Read 24 bytes from map-output for attempt_local2011001580_0001_m_000004_0\n", "2024-08-04 19:13:33,696 INFO reduce.MergeManagerImpl: closeInMemoryFile -> map-output of size: 24, inMemoryMapOutputs.size() -> 1, commitMemory -> 0, usedMemory ->24\n", "2024-08-04 19:13:33,706 INFO mapreduce.Job: map 100% reduce 0%\n", "2024-08-04 19:13:33,711 INFO reduce.LocalFetcher: localfetcher#1 about to shuffle output of map attempt_local2011001580_0001_m_000001_0 decomp: 24 len: 28 to MEMORY\n", "2024-08-04 19:13:33,716 INFO reduce.InMemoryMapOutput: Read 24 bytes from map-output for attempt_local2011001580_0001_m_000001_0\n", "2024-08-04 19:13:33,716 INFO reduce.MergeManagerImpl: closeInMemoryFile -> map-output of size: 24, inMemoryMapOutputs.size() -> 2, commitMemory -> 24, usedMemory ->48\n", "2024-08-04 19:13:33,722 INFO reduce.LocalFetcher: localfetcher#1 about to shuffle output of map attempt_local2011001580_0001_m_000002_0 decomp: 24 len: 28 to MEMORY\n", "2024-08-04 19:13:33,726 INFO reduce.InMemoryMapOutput: Read 24 bytes from map-output for attempt_local2011001580_0001_m_000002_0\n", "2024-08-04 19:13:33,726 INFO reduce.MergeManagerImpl: closeInMemoryFile -> map-output of size: 24, inMemoryMapOutputs.size() -> 3, commitMemory -> 48, usedMemory ->72\n", "2024-08-04 19:13:33,729 INFO reduce.LocalFetcher: localfetcher#1 about to shuffle output of map attempt_local2011001580_0001_m_000000_0 decomp: 24 len: 28 to MEMORY\n", "2024-08-04 19:13:33,731 INFO reduce.InMemoryMapOutput: Read 24 bytes from map-output for attempt_local2011001580_0001_m_000000_0\n", "2024-08-04 19:13:33,731 INFO reduce.MergeManagerImpl: closeInMemoryFile -> map-output of size: 24, inMemoryMapOutputs.size() -> 4, commitMemory -> 72, usedMemory ->96\n", "2024-08-04 19:13:33,737 INFO reduce.LocalFetcher: localfetcher#1 about to shuffle output of map attempt_local2011001580_0001_m_000003_0 decomp: 24 len: 28 to MEMORY\n", "2024-08-04 19:13:33,740 INFO reduce.InMemoryMapOutput: Read 24 bytes from map-output for attempt_local2011001580_0001_m_000003_0\n", "2024-08-04 19:13:33,741 INFO reduce.MergeManagerImpl: closeInMemoryFile -> map-output of size: 24, inMemoryMapOutputs.size() -> 5, commitMemory -> 96, usedMemory ->120\n", "2024-08-04 19:13:33,742 INFO reduce.EventFetcher: EventFetcher is interrupted.. Returning\n", "2024-08-04 19:13:33,743 INFO mapred.LocalJobRunner: 5 / 5 copied.\n", "2024-08-04 19:13:33,744 INFO reduce.MergeManagerImpl: finalMerge called with 5 in-memory map-outputs and 0 on-disk map-outputs\n", "2024-08-04 19:13:33,754 INFO mapred.Merger: Merging 5 sorted segments\n", "2024-08-04 19:13:33,754 INFO mapred.Merger: Down to the last merge-pass, with 5 segments left of total size: 105 bytes\n", "2024-08-04 19:13:33,757 INFO reduce.MergeManagerImpl: Merged 5 segments, 120 bytes to disk to satisfy reduce memory limit\n", "2024-08-04 19:13:33,757 INFO reduce.MergeManagerImpl: Merging 1 files, 116 bytes from disk\n", "2024-08-04 19:13:33,759 INFO reduce.MergeManagerImpl: Merging 0 segments, 0 bytes from memory into reduce\n", "2024-08-04 19:13:33,759 INFO mapred.Merger: Merging 1 sorted segments\n", "2024-08-04 19:13:33,759 INFO mapred.Merger: Down to the last merge-pass, with 1 segments left of total size: 109 bytes\n", "2024-08-04 19:13:33,760 INFO mapred.LocalJobRunner: 5 / 5 copied.\n", "2024-08-04 19:13:33,765 INFO Configuration.deprecation: mapred.skip.on is deprecated. Instead, use mapreduce.job.skiprecords\n", "2024-08-04 19:13:33,779 INFO mapred.Task: Task:attempt_local2011001580_0001_r_000000_0 is done. And is in the process of committing\n", "2024-08-04 19:13:33,783 INFO mapred.LocalJobRunner: 5 / 5 copied.\n", "2024-08-04 19:13:33,783 INFO mapred.Task: Task attempt_local2011001580_0001_r_000000_0 is allowed to commit now\n", "2024-08-04 19:13:33,786 INFO output.FileOutputCommitter: Saved output of task 'attempt_local2011001580_0001_r_000000_0' to file:/content/QuasiMonteCarlo_1722798810530_1260429884/out\n", "2024-08-04 19:13:33,788 INFO mapred.LocalJobRunner: reduce > reduce\n", "2024-08-04 19:13:33,788 INFO mapred.Task: Task 'attempt_local2011001580_0001_r_000000_0' done.\n", "2024-08-04 19:13:33,792 INFO mapred.Task: Final Counters for attempt_local2011001580_0001_r_000000_0: Counters: 24\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=285572\n", "\t\tFILE: Number of bytes written=998097\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\tMap-Reduce Framework\n", "\t\tCombine input records=0\n", "\t\tCombine output records=0\n", "\t\tReduce input groups=2\n", "\t\tReduce shuffle bytes=140\n", "\t\tReduce input records=10\n", "\t\tReduce output records=0\n", "\t\tSpilled Records=10\n", "\t\tShuffled Maps =5\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=5\n", "\t\tGC time elapsed (ms)=0\n", "\t\tTotal committed heap usage (bytes)=473956352\n", "\tShuffle Errors\n", "\t\tBAD_ID=0\n", "\t\tCONNECTION=0\n", "\t\tIO_ERROR=0\n", "\t\tWRONG_LENGTH=0\n", "\t\tWRONG_MAP=0\n", "\t\tWRONG_REDUCE=0\n", "\tFile Output Format Counters \n", "\t\tBytes Written=109\n", "2024-08-04 19:13:33,792 INFO mapred.LocalJobRunner: Finishing task: attempt_local2011001580_0001_r_000000_0\n", "2024-08-04 19:13:33,794 INFO mapred.LocalJobRunner: reduce task executor complete.\n", "2024-08-04 19:13:34,708 INFO mapreduce.Job: map 100% reduce 100%\n", "2024-08-04 19:13:34,709 INFO mapreduce.Job: Job job_local2011001580_0001 completed successfully\n", "2024-08-04 19:13:34,753 INFO mapreduce.Job: Counters: 30\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=1705470\n", "\t\tFILE: Number of bytes written=5986207\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\tMap-Reduce Framework\n", "\t\tMap input records=5\n", "\t\tMap output records=10\n", "\t\tMap output bytes=90\n", "\t\tMap output materialized bytes=140\n", "\t\tInput split bytes=640\n", "\t\tCombine input records=0\n", "\t\tCombine output records=0\n", "\t\tReduce input groups=2\n", "\t\tReduce shuffle bytes=140\n", "\t\tReduce input records=10\n", "\t\tReduce output records=0\n", "\t\tSpilled Records=20\n", "\t\tShuffled Maps =5\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=5\n", "\t\tGC time elapsed (ms)=47\n", "\t\tTotal committed heap usage (bytes)=2365587456\n", "\tShuffle Errors\n", "\t\tBAD_ID=0\n", "\t\tCONNECTION=0\n", "\t\tIO_ERROR=0\n", "\t\tWRONG_LENGTH=0\n", "\t\tWRONG_MAP=0\n", "\t\tWRONG_REDUCE=0\n", "\tFile Input Format Counters \n", "\t\tBytes Read=650\n", "\tFile Output Format Counters \n", "\t\tBytes Written=109\n", "Job Finished in 3.28 seconds\n", "Estimated value of Pi is 3.14160000000000000000\n" ] } ] }, { "cell_type": "markdown", "source": [ "The job completed successfully, however it did not run on the MiniCluster because we did not specify the MiniCluster's Yarn Resource Manager address.\n", "\n", "\n", "In fact, `yarn application -list` returns no apps (neither running nor finished).\n" ], "metadata": { "id": "6foi_r8f-QDH" } }, { "cell_type": "code", "source": [ "!yarn application -D yarn.resourcemanager.address=localhost:8903 -list -appStates ALL" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "_GIEiotdBZZw", "outputId": "d72b1287-05f2-44d9-e808-faf2597972cc" }, "execution_count": 64, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "2024-08-04 19:13:37,808 INFO client.DefaultNoHARMFailoverProxyProvider: Connecting to ResourceManager at localhost/127.0.0.1:8903\n", "Total number of applications (application-types: [], states: [NEW, NEW_SAVING, SUBMITTED, ACCEPTED, RUNNING, FINISHED, FAILED, KILLED] and tags: []):0\n", " Application-Id\t Application-Name\t Application-Type\t User\t Queue\t State\t Final-State\t Progress\t Tracking-URL\n" ] } ] }, { "cell_type": "markdown", "source": [ "## Local configuration files" ], "metadata": { "id": "tVaJQD34VhcL" } }, { "cell_type": "markdown", "source": [ "In order to be able to submit the job to the MiniCluster with YARN we need to edit three files:\n", "\n", "\n", "* `mapred-site.xml`\n", "* `core-site.xml`\n", "* `yarn-site.xml`\n", "\n", "(see https://hadoop.apache.org/docs/current/hadoop-project-dist/hadoop-common/SingleCluster.html#YARN_on_a_Single_Node)\n" ], "metadata": { "id": "a9geb1q-8qSE" } }, { "cell_type": "code", "source": [ "file_mapred_site = os.path.join(os.environ['HADOOP_HOME'],'etc/hadoop/mapred-site.xml')\n", "file_core_site = os.path.join(os.environ['HADOOP_HOME'],'etc/hadoop/core-site.xml')\n", "file_yarn_site = os.path.join(os.environ['HADOOP_HOME'],'etc/hadoop/yarn-site.xml')" ], "metadata": { "id": "YmW0MsoTH0Bz" }, "execution_count": 65, "outputs": [] }, { "cell_type": "code", "source": [ "%%bash\n", "cat > $HADOOP_HOME/'etc/hadoop/mapred-site.xml' << 🐸\n", "\n", " \n", " mapreduce.framework.name\n", " yarn\n", " \n", " \n", " mapreduce.application.classpath\n", " ${HADOOP_HOME}/share/hadoop/mapreduce/*:${HADOOP_HOME}/share/hadoop/mapreduce/lib/*\n", " \n", "\n", "🐸" ], "metadata": { "id": "Ru0uB16T9uPA" }, "execution_count": 66, "outputs": [] }, { "cell_type": "code", "source": [ "!cat $HADOOP_HOME/'etc/hadoop/mapred-site.xml'" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1hKTx-LQXa4e", "outputId": "40e05181-58f4-4b0b-f617-d78aa7e61221" }, "execution_count": 67, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\n", " \n", " mapreduce.framework.name\n", " yarn\n", " \n", " \n", " mapreduce.application.classpath\n", " /content/hadoop-3.4.0/share/hadoop/mapreduce/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*\n", " \n", "\n" ] } ] }, { "cell_type": "markdown", "source": [ "Set the default filesystem as the MiniCluster's filesystem in `core-site.xml`. This is necessary in order to allow YARN to save the applications logs to HDFS and this is why we create the directory `/tmp/logs` on HDFS." ], "metadata": { "id": "QRICGx9K883j" } }, { "cell_type": "code", "source": [ "with open(file_core_site, 'w') as file:\n", " file.write(\"\"\"\n", "\n", " \n", " fs.defaultFS\n", " hdfs://localhost:8902/\n", " \n", "\"\"\")" ], "metadata": { "id": "R1n1y3io85As" }, "execution_count": 68, "outputs": [] }, { "cell_type": "markdown", "source": [ "Set `yarn.resourcemanager.address=localhost:8903` in `yarn-site.xml`." ], "metadata": { "id": "pD8pB4MCGa_5" } }, { "cell_type": "code", "source": [ "with open(file_yarn_site, 'w') as file:\n", " file.write(\"\"\"\n", "\n", "\n", " yarn.resourcemanager.address\n", " localhost:8903\n", "\n", "\n", " yarn.log-aggregation-enable\n", " true\n", "\n", "\"\"\")\n" ], "metadata": { "id": "F9sxqwOZOWTl" }, "execution_count": 69, "outputs": [] }, { "cell_type": "markdown", "source": [ "It might be necessary at this point to re-start the cluster." ], "metadata": { "id": "5Nwameq-Ce3g" } }, { "cell_type": "code", "source": [ "process.kill()\n", "!pkill -f java # kill java processes" ], "metadata": { "id": "Yh-c5G_bCd6f" }, "execution_count": 70, "outputs": [] }, { "cell_type": "code", "source": [ "with open('out.txt', \"w\") as stdout_file, open('err.txt', \"w\") as stderr_file:\n", " process = subprocess.Popen(\n", " [\"mapred\", \"minicluster\", \"-format\", \"-jhsport\", \"8900\", \"-nnhttpport\", \"8901\", \"-nnport\", \"8902\", \"-rmport\", \"8903\"],\n", " stdout=stdout_file,\n", " stderr=stderr_file\n", " )" ], "metadata": { "id": "oNNl1MzDDd6D" }, "execution_count": 71, "outputs": [] }, { "cell_type": "markdown", "source": [ "Verify that the MiniCluster is running." ], "metadata": { "id": "w5pioEgpXw02" } }, { "cell_type": "code", "source": [ "for att in range(10):\n", " with open('err.txt') as myfile:\n", " if 'Started MiniMRCluster' in myfile.read():\n", " print('MiniCluster is up and running')\n", " break\n", " else:\n", " time.sleep(2)\n" ], "metadata": { "id": "CeOTCmbxdHpm", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "8e9bd4d1-8695-4527-96c7-7459c2ad801b" }, "execution_count": 72, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "MiniCluster is up and running\n" ] } ] }, { "cell_type": "code", "source": [ "!lsof -n -i -P +c0 -sTCP:LISTEN -ac java" ], "metadata": { "id": "ZPk1XrlgDHlI", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "fce7b461-99cd-4d90-e837-3089c52d7e6a" }, "execution_count": 73, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\n", "java 5488 root 341u IPv4 149683 0t0 TCP 127.0.0.1:8901 (LISTEN)\n", "java 5488 root 351u IPv4 148854 0t0 TCP 127.0.0.1:8902 (LISTEN)\n", "java 5488 root 361u IPv4 148862 0t0 TCP 127.0.0.1:36547 (LISTEN)\n", "java 5488 root 364u IPv4 148865 0t0 TCP 127.0.0.1:40385 (LISTEN)\n", "java 5488 root 393u IPv4 150500 0t0 TCP 127.0.0.1:42681 (LISTEN)\n", "java 5488 root 394u IPv4 148903 0t0 TCP 127.0.0.1:34431 (LISTEN)\n", "java 5488 root 420u IPv4 158000 0t0 TCP *:8031 (LISTEN)\n", "java 5488 root 434u IPv4 154506 0t0 TCP *:10033 (LISTEN)\n", "java 5488 root 444u IPv4 157946 0t0 TCP *:19888 (LISTEN)\n", "java 5488 root 446u IPv4 154605 0t0 TCP *:8088 (LISTEN)\n", "java 5488 root 454u IPv4 157989 0t0 TCP 127.0.0.1:8900 (LISTEN)\n", "java 5488 root 464u IPv4 157995 0t0 TCP *:8033 (LISTEN)\n", "java 5488 root 484u IPv4 158005 0t0 TCP *:8030 (LISTEN)\n", "java 5488 root 494u IPv4 158009 0t0 TCP 127.0.0.1:8903 (LISTEN)\n", "java 5488 root 504u IPv4 158797 0t0 TCP 127.0.0.1:34535 (LISTEN)\n", "java 5488 root 514u IPv4 158027 0t0 TCP 127.0.0.1:34217 (LISTEN)\n", "java 5488 root 524u IPv4 158801 0t0 TCP *:43847 (LISTEN)\n", "java 5488 root 525u IPv4 158031 0t0 TCP 127.0.0.1:37361 (LISTEN)\n" ] } ] }, { "cell_type": "markdown", "source": [ "Submit the app again. You should see at the very beginning of the output:\n", "\n", "```\n", "Connecting to ResourceManager at localhost/127.0.0.1:8903\n", "```\n", "\n", "This means that YARN has read its configuration file." ], "metadata": { "id": "tWIHDWeDFe14" } }, { "cell_type": "markdown", "source": [ "## Run the `pi` app on the MiniCluster with YARN" ], "metadata": { "id": "6wsQK9LlGWf-" } }, { "cell_type": "markdown", "source": [ "Let us run the job on the MiniCluster. \"Running\n", "\n" ], "metadata": { "id": "EP0_RTN1ZuhU" } }, { "cell_type": "code", "source": [ "!yarn jar ./hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar pi \\\n", " 5 1000" ], "metadata": { "id": "yjO0xISPFc_w", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "fa7be714-b6e8-47f1-af5e-2b802ec534d7" }, "execution_count": 74, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Number of Maps = 5\n", "Samples per Map = 1000\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "04-Aug-24 07:13:59 PM - INFO: t=2024-08-04T19:13:59+0000 lvl=info msg=\"join connections\" obj=join id=4944f91c91d7 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49611\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=b6557ad3937b l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49611\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=31c3ae28621f l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=5aa288b19d68 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=ec278b8a4015 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=c8a82bdeb45c l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=6732850300e3 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=a6678ebec0fb l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=88e97548a4a8 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=cd4c21a2f9be l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=a1f21ec754c8 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=524ebc6a8a13 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=01a4d73455a4 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=d2679b39ea53 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=0ac5e9002df7 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:00 PM - INFO: t=2024-08-04T19:14:00+0000 lvl=info msg=\"join connections\" obj=join id=4088f300f1b2 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:01 PM - INFO: t=2024-08-04T19:14:01+0000 lvl=info msg=\"join connections\" obj=join id=2c22c3282878 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:01 PM - INFO: t=2024-08-04T19:14:01+0000 lvl=info msg=\"join connections\" obj=join id=9b7da82d412c l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:01 PM - INFO: t=2024-08-04T19:14:01+0000 lvl=info msg=\"join connections\" obj=join id=9ad5e9b956c0 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:01 PM - INFO: t=2024-08-04T19:14:01+0000 lvl=info msg=\"join connections\" obj=join id=2aaca7c3ee6e l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:01 PM - INFO: t=2024-08-04T19:14:01+0000 lvl=info msg=\"join connections\" obj=join id=71230148c91d l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:01 PM - INFO: t=2024-08-04T19:14:01+0000 lvl=info msg=\"join connections\" obj=join id=fdd27abddc4c l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:01 PM - INFO: t=2024-08-04T19:14:01+0000 lvl=info msg=\"join connections\" obj=join id=dd6afb0f3192 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n", "04-Aug-24 07:14:01 PM - INFO: t=2024-08-04T19:14:01+0000 lvl=info msg=\"join connections\" obj=join id=d4821357ab57 l=127.0.0.1:8901 r=[2a02:8388:6cc5:e800:70ee:91e:4517:7eea]:49620\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "Wrote input for Map #0\n", "Wrote input for Map #1\n", "Wrote input for Map #2\n", "Wrote input for Map #3\n", "Wrote input for Map #4\n", "Starting Job\n", "2024-08-04 19:14:02,329 INFO client.DefaultNoHARMFailoverProxyProvider: Connecting to ResourceManager at localhost/127.0.0.1:8903\n", "2024-08-04 19:14:03,303 INFO mapreduce.JobResourceUploader: Disabling Erasure Coding for path: /tmp/hadoop-yarn/staging/root/.staging/job_1722798834650_0001\n", "2024-08-04 19:14:03,915 INFO input.FileInputFormat: Total input files to process : 5\n", "2024-08-04 19:14:04,481 INFO mapreduce.JobSubmitter: number of splits:5\n", "2024-08-04 19:14:05,484 INFO mapreduce.JobSubmitter: Submitting tokens for job: job_1722798834650_0001\n", "2024-08-04 19:14:05,485 INFO mapreduce.JobSubmitter: Executing with tokens: []\n", "2024-08-04 19:14:06,493 INFO conf.Configuration: resource-types.xml not found\n", "2024-08-04 19:14:06,503 INFO resource.ResourceUtils: Unable to find 'resource-types.xml'.\n", "2024-08-04 19:14:07,764 INFO impl.YarnClientImpl: Submitted application application_1722798834650_0001\n", "2024-08-04 19:14:07,940 INFO mapreduce.Job: The url to track the job: http://446a375b7fe4:8088/proxy/application_1722798834650_0001/\n", "2024-08-04 19:14:07,947 INFO mapreduce.Job: Running job: job_1722798834650_0001\n", "2024-08-04 19:14:21,800 INFO mapreduce.Job: Job job_1722798834650_0001 running in uber mode : false\n", "2024-08-04 19:14:21,802 INFO mapreduce.Job: map 0% reduce 0%\n", "2024-08-04 19:14:35,193 INFO mapreduce.Job: map 40% reduce 0%\n", "2024-08-04 19:14:47,348 INFO mapreduce.Job: map 80% reduce 0%\n", "2024-08-04 19:14:59,592 INFO mapreduce.Job: map 100% reduce 0%\n", "2024-08-04 19:15:00,604 INFO mapreduce.Job: map 100% reduce 100%\n", "2024-08-04 19:15:01,621 INFO mapreduce.Job: Job job_1722798834650_0001 completed successfully\n", "2024-08-04 19:15:01,756 INFO mapreduce.Job: Counters: 54\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=116\n", "\t\tFILE: Number of bytes written=1856793\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\t\tHDFS: Number of bytes read=1320\n", "\t\tHDFS: Number of bytes written=215\n", "\t\tHDFS: Number of read operations=25\n", "\t\tHDFS: Number of large read operations=0\n", "\t\tHDFS: Number of write operations=3\n", "\t\tHDFS: Number of bytes read erasure-coded=0\n", "\tJob Counters \n", "\t\tLaunched map tasks=5\n", "\t\tLaunched reduce tasks=1\n", "\t\tData-local map tasks=5\n", "\t\tTotal time spent by all maps in occupied slots (ms)=53665\n", "\t\tTotal time spent by all reduces in occupied slots (ms)=11104\n", "\t\tTotal time spent by all map tasks (ms)=53665\n", "\t\tTotal time spent by all reduce tasks (ms)=11104\n", "\t\tTotal vcore-milliseconds taken by all map tasks=53665\n", "\t\tTotal vcore-milliseconds taken by all reduce tasks=11104\n", "\t\tTotal megabyte-milliseconds taken by all map tasks=54952960\n", "\t\tTotal megabyte-milliseconds taken by all reduce tasks=11370496\n", "\tMap-Reduce Framework\n", "\t\tMap input records=5\n", "\t\tMap output records=10\n", "\t\tMap output bytes=90\n", "\t\tMap output materialized bytes=140\n", "\t\tInput split bytes=730\n", "\t\tCombine input records=0\n", "\t\tCombine output records=0\n", "\t\tReduce input groups=2\n", "\t\tReduce shuffle bytes=140\n", "\t\tReduce input records=10\n", "\t\tReduce output records=0\n", "\t\tSpilled Records=20\n", "\t\tShuffled Maps =5\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=5\n", "\t\tGC time elapsed (ms)=505\n", "\t\tCPU time spent (ms)=5570\n", "\t\tPhysical memory (bytes) snapshot=1933701120\n", "\t\tVirtual memory (bytes) snapshot=16332873728\n", "\t\tTotal committed heap usage (bytes)=1436549120\n", "\t\tPeak Map Physical memory (bytes)=383688704\n", "\t\tPeak Map Virtual memory (bytes)=2723983360\n", "\t\tPeak Reduce Physical memory (bytes)=217210880\n", "\t\tPeak Reduce Virtual memory (bytes)=2730729472\n", "\tShuffle Errors\n", "\t\tBAD_ID=0\n", "\t\tCONNECTION=0\n", "\t\tIO_ERROR=0\n", "\t\tWRONG_LENGTH=0\n", "\t\tWRONG_MAP=0\n", "\t\tWRONG_REDUCE=0\n", "\tFile Input Format Counters \n", "\t\tBytes Read=590\n", "\tFile Output Format Counters \n", "\t\tBytes Written=97\n", "Job Finished in 59.652 seconds\n", "Estimated value of Pi is 3.14160000000000000000\n" ] } ] }, { "cell_type": "markdown", "source": [ "We can now see the finished app listed in the YARN resource manager (note that this time we do not need to specify the Resource Manager's address with the option `-D yarn.resourcemanager.address=localhost:8903`)." ], "metadata": { "id": "H-qDAyhcQOCt" } }, { "cell_type": "code", "source": [ "!yarn application -list -appStates ALL" ], "metadata": { "id": "Ko_hoU7ZQTdD", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "0b4af40b-6baa-4926-8c67-12c0e44a78dd" }, "execution_count": 75, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "2024-08-04 19:15:05,035 INFO client.DefaultNoHARMFailoverProxyProvider: Connecting to ResourceManager at localhost/127.0.0.1:8903\n", "Total number of applications (application-types: [], states: [NEW, NEW_SAVING, SUBMITTED, ACCEPTED, RUNNING, FINISHED, FAILED, KILLED] and tags: []):1\n", " Application-Id\t Application-Name\t Application-Type\t User\t Queue\t State\t Final-State\t Progress\t Tracking-URL\n", "application_1722798834650_0001\t QuasiMonteCarlo\t MAPREDUCE\t root\troot.default\t FINISHED\t SUCCEEDED\t 100%\thttp://446a375b7fe4:19888/jobhistory/job/job_1722798834650_0001\n" ] } ] }, { "cell_type": "markdown", "source": [ "## Run the `pi` app in the background" ], "metadata": { "id": "KJ_DvxISR_ds" } }, { "cell_type": "markdown", "source": [ "Let us run the `pi` app in the background (as a subprocess) and with more mappers, so that it lasts longer and we are able to monitor its progress with the `yarn` command-line." ], "metadata": { "id": "hDgf97RkoP7O" } }, { "cell_type": "code", "source": [ "with open('job_out.txt', \"w\") as stdout_file, open('job_err.txt', \"w\") as stderr_file:\n", " process = subprocess.Popen(\n", " [\"yarn\", \"jar\", \"./hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar\", \"pi\",\n", " \"-D\", \"localhost:8903\",\n", " \"50\", \"1000000\"],\n", " stdout=stdout_file,\n", " stderr=stderr_file\n", " )" ], "metadata": { "id": "JPGCGVCcoPVh" }, "execution_count": 76, "outputs": [] }, { "cell_type": "code", "source": [ "time.sleep(10)" ], "metadata": { "id": "pYXRgDiRSOZS" }, "execution_count": 77, "outputs": [] }, { "cell_type": "code", "source": [ "!yarn application -list -appStates ALL" ], "metadata": { "id": "X-jC_BxS-rpY", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "f28e58bb-bb08-4433-9baf-ba024ca60229" }, "execution_count": 78, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "2024-08-04 19:15:21,096 INFO client.DefaultNoHARMFailoverProxyProvider: Connecting to ResourceManager at localhost/127.0.0.1:8903\n", "Total number of applications (application-types: [], states: [NEW, NEW_SAVING, SUBMITTED, ACCEPTED, RUNNING, FINISHED, FAILED, KILLED] and tags: []):2\n", " Application-Id\t Application-Name\t Application-Type\t User\t Queue\t State\t Final-State\t Progress\t Tracking-URL\n", "application_1722798834650_0001\t QuasiMonteCarlo\t MAPREDUCE\t root\troot.default\t FINISHED\t SUCCEEDED\t 100%\thttp://446a375b7fe4:19888/jobhistory/job/job_1722798834650_0001\n", "application_1722798834650_0002\t QuasiMonteCarlo\t MAPREDUCE\t root\troot.default\t ACCEPTED\t UNDEFINED\t 0%\t N/A\n" ] } ] }, { "cell_type": "markdown", "source": [ "If you do not see the newly submitted application in the YARN queue yet, give it some time and re-run the `yarn application -list` command! \"Running\n", "\n" ], "metadata": { "id": "lMbgNm_pSfF1" } }, { "cell_type": "code", "source": [ "!yarn application -list -appStates ALL" ], "metadata": { "id": "Da-sAM1NReSG", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "1ac61fd1-bb7a-4e1a-8284-0414d8458a78" }, "execution_count": 79, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "2024-08-04 19:15:28,650 INFO client.DefaultNoHARMFailoverProxyProvider: Connecting to ResourceManager at localhost/127.0.0.1:8903\n", "Total number of applications (application-types: [], states: [NEW, NEW_SAVING, SUBMITTED, ACCEPTED, RUNNING, FINISHED, FAILED, KILLED] and tags: []):2\n", " Application-Id\t Application-Name\t Application-Type\t User\t Queue\t State\t Final-State\t Progress\t Tracking-URL\n", "application_1722798834650_0001\t QuasiMonteCarlo\t MAPREDUCE\t root\troot.default\t FINISHED\t SUCCEEDED\t 100%\thttp://446a375b7fe4:19888/jobhistory/job/job_1722798834650_0001\n", "application_1722798834650_0002\t QuasiMonteCarlo\t MAPREDUCE\t root\troot.default\t ACCEPTED\t UNDEFINED\t 0%\t N/A\n" ] } ] }, { "cell_type": "markdown", "source": [ "You should now see something like this:\n", "```\n", "Total number of applications (application-types: [], states: [NEW, NEW_SAVING, SUBMITTED, ACCEPTED, RUNNING, FINISHED, FAILED, KILLED] and tags: []):2\n", " Application-Id\t Application-Name\t Application-Type\t User\t Queue\t State\t Final-State\t Progress\t Tracking-URL\n", "application_1707941943926_0001\t QuasiMonteCarlo\t MAPREDUCE\t root\t default\t FINISHED\t SUCCEEDED\t 100%\thttp://c532258dcee8:19888/jobhistory/job/job_1707941943926_0001\n", "application_1707941943926_0002\t QuasiMonteCarlo\t MAPREDUCE\t root\t default\t RUNNING\t UNDEFINED\t 5.18%\t http://localhost:43121\n", "```\n", "\n", "The application in status `RUNNING` is the most recently submitted." ], "metadata": { "id": "zIYhojkaSwdi" } }, { "cell_type": "markdown", "source": [ "# View the logs of an application" ], "metadata": { "id": "ACJng9ePTQct" } }, { "cell_type": "markdown", "source": [ "To view the logs of a finished application use:\n", "\n", "```\n", "yarn logs -applicationID \n", "```\n", "\n", "For the sake of this demo, we are going to pick the id if the first successfully finished app with the following shell command:" ], "metadata": { "id": "rydldlaISPUV" } }, { "cell_type": "code", "source": [ "!yarn application -list -appStates FINISHED 2>/dev/null|grep SUCCEEDED|tail -1| cut -f1" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "zF0cW5d3T3ec", "outputId": "8eea2a34-025c-4b35-ffdb-feb88376db28" }, "execution_count": 80, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "application_1722798834650_0001\n" ] } ] }, { "cell_type": "markdown", "source": [ "View the logs for the selected application id (warning: it's a large file!)." ], "metadata": { "id": "PI9GkpQnTzZZ" } }, { "cell_type": "code", "source": [ "%%bash\n", "app_id=$(yarn application -list -appStates FINISHED 2>/dev/null|grep SUCCEEDED|tail -1| cut -f1)\n", "yarn logs -applicationId $app_id" ], "metadata": { "id": "9r5WySeyS6cF", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "3d85bc9a-c112-4179-9cac-0fed36ca483a" }, "execution_count": 81, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Container: container_1722798834650_0001_01_000004 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:directory.info\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:2101\n", "LogContents:\n", "ls -l:\n", "total 32\n", "-rw-r--r-- 1 root root 129 Aug 4 19:14 container_tokens\n", "-rwx------ 1 root root 964 Aug 4 19:14 default_container_executor_session.sh\n", "-rwx------ 1 root root 1019 Aug 4 19:14 default_container_executor.sh\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.jar -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.xml -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\n", "-rwx------ 1 root root 8159 Aug 4 19:14 launch_container.sh\n", "drwx--x--- 2 root root 4096 Aug 4 19:14 tmp\n", "find -L . -maxdepth 5 -ls:\n", " 809807 4 drwx--x--- 3 root root 4096 Aug 4 19:14 .\n", " 809848 4 -rwx------ 1 root root 1019 Aug 4 19:14 ./default_container_executor.sh\n", " 809751 260 -r-x------ 1 root root 264361 Aug 4 19:14 ./job.xml\n", " 809822 4 -rw-r--r-- 1 root root 129 Aug 4 19:14 ./container_tokens\n", " 809841 4 -rwx------ 1 root root 964 Aug 4 19:14 ./default_container_executor_session.sh\n", " 809826 8 -rwx------ 1 root root 8159 Aug 4 19:14 ./launch_container.sh\n", " 809849 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor.sh.crc\n", " 809840 4 -rw-r--r-- 1 root root 72 Aug 4 19:14 ./.launch_container.sh.crc\n", " 809745 4 drwx------ 2 root root 4096 Aug 4 19:14 ./job.jar\n", " 809746 276 -r-x------ 1 root root 281609 Aug 4 19:14 ./job.jar/job.jar\n", " 809823 4 -rw-r--r-- 1 root root 12 Aug 4 19:14 ./.container_tokens.crc\n", " 809847 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor_session.sh.crc\n", " 809821 4 drwx--x--- 2 root root 4096 Aug 4 19:14 ./tmp\n", "broken symlinks(find -L . -maxdepth 5 -type l -ls):\n", "\n", "End of LogType:directory.info\n", "*******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000004 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:launch_container.sh\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:8159\n", "LogContents:\n", "#!/bin/bash\n", "\n", "set -o pipefail -e\n", "export PRELAUNCH_OUT=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/prelaunch.out\"\n", "exec >\"${PRELAUNCH_OUT}\"\n", "export PRELAUNCH_ERR=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/prelaunch.err\"\n", "exec 2>\"${PRELAUNCH_ERR}\"\n", "echo \"Setting up env variables\"\n", "export JAVA_HOME=${JAVA_HOME:-\"/usr/lib/jvm/java-11-openjdk-amd64\"}\n", "export HADOOP_COMMON_HOME=${HADOOP_COMMON_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HDFS_HOME=${HADOOP_HDFS_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_CONF_DIR=${HADOOP_CONF_DIR:-\"/content/hadoop-3.4.0/etc/hadoop\"}\n", "export HADOOP_YARN_HOME=${HADOOP_YARN_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HOME=${HADOOP_HOME:-\"/content/hadoop-3.4.0\"}\n", "export PATH=${PATH:-\"/content/hadoop-3.4.0/bin:/opt/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/tools/node/bin:/tools/google-cloud-sdk/bin\"}\n", "export LANG=${LANG:-\"en_US.UTF-8\"}\n", "export HADOOP_TOKEN_FILE_LOCATION=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000004/container_tokens\"\n", "export CONTAINER_ID=\"container_1722798834650_0001_01_000004\"\n", "export NM_PORT=\"34535\"\n", "export NM_HOST=\"localhost\"\n", "export NM_HTTP_PORT=\"37361\"\n", "export LOCAL_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\"\n", "export LOCAL_USER_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/\"\n", "export LOG_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000004,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000004,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000004,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004\"\n", "export USER=\"root\"\n", "export LOGNAME=\"root\"\n", "export HOME=\"/home/\"\n", "export PWD=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000004\"\n", "export LOCALIZATION_COUNTERS=\"0,548046,0,2,4\"\n", "export JVM_PID=\"$$\"\n", "export NM_AUX_SERVICE_mapreduce_shuffle=\"AACrRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n", "export STDOUT_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/stdout\"\n", "export SHELL=\"/bin/bash\"\n", "export HADOOP_ROOT_LOGGER=\"INFO,console\"\n", "export CLASSPATH=\"$PWD:$HADOOP_CONF_DIR:$HADOOP_COMMON_HOME/share/hadoop/common/*:$HADOOP_COMMON_HOME/share/hadoop/common/lib/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/lib/*:$HADOOP_YARN_HOME/share/hadoop/yarn/*:$HADOOP_YARN_HOME/share/hadoop/yarn/lib/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/*:job.jar/classes/:job.jar/lib/*:$PWD/*\"\n", "export LD_LIBRARY_PATH=\"$PWD:$HADOOP_COMMON_HOME/lib/native\"\n", "export STDERR_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/stderr\"\n", "export HADOOP_CLIENT_OPTS=\"\"\n", "export MALLOC_ARENA_MAX=\"4\"\n", "echo \"Setting up job resources\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\" \"job.xml\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\" \"job.jar\"\n", "echo \"Copying debugging information\"\n", "# Creating copy of launch script\n", "cp \"launch_container.sh\" \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/launch_container.sh\"\n", "chmod 640 \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/launch_container.sh\"\n", "# Determining directory contents\n", "echo \"ls -l:\" 1>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/directory.info\"\n", "ls -l 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/directory.info\"\n", "echo \"find -L . -maxdepth 5 -ls:\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/directory.info\"\n", "find -L . -maxdepth 5 -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/directory.info\"\n", "echo \"broken symlinks(find -L . -maxdepth 5 -type l -ls):\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/directory.info\"\n", "find -L . -maxdepth 5 -type l -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/directory.info\"\n", "echo \"Launching container\"\n", "exec /bin/bash -c \"$JAVA_HOME/bin/java -Djava.net.preferIPv4Stack=true -Dhadoop.metrics.log.level=WARN -Xmx820m -Djava.io.tmpdir=$PWD/tmp -Dlog4j.configuration=container-log4j.properties -Dyarn.app.container.log.dir=/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004 -Dyarn.app.container.log.filesize=0 -Dhadoop.root.logger=INFO,CLA -Dhadoop.root.logfile=syslog org.apache.hadoop.mapred.YarnChild 127.0.0.1 40041 attempt_1722798834650_0001_m_000002_0 4 1>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/stdout 2>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000004/stderr \"\n", "\n", "End of LogType:launch_container.sh\n", "************************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000004 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.err\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:prelaunch.err\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000004 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.out\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:100\n", "LogContents:\n", "Setting up env variables\n", "Setting up job resources\n", "Copying debugging information\n", "Launching container\n", "\n", "End of LogType:prelaunch.out\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000004 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stderr\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stderr\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000004 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stdout\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stdout\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000004 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:syslog\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:31510\n", "LogContents:\n", "2024-08-04 19:14:39,635 INFO [main] org.apache.hadoop.security.SecurityUtil: Updating Configuration\n", "2024-08-04 19:14:40,070 INFO [main] org.apache.hadoop.metrics2.impl.MetricsConfig: Loaded properties from hadoop-metrics2.properties\n", "2024-08-04 19:14:40,481 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Scheduled Metric snapshot period at 10 second(s).\n", "2024-08-04 19:14:40,481 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system started\n", "2024-08-04 19:14:40,778 INFO [main] org.apache.hadoop.mapred.YarnChild: Executing with tokens: [Kind: mapreduce.job, Service: job_1722798834650_0001, Ident: (org.apache.hadoop.mapreduce.security.token.JobTokenIdentifier@70f02c32)]\n", "2024-08-04 19:14:40,910 INFO [main] org.apache.hadoop.mapred.YarnChild: Sleeping for 0ms before retrying again. Got null now.\n", "2024-08-04 19:14:41,581 INFO [main] org.apache.hadoop.mapred.YarnChild: mapreduce.cluster.local.dir for child: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\n", "2024-08-04 19:14:43,074 INFO [main] org.apache.hadoop.mapred.YarnChild: \n", "/************************************************************\n", "[system properties]\n", "os.name: Linux\n", "os.version: 6.1.85+\n", "java.home: /usr/lib/jvm/java-11-openjdk-amd64\n", "java.runtime.version: 11.0.24+8-post-Ubuntu-1ubuntu322.04\n", "java.vendor: Ubuntu\n", "java.version: 11.0.24\n", "java.vm.name: OpenJDK 64-Bit Server VM\n", "java.class.path: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000004:/content/hadoop-3.4.0/etc/hadoop:/content/hadoop-3.4.0/share/hadoop/common/hadoop-kms-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsp-api-2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/bcprov-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-api-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-reload4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jul-to-slf4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-httpfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/json-simple-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/HikariCP-4.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/leveldbjni-all-1.8.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-mawo-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-resourcemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-web-proxy-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-router-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-timeline-pluginstorage-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-sharedcachemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-distributedshell-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-unmanaged-am-launcher-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-applicationhistoryservice-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-nodemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-globalpolicygenerator-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-tests-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jakarta.xml.bind-api-2.3.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-plus-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/objenesis-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-module-jaxb-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/protobuf-java-2.5.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.inject-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/swagger-annotations-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jna-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-client-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcpkix-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/snakeyaml-2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/commons-lang-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-servlet-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/mssql-jdbc-6.2.1.jre7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/aopalliance-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/codemodel-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/geronimo-jcache_1.0_spec-1.0-alpha-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-tree-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-api-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/ehcache-3.3.1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcutil-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/fst-2.50.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-client-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jsonschema2pojo-core-1.0.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-common-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-jndi-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-commons-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-server-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-guice-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-client-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-annotations-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-json-provider-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-base-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-uploader-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-shuffle-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/mockito-core-2.28.2.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-app-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-nativetask-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-plugins-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/job.jar:job.jar/classes/:job.jar/lib/*:/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000004/job.jar\n", "java.io.tmpdir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000004/tmp\n", "user.dir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000004\n", "user.name: root\n", "************************************************************/\n", "2024-08-04 19:14:43,083 INFO [main] org.apache.hadoop.conf.Configuration.deprecation: session.id is deprecated. Instead, use dfs.metrics.session-id\n", "2024-08-04 19:14:44,501 INFO [main] org.apache.hadoop.mapreduce.lib.output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:14:44,503 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:14:44,503 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:14:44,574 INFO [main] org.apache.hadoop.mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:14:45,146 INFO [main] org.apache.hadoop.mapred.MapTask: Processing split: hdfs://localhost:8902/user/root/QuasiMonteCarlo_1722798838891_1650860168/in/part2:0+118\n", "2024-08-04 19:14:45,350 INFO [main] org.apache.hadoop.mapred.MapTask: (EQUATOR) 0 kvi 26214396(104857584)\n", "2024-08-04 19:14:45,350 INFO [main] org.apache.hadoop.mapred.MapTask: mapreduce.task.io.sort.mb: 100\n", "2024-08-04 19:14:45,350 INFO [main] org.apache.hadoop.mapred.MapTask: soft limit at 83886080\n", "2024-08-04 19:14:45,350 INFO [main] org.apache.hadoop.mapred.MapTask: bufstart = 0; bufvoid = 104857600\n", "2024-08-04 19:14:45,350 INFO [main] org.apache.hadoop.mapred.MapTask: kvstart = 26214396; length = 6553600\n", "2024-08-04 19:14:45,390 INFO [main] org.apache.hadoop.mapred.MapTask: Map output collector class = org.apache.hadoop.mapred.MapTask$MapOutputBuffer\n", "2024-08-04 19:14:45,530 INFO [main] org.apache.hadoop.mapred.MapTask: Starting flush of map output\n", "2024-08-04 19:14:45,530 INFO [main] org.apache.hadoop.mapred.MapTask: Spilling map output\n", "2024-08-04 19:14:45,530 INFO [main] org.apache.hadoop.mapred.MapTask: bufstart = 0; bufend = 18; bufvoid = 104857600\n", "2024-08-04 19:14:45,530 INFO [main] org.apache.hadoop.mapred.MapTask: kvstart = 26214396(104857584); kvend = 26214392(104857568); length = 5/6553600\n", "2024-08-04 19:14:45,541 INFO [main] org.apache.hadoop.mapred.MapTask: Finished spill 0\n", "2024-08-04 19:14:45,602 INFO [main] org.apache.hadoop.mapred.Task: Task:attempt_1722798834650_0001_m_000002_0 is done. And is in the process of committing\n", "2024-08-04 19:14:45,640 INFO [main] org.apache.hadoop.mapred.Task: Task 'attempt_1722798834650_0001_m_000002_0' done.\n", "2024-08-04 19:14:45,661 INFO [main] org.apache.hadoop.mapred.Task: Final Counters for attempt_1722798834650_0001_m_000002_0: Counters: 28\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=0\n", "\t\tFILE: Number of bytes written=309460\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\t\tHDFS: Number of bytes read=264\n", "\t\tHDFS: Number of bytes written=0\n", "\t\tHDFS: Number of read operations=4\n", "\t\tHDFS: Number of large read operations=0\n", "\t\tHDFS: Number of write operations=0\n", "\t\tHDFS: Number of bytes read erasure-coded=0\n", "\tMap-Reduce Framework\n", "\t\tMap input records=1\n", "\t\tMap output records=2\n", "\t\tMap output bytes=18\n", "\t\tMap output materialized bytes=28\n", "\t\tInput split bytes=146\n", "\t\tCombine input records=0\n", "\t\tSpilled Records=2\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=0\n", "\t\tGC time elapsed (ms)=74\n", "\t\tCPU time spent (ms)=920\n", "\t\tPhysical memory (bytes) snapshot=327950336\n", "\t\tVirtual memory (bytes) snapshot=2719514624\n", "\t\tTotal committed heap usage (bytes)=216006656\n", "\t\tPeak Map Physical memory (bytes)=327950336\n", "\t\tPeak Map Virtual memory (bytes)=2719514624\n", "\tFile Input Format Counters \n", "\t\tBytes Read=118\n", "2024-08-04 19:14:45,663 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Stopping MapTask metrics system...\n", "2024-08-04 19:14:45,663 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system stopped.\n", "2024-08-04 19:14:45,664 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system shutdown complete.\n", "\n", "End of LogType:syslog\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000005 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:directory.info\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:2101\n", "LogContents:\n", "ls -l:\n", "total 32\n", "-rw-r--r-- 1 root root 129 Aug 4 19:14 container_tokens\n", "-rwx------ 1 root root 964 Aug 4 19:14 default_container_executor_session.sh\n", "-rwx------ 1 root root 1019 Aug 4 19:14 default_container_executor.sh\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.jar -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.xml -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\n", "-rwx------ 1 root root 8159 Aug 4 19:14 launch_container.sh\n", "drwx--x--- 2 root root 4096 Aug 4 19:14 tmp\n", "find -L . -maxdepth 5 -ls:\n", " 809830 4 drwx--x--- 3 root root 4096 Aug 4 19:14 .\n", " 809860 4 -rwx------ 1 root root 1019 Aug 4 19:14 ./default_container_executor.sh\n", " 809751 260 -r-x------ 1 root root 264361 Aug 4 19:14 ./job.xml\n", " 809845 4 -rw-r--r-- 1 root root 129 Aug 4 19:14 ./container_tokens\n", " 809857 4 -rwx------ 1 root root 964 Aug 4 19:14 ./default_container_executor_session.sh\n", " 809851 8 -rwx------ 1 root root 8159 Aug 4 19:14 ./launch_container.sh\n", " 809864 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor.sh.crc\n", " 809852 4 -rw-r--r-- 1 root root 72 Aug 4 19:14 ./.launch_container.sh.crc\n", " 809745 4 drwx------ 2 root root 4096 Aug 4 19:14 ./job.jar\n", " 809746 276 -r-x------ 1 root root 281609 Aug 4 19:14 ./job.jar/job.jar\n", " 809846 4 -rw-r--r-- 1 root root 12 Aug 4 19:14 ./.container_tokens.crc\n", " 809858 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor_session.sh.crc\n", " 809843 4 drwx--x--- 2 root root 4096 Aug 4 19:14 ./tmp\n", "broken symlinks(find -L . -maxdepth 5 -type l -ls):\n", "\n", "End of LogType:directory.info\n", "*******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000005 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:launch_container.sh\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:8159\n", "LogContents:\n", "#!/bin/bash\n", "\n", "set -o pipefail -e\n", "export PRELAUNCH_OUT=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/prelaunch.out\"\n", "exec >\"${PRELAUNCH_OUT}\"\n", "export PRELAUNCH_ERR=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/prelaunch.err\"\n", "exec 2>\"${PRELAUNCH_ERR}\"\n", "echo \"Setting up env variables\"\n", "export JAVA_HOME=${JAVA_HOME:-\"/usr/lib/jvm/java-11-openjdk-amd64\"}\n", "export HADOOP_COMMON_HOME=${HADOOP_COMMON_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HDFS_HOME=${HADOOP_HDFS_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_CONF_DIR=${HADOOP_CONF_DIR:-\"/content/hadoop-3.4.0/etc/hadoop\"}\n", "export HADOOP_YARN_HOME=${HADOOP_YARN_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HOME=${HADOOP_HOME:-\"/content/hadoop-3.4.0\"}\n", "export PATH=${PATH:-\"/content/hadoop-3.4.0/bin:/opt/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/tools/node/bin:/tools/google-cloud-sdk/bin\"}\n", "export LANG=${LANG:-\"en_US.UTF-8\"}\n", "export HADOOP_TOKEN_FILE_LOCATION=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000005/container_tokens\"\n", "export CONTAINER_ID=\"container_1722798834650_0001_01_000005\"\n", "export NM_PORT=\"34535\"\n", "export NM_HOST=\"localhost\"\n", "export NM_HTTP_PORT=\"37361\"\n", "export LOCAL_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\"\n", "export LOCAL_USER_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/\"\n", "export LOG_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000005,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000005,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000005,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005\"\n", "export USER=\"root\"\n", "export LOGNAME=\"root\"\n", "export HOME=\"/home/\"\n", "export PWD=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000005\"\n", "export LOCALIZATION_COUNTERS=\"0,548046,0,2,6\"\n", "export JVM_PID=\"$$\"\n", "export NM_AUX_SERVICE_mapreduce_shuffle=\"AACrRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n", "export STDOUT_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/stdout\"\n", "export SHELL=\"/bin/bash\"\n", "export HADOOP_ROOT_LOGGER=\"INFO,console\"\n", "export CLASSPATH=\"$PWD:$HADOOP_CONF_DIR:$HADOOP_COMMON_HOME/share/hadoop/common/*:$HADOOP_COMMON_HOME/share/hadoop/common/lib/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/lib/*:$HADOOP_YARN_HOME/share/hadoop/yarn/*:$HADOOP_YARN_HOME/share/hadoop/yarn/lib/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/*:job.jar/classes/:job.jar/lib/*:$PWD/*\"\n", "export LD_LIBRARY_PATH=\"$PWD:$HADOOP_COMMON_HOME/lib/native\"\n", "export STDERR_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/stderr\"\n", "export HADOOP_CLIENT_OPTS=\"\"\n", "export MALLOC_ARENA_MAX=\"4\"\n", "echo \"Setting up job resources\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\" \"job.xml\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\" \"job.jar\"\n", "echo \"Copying debugging information\"\n", "# Creating copy of launch script\n", "cp \"launch_container.sh\" \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/launch_container.sh\"\n", "chmod 640 \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/launch_container.sh\"\n", "# Determining directory contents\n", "echo \"ls -l:\" 1>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/directory.info\"\n", "ls -l 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/directory.info\"\n", "echo \"find -L . -maxdepth 5 -ls:\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/directory.info\"\n", "find -L . -maxdepth 5 -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/directory.info\"\n", "echo \"broken symlinks(find -L . -maxdepth 5 -type l -ls):\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/directory.info\"\n", "find -L . -maxdepth 5 -type l -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/directory.info\"\n", "echo \"Launching container\"\n", "exec /bin/bash -c \"$JAVA_HOME/bin/java -Djava.net.preferIPv4Stack=true -Dhadoop.metrics.log.level=WARN -Xmx820m -Djava.io.tmpdir=$PWD/tmp -Dlog4j.configuration=container-log4j.properties -Dyarn.app.container.log.dir=/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005 -Dyarn.app.container.log.filesize=0 -Dhadoop.root.logger=INFO,CLA -Dhadoop.root.logfile=syslog org.apache.hadoop.mapred.YarnChild 127.0.0.1 40041 attempt_1722798834650_0001_m_000003_0 5 1>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/stdout 2>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000005/stderr \"\n", "\n", "End of LogType:launch_container.sh\n", "************************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000005 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.err\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:prelaunch.err\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000005 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.out\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:100\n", "LogContents:\n", "Setting up env variables\n", "Setting up job resources\n", "Copying debugging information\n", "Launching container\n", "\n", "End of LogType:prelaunch.out\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000005 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stderr\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stderr\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000005 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stdout\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stdout\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000005 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:syslog\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:31510\n", "LogContents:\n", "2024-08-04 19:14:39,501 INFO [main] org.apache.hadoop.security.SecurityUtil: Updating Configuration\n", "2024-08-04 19:14:39,908 INFO [main] org.apache.hadoop.metrics2.impl.MetricsConfig: Loaded properties from hadoop-metrics2.properties\n", "2024-08-04 19:14:40,230 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Scheduled Metric snapshot period at 10 second(s).\n", "2024-08-04 19:14:40,230 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system started\n", "2024-08-04 19:14:40,517 INFO [main] org.apache.hadoop.mapred.YarnChild: Executing with tokens: [Kind: mapreduce.job, Service: job_1722798834650_0001, Ident: (org.apache.hadoop.mapreduce.security.token.JobTokenIdentifier@70f02c32)]\n", "2024-08-04 19:14:40,663 INFO [main] org.apache.hadoop.mapred.YarnChild: Sleeping for 0ms before retrying again. Got null now.\n", "2024-08-04 19:14:41,380 INFO [main] org.apache.hadoop.mapred.YarnChild: mapreduce.cluster.local.dir for child: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\n", "2024-08-04 19:14:42,874 INFO [main] org.apache.hadoop.mapred.YarnChild: \n", "/************************************************************\n", "[system properties]\n", "os.name: Linux\n", "os.version: 6.1.85+\n", "java.home: /usr/lib/jvm/java-11-openjdk-amd64\n", "java.runtime.version: 11.0.24+8-post-Ubuntu-1ubuntu322.04\n", "java.vendor: Ubuntu\n", "java.version: 11.0.24\n", "java.vm.name: OpenJDK 64-Bit Server VM\n", "java.class.path: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000005:/content/hadoop-3.4.0/etc/hadoop:/content/hadoop-3.4.0/share/hadoop/common/hadoop-kms-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsp-api-2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/bcprov-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-api-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-reload4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jul-to-slf4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-httpfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/json-simple-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/HikariCP-4.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/leveldbjni-all-1.8.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-mawo-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-resourcemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-web-proxy-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-router-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-timeline-pluginstorage-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-sharedcachemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-distributedshell-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-unmanaged-am-launcher-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-applicationhistoryservice-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-nodemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-globalpolicygenerator-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-tests-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jakarta.xml.bind-api-2.3.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-plus-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/objenesis-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-module-jaxb-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/protobuf-java-2.5.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.inject-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/swagger-annotations-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jna-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-client-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcpkix-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/snakeyaml-2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/commons-lang-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-servlet-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/mssql-jdbc-6.2.1.jre7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/aopalliance-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/codemodel-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/geronimo-jcache_1.0_spec-1.0-alpha-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-tree-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-api-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/ehcache-3.3.1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcutil-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/fst-2.50.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-client-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jsonschema2pojo-core-1.0.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-common-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-jndi-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-commons-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-server-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-guice-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-client-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-annotations-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-json-provider-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-base-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-uploader-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-shuffle-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/mockito-core-2.28.2.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-app-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-nativetask-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-plugins-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/job.jar:job.jar/classes/:job.jar/lib/*:/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000005/job.jar\n", "java.io.tmpdir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000005/tmp\n", "user.dir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000005\n", "user.name: root\n", "************************************************************/\n", "2024-08-04 19:14:42,875 INFO [main] org.apache.hadoop.conf.Configuration.deprecation: session.id is deprecated. Instead, use dfs.metrics.session-id\n", "2024-08-04 19:14:44,317 INFO [main] org.apache.hadoop.mapreduce.lib.output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:14:44,319 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:14:44,319 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:14:44,410 INFO [main] org.apache.hadoop.mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:14:45,042 INFO [main] org.apache.hadoop.mapred.MapTask: Processing split: hdfs://localhost:8902/user/root/QuasiMonteCarlo_1722798838891_1650860168/in/part3:0+118\n", "2024-08-04 19:14:45,245 INFO [main] org.apache.hadoop.mapred.MapTask: (EQUATOR) 0 kvi 26214396(104857584)\n", "2024-08-04 19:14:45,245 INFO [main] org.apache.hadoop.mapred.MapTask: mapreduce.task.io.sort.mb: 100\n", "2024-08-04 19:14:45,245 INFO [main] org.apache.hadoop.mapred.MapTask: soft limit at 83886080\n", "2024-08-04 19:14:45,245 INFO [main] org.apache.hadoop.mapred.MapTask: bufstart = 0; bufvoid = 104857600\n", "2024-08-04 19:14:45,245 INFO [main] org.apache.hadoop.mapred.MapTask: kvstart = 26214396; length = 6553600\n", "2024-08-04 19:14:45,261 INFO [main] org.apache.hadoop.mapred.MapTask: Map output collector class = org.apache.hadoop.mapred.MapTask$MapOutputBuffer\n", "2024-08-04 19:14:45,348 INFO [main] org.apache.hadoop.mapred.MapTask: Starting flush of map output\n", "2024-08-04 19:14:45,348 INFO [main] org.apache.hadoop.mapred.MapTask: Spilling map output\n", "2024-08-04 19:14:45,352 INFO [main] org.apache.hadoop.mapred.MapTask: bufstart = 0; bufend = 18; bufvoid = 104857600\n", "2024-08-04 19:14:45,352 INFO [main] org.apache.hadoop.mapred.MapTask: kvstart = 26214396(104857584); kvend = 26214392(104857568); length = 5/6553600\n", "2024-08-04 19:14:45,372 INFO [main] org.apache.hadoop.mapred.MapTask: Finished spill 0\n", "2024-08-04 19:14:45,441 INFO [main] org.apache.hadoop.mapred.Task: Task:attempt_1722798834650_0001_m_000003_0 is done. And is in the process of committing\n", "2024-08-04 19:14:45,493 INFO [main] org.apache.hadoop.mapred.Task: Task 'attempt_1722798834650_0001_m_000003_0' done.\n", "2024-08-04 19:14:45,517 INFO [main] org.apache.hadoop.mapred.Task: Final Counters for attempt_1722798834650_0001_m_000003_0: Counters: 28\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=0\n", "\t\tFILE: Number of bytes written=309460\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\t\tHDFS: Number of bytes read=264\n", "\t\tHDFS: Number of bytes written=0\n", "\t\tHDFS: Number of read operations=4\n", "\t\tHDFS: Number of large read operations=0\n", "\t\tHDFS: Number of write operations=0\n", "\t\tHDFS: Number of bytes read erasure-coded=0\n", "\tMap-Reduce Framework\n", "\t\tMap input records=1\n", "\t\tMap output records=2\n", "\t\tMap output bytes=18\n", "\t\tMap output materialized bytes=28\n", "\t\tInput split bytes=146\n", "\t\tCombine input records=0\n", "\t\tSpilled Records=2\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=0\n", "\t\tGC time elapsed (ms)=80\n", "\t\tCPU time spent (ms)=900\n", "\t\tPhysical memory (bytes) snapshot=311812096\n", "\t\tVirtual memory (bytes) snapshot=2722275328\n", "\t\tTotal committed heap usage (bytes)=216006656\n", "\t\tPeak Map Physical memory (bytes)=311812096\n", "\t\tPeak Map Virtual memory (bytes)=2722275328\n", "\tFile Input Format Counters \n", "\t\tBytes Read=118\n", "2024-08-04 19:14:45,519 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Stopping MapTask metrics system...\n", "2024-08-04 19:14:45,520 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system stopped.\n", "2024-08-04 19:14:45,520 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system shutdown complete.\n", "\n", "End of LogType:syslog\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000002 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:directory.info\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:2101\n", "LogContents:\n", "ls -l:\n", "total 32\n", "-rw-r--r-- 1 root root 129 Aug 4 19:14 container_tokens\n", "-rwx------ 1 root root 964 Aug 4 19:14 default_container_executor_session.sh\n", "-rwx------ 1 root root 1019 Aug 4 19:14 default_container_executor.sh\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.jar -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.xml -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\n", "-rwx------ 1 root root 8159 Aug 4 19:14 launch_container.sh\n", "drwx--x--- 2 root root 4096 Aug 4 19:14 tmp\n", "find -L . -maxdepth 5 -ls:\n", " 809832 4 drwx--x--- 3 root root 4096 Aug 4 19:14 .\n", " 809849 4 -rwx------ 1 root root 1019 Aug 4 19:14 ./default_container_executor.sh\n", " 809751 260 -r-x------ 1 root root 264361 Aug 4 19:14 ./job.xml\n", " 809840 4 -rw-r--r-- 1 root root 129 Aug 4 19:14 ./container_tokens\n", " 809847 4 -rwx------ 1 root root 964 Aug 4 19:14 ./default_container_executor_session.sh\n", " 809845 8 -rwx------ 1 root root 8159 Aug 4 19:14 ./launch_container.sh\n", " 809851 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor.sh.crc\n", " 809846 4 -rw-r--r-- 1 root root 72 Aug 4 19:14 ./.launch_container.sh.crc\n", " 809745 4 drwx------ 2 root root 4096 Aug 4 19:14 ./job.jar\n", " 809746 276 -r-x------ 1 root root 281609 Aug 4 19:14 ./job.jar/job.jar\n", " 809841 4 -rw-r--r-- 1 root root 12 Aug 4 19:14 ./.container_tokens.crc\n", " 809848 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor_session.sh.crc\n", " 809839 4 drwx--x--- 2 root root 4096 Aug 4 19:14 ./tmp\n", "broken symlinks(find -L . -maxdepth 5 -type l -ls):\n", "\n", "End of LogType:directory.info\n", "*******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000002 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:launch_container.sh\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:8159\n", "LogContents:\n", "#!/bin/bash\n", "\n", "set -o pipefail -e\n", "export PRELAUNCH_OUT=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/prelaunch.out\"\n", "exec >\"${PRELAUNCH_OUT}\"\n", "export PRELAUNCH_ERR=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/prelaunch.err\"\n", "exec 2>\"${PRELAUNCH_ERR}\"\n", "echo \"Setting up env variables\"\n", "export JAVA_HOME=${JAVA_HOME:-\"/usr/lib/jvm/java-11-openjdk-amd64\"}\n", "export HADOOP_COMMON_HOME=${HADOOP_COMMON_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HDFS_HOME=${HADOOP_HDFS_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_CONF_DIR=${HADOOP_CONF_DIR:-\"/content/hadoop-3.4.0/etc/hadoop\"}\n", "export HADOOP_YARN_HOME=${HADOOP_YARN_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HOME=${HADOOP_HOME:-\"/content/hadoop-3.4.0\"}\n", "export PATH=${PATH:-\"/content/hadoop-3.4.0/bin:/opt/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/tools/node/bin:/tools/google-cloud-sdk/bin\"}\n", "export LANG=${LANG:-\"en_US.UTF-8\"}\n", "export HADOOP_TOKEN_FILE_LOCATION=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000002/container_tokens\"\n", "export CONTAINER_ID=\"container_1722798834650_0001_01_000002\"\n", "export NM_PORT=\"34535\"\n", "export NM_HOST=\"localhost\"\n", "export NM_HTTP_PORT=\"37361\"\n", "export LOCAL_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\"\n", "export LOCAL_USER_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/\"\n", "export LOG_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000002,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000002,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000002\"\n", "export USER=\"root\"\n", "export LOGNAME=\"root\"\n", "export HOME=\"/home/\"\n", "export PWD=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000002\"\n", "export LOCALIZATION_COUNTERS=\"0,548046,0,2,5\"\n", "export JVM_PID=\"$$\"\n", "export NM_AUX_SERVICE_mapreduce_shuffle=\"AACrRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n", "export STDOUT_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/stdout\"\n", "export SHELL=\"/bin/bash\"\n", "export HADOOP_ROOT_LOGGER=\"INFO,console\"\n", "export CLASSPATH=\"$PWD:$HADOOP_CONF_DIR:$HADOOP_COMMON_HOME/share/hadoop/common/*:$HADOOP_COMMON_HOME/share/hadoop/common/lib/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/lib/*:$HADOOP_YARN_HOME/share/hadoop/yarn/*:$HADOOP_YARN_HOME/share/hadoop/yarn/lib/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/*:job.jar/classes/:job.jar/lib/*:$PWD/*\"\n", "export LD_LIBRARY_PATH=\"$PWD:$HADOOP_COMMON_HOME/lib/native\"\n", "export STDERR_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/stderr\"\n", "export HADOOP_CLIENT_OPTS=\"\"\n", "export MALLOC_ARENA_MAX=\"4\"\n", "echo \"Setting up job resources\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\" \"job.xml\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\" \"job.jar\"\n", "echo \"Copying debugging information\"\n", "# Creating copy of launch script\n", "cp \"launch_container.sh\" \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/launch_container.sh\"\n", "chmod 640 \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/launch_container.sh\"\n", "# Determining directory contents\n", "echo \"ls -l:\" 1>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/directory.info\"\n", "ls -l 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/directory.info\"\n", "echo \"find -L . -maxdepth 5 -ls:\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/directory.info\"\n", "find -L . -maxdepth 5 -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/directory.info\"\n", "echo \"broken symlinks(find -L . -maxdepth 5 -type l -ls):\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/directory.info\"\n", "find -L . -maxdepth 5 -type l -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/directory.info\"\n", "echo \"Launching container\"\n", "exec /bin/bash -c \"$JAVA_HOME/bin/java -Djava.net.preferIPv4Stack=true -Dhadoop.metrics.log.level=WARN -Xmx820m -Djava.io.tmpdir=$PWD/tmp -Dlog4j.configuration=container-log4j.properties -Dyarn.app.container.log.dir=/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002 -Dyarn.app.container.log.filesize=0 -Dhadoop.root.logger=INFO,CLA -Dhadoop.root.logfile=syslog org.apache.hadoop.mapred.YarnChild 127.0.0.1 40041 attempt_1722798834650_0001_m_000000_0 2 1>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/stdout 2>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000002/stderr \"\n", "\n", "End of LogType:launch_container.sh\n", "************************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000002 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.err\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:prelaunch.err\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000002 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.out\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:100\n", "LogContents:\n", "Setting up env variables\n", "Setting up job resources\n", "Copying debugging information\n", "Launching container\n", "\n", "End of LogType:prelaunch.out\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000002 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stderr\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stderr\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000002 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stdout\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stdout\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000002 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:syslog\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:31510\n", "LogContents:\n", "2024-08-04 19:14:26,405 INFO [main] org.apache.hadoop.security.SecurityUtil: Updating Configuration\n", "2024-08-04 19:14:26,656 INFO [main] org.apache.hadoop.metrics2.impl.MetricsConfig: Loaded properties from hadoop-metrics2.properties\n", "2024-08-04 19:14:27,095 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Scheduled Metric snapshot period at 10 second(s).\n", "2024-08-04 19:14:27,095 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system started\n", "2024-08-04 19:14:27,421 INFO [main] org.apache.hadoop.mapred.YarnChild: Executing with tokens: [Kind: mapreduce.job, Service: job_1722798834650_0001, Ident: (org.apache.hadoop.mapreduce.security.token.JobTokenIdentifier@70f02c32)]\n", "2024-08-04 19:14:27,614 INFO [main] org.apache.hadoop.mapred.YarnChild: Sleeping for 0ms before retrying again. Got null now.\n", "2024-08-04 19:14:28,578 INFO [main] org.apache.hadoop.mapred.YarnChild: mapreduce.cluster.local.dir for child: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\n", "2024-08-04 19:14:30,299 INFO [main] org.apache.hadoop.mapred.YarnChild: \n", "/************************************************************\n", "[system properties]\n", "os.name: Linux\n", "os.version: 6.1.85+\n", "java.home: /usr/lib/jvm/java-11-openjdk-amd64\n", "java.runtime.version: 11.0.24+8-post-Ubuntu-1ubuntu322.04\n", "java.vendor: Ubuntu\n", "java.version: 11.0.24\n", "java.vm.name: OpenJDK 64-Bit Server VM\n", "java.class.path: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000002:/content/hadoop-3.4.0/etc/hadoop:/content/hadoop-3.4.0/share/hadoop/common/hadoop-kms-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsp-api-2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/bcprov-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-api-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-reload4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jul-to-slf4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-httpfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/json-simple-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/HikariCP-4.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/leveldbjni-all-1.8.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-mawo-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-resourcemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-web-proxy-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-router-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-timeline-pluginstorage-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-sharedcachemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-distributedshell-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-unmanaged-am-launcher-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-applicationhistoryservice-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-nodemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-globalpolicygenerator-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-tests-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jakarta.xml.bind-api-2.3.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-plus-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/objenesis-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-module-jaxb-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/protobuf-java-2.5.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.inject-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/swagger-annotations-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jna-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-client-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcpkix-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/snakeyaml-2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/commons-lang-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-servlet-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/mssql-jdbc-6.2.1.jre7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/aopalliance-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/codemodel-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/geronimo-jcache_1.0_spec-1.0-alpha-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-tree-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-api-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/ehcache-3.3.1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcutil-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/fst-2.50.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-client-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jsonschema2pojo-core-1.0.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-common-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-jndi-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-commons-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-server-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-guice-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-client-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-annotations-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-json-provider-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-base-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-uploader-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-shuffle-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/mockito-core-2.28.2.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-app-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-nativetask-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-plugins-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/job.jar:job.jar/classes/:job.jar/lib/*:/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000002/job.jar\n", "java.io.tmpdir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000002/tmp\n", "user.dir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000002\n", "user.name: root\n", "************************************************************/\n", "2024-08-04 19:14:30,300 INFO [main] org.apache.hadoop.conf.Configuration.deprecation: session.id is deprecated. Instead, use dfs.metrics.session-id\n", "2024-08-04 19:14:31,952 INFO [main] org.apache.hadoop.mapreduce.lib.output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:14:31,957 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:14:31,958 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:14:32,045 INFO [main] org.apache.hadoop.mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:14:32,998 INFO [main] org.apache.hadoop.mapred.MapTask: Processing split: hdfs://localhost:8902/user/root/QuasiMonteCarlo_1722798838891_1650860168/in/part0:0+118\n", "2024-08-04 19:14:33,519 INFO [main] org.apache.hadoop.mapred.MapTask: (EQUATOR) 0 kvi 26214396(104857584)\n", "2024-08-04 19:14:33,520 INFO [main] org.apache.hadoop.mapred.MapTask: mapreduce.task.io.sort.mb: 100\n", "2024-08-04 19:14:33,520 INFO [main] org.apache.hadoop.mapred.MapTask: soft limit at 83886080\n", "2024-08-04 19:14:33,520 INFO [main] org.apache.hadoop.mapred.MapTask: bufstart = 0; bufvoid = 104857600\n", "2024-08-04 19:14:33,520 INFO [main] org.apache.hadoop.mapred.MapTask: kvstart = 26214396; length = 6553600\n", "2024-08-04 19:14:33,562 INFO [main] org.apache.hadoop.mapred.MapTask: Map output collector class = org.apache.hadoop.mapred.MapTask$MapOutputBuffer\n", "2024-08-04 19:14:33,974 INFO [main] org.apache.hadoop.mapred.MapTask: Starting flush of map output\n", "2024-08-04 19:14:33,974 INFO [main] org.apache.hadoop.mapred.MapTask: Spilling map output\n", "2024-08-04 19:14:33,974 INFO [main] org.apache.hadoop.mapred.MapTask: bufstart = 0; bufend = 18; bufvoid = 104857600\n", "2024-08-04 19:14:33,974 INFO [main] org.apache.hadoop.mapred.MapTask: kvstart = 26214396(104857584); kvend = 26214392(104857568); length = 5/6553600\n", "2024-08-04 19:14:34,008 INFO [main] org.apache.hadoop.mapred.MapTask: Finished spill 0\n", "2024-08-04 19:14:34,066 INFO [main] org.apache.hadoop.mapred.Task: Task:attempt_1722798834650_0001_m_000000_0 is done. And is in the process of committing\n", "2024-08-04 19:14:34,129 INFO [main] org.apache.hadoop.mapred.Task: Task 'attempt_1722798834650_0001_m_000000_0' done.\n", "2024-08-04 19:14:34,161 INFO [main] org.apache.hadoop.mapred.Task: Final Counters for attempt_1722798834650_0001_m_000000_0: Counters: 28\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=0\n", "\t\tFILE: Number of bytes written=309460\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\t\tHDFS: Number of bytes read=264\n", "\t\tHDFS: Number of bytes written=0\n", "\t\tHDFS: Number of read operations=4\n", "\t\tHDFS: Number of large read operations=0\n", "\t\tHDFS: Number of write operations=0\n", "\t\tHDFS: Number of bytes read erasure-coded=0\n", "\tMap-Reduce Framework\n", "\t\tMap input records=1\n", "\t\tMap output records=2\n", "\t\tMap output bytes=18\n", "\t\tMap output materialized bytes=28\n", "\t\tInput split bytes=146\n", "\t\tCombine input records=0\n", "\t\tSpilled Records=2\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=0\n", "\t\tGC time elapsed (ms)=88\n", "\t\tCPU time spent (ms)=880\n", "\t\tPhysical memory (bytes) snapshot=331776000\n", "\t\tVirtual memory (bytes) snapshot=2719916032\n", "\t\tTotal committed heap usage (bytes)=216006656\n", "\t\tPeak Map Physical memory (bytes)=331776000\n", "\t\tPeak Map Virtual memory (bytes)=2719916032\n", "\tFile Input Format Counters \n", "\t\tBytes Read=118\n", "2024-08-04 19:14:34,163 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Stopping MapTask metrics system...\n", "2024-08-04 19:14:34,164 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system stopped.\n", "2024-08-04 19:14:34,164 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system shutdown complete.\n", "\n", "End of LogType:syslog\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000003 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:directory.info\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:2101\n", "LogContents:\n", "ls -l:\n", "total 32\n", "-rw-r--r-- 1 root root 129 Aug 4 19:14 container_tokens\n", "-rwx------ 1 root root 964 Aug 4 19:14 default_container_executor_session.sh\n", "-rwx------ 1 root root 1019 Aug 4 19:14 default_container_executor.sh\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.jar -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.xml -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\n", "-rwx------ 1 root root 8160 Aug 4 19:14 launch_container.sh\n", "drwx--x--- 2 root root 4096 Aug 4 19:14 tmp\n", "find -L . -maxdepth 5 -ls:\n", " 809809 4 drwx--x--- 3 root root 4096 Aug 4 19:14 .\n", " 809824 4 -rwx------ 1 root root 1019 Aug 4 19:14 ./default_container_executor.sh\n", " 809751 260 -r-x------ 1 root root 264361 Aug 4 19:14 ./job.xml\n", " 809816 4 -rw-r--r-- 1 root root 129 Aug 4 19:14 ./container_tokens\n", " 809822 4 -rwx------ 1 root root 964 Aug 4 19:14 ./default_container_executor_session.sh\n", " 809820 8 -rwx------ 1 root root 8160 Aug 4 19:14 ./launch_container.sh\n", " 809825 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor.sh.crc\n", " 809821 4 -rw-r--r-- 1 root root 72 Aug 4 19:14 ./.launch_container.sh.crc\n", " 809745 4 drwx------ 2 root root 4096 Aug 4 19:14 ./job.jar\n", " 809746 276 -r-x------ 1 root root 281609 Aug 4 19:14 ./job.jar/job.jar\n", " 809817 4 -rw-r--r-- 1 root root 12 Aug 4 19:14 ./.container_tokens.crc\n", " 809823 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor_session.sh.crc\n", " 809815 4 drwx--x--- 2 root root 4096 Aug 4 19:14 ./tmp\n", "broken symlinks(find -L . -maxdepth 5 -type l -ls):\n", "\n", "End of LogType:directory.info\n", "*******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000003 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:launch_container.sh\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:8160\n", "LogContents:\n", "#!/bin/bash\n", "\n", "set -o pipefail -e\n", "export PRELAUNCH_OUT=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/prelaunch.out\"\n", "exec >\"${PRELAUNCH_OUT}\"\n", "export PRELAUNCH_ERR=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/prelaunch.err\"\n", "exec 2>\"${PRELAUNCH_ERR}\"\n", "echo \"Setting up env variables\"\n", "export JAVA_HOME=${JAVA_HOME:-\"/usr/lib/jvm/java-11-openjdk-amd64\"}\n", "export HADOOP_COMMON_HOME=${HADOOP_COMMON_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HDFS_HOME=${HADOOP_HDFS_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_CONF_DIR=${HADOOP_CONF_DIR:-\"/content/hadoop-3.4.0/etc/hadoop\"}\n", "export HADOOP_YARN_HOME=${HADOOP_YARN_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HOME=${HADOOP_HOME:-\"/content/hadoop-3.4.0\"}\n", "export PATH=${PATH:-\"/content/hadoop-3.4.0/bin:/opt/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/tools/node/bin:/tools/google-cloud-sdk/bin\"}\n", "export LANG=${LANG:-\"en_US.UTF-8\"}\n", "export HADOOP_TOKEN_FILE_LOCATION=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000003/container_tokens\"\n", "export CONTAINER_ID=\"container_1722798834650_0001_01_000003\"\n", "export NM_PORT=\"34535\"\n", "export NM_HOST=\"localhost\"\n", "export NM_HTTP_PORT=\"37361\"\n", "export LOCAL_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\"\n", "export LOCAL_USER_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/\"\n", "export LOG_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000003,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000003,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000003\"\n", "export USER=\"root\"\n", "export LOGNAME=\"root\"\n", "export HOME=\"/home/\"\n", "export PWD=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000003\"\n", "export LOCALIZATION_COUNTERS=\"0,548046,0,2,26\"\n", "export JVM_PID=\"$$\"\n", "export NM_AUX_SERVICE_mapreduce_shuffle=\"AACrRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n", "export STDOUT_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/stdout\"\n", "export SHELL=\"/bin/bash\"\n", "export HADOOP_ROOT_LOGGER=\"INFO,console\"\n", "export CLASSPATH=\"$PWD:$HADOOP_CONF_DIR:$HADOOP_COMMON_HOME/share/hadoop/common/*:$HADOOP_COMMON_HOME/share/hadoop/common/lib/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/lib/*:$HADOOP_YARN_HOME/share/hadoop/yarn/*:$HADOOP_YARN_HOME/share/hadoop/yarn/lib/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/*:job.jar/classes/:job.jar/lib/*:$PWD/*\"\n", "export LD_LIBRARY_PATH=\"$PWD:$HADOOP_COMMON_HOME/lib/native\"\n", "export STDERR_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/stderr\"\n", "export HADOOP_CLIENT_OPTS=\"\"\n", "export MALLOC_ARENA_MAX=\"4\"\n", "echo \"Setting up job resources\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\" \"job.xml\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\" \"job.jar\"\n", "echo \"Copying debugging information\"\n", "# Creating copy of launch script\n", "cp \"launch_container.sh\" \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/launch_container.sh\"\n", "chmod 640 \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/launch_container.sh\"\n", "# Determining directory contents\n", "echo \"ls -l:\" 1>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/directory.info\"\n", "ls -l 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/directory.info\"\n", "echo \"find -L . -maxdepth 5 -ls:\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/directory.info\"\n", "find -L . -maxdepth 5 -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/directory.info\"\n", "echo \"broken symlinks(find -L . -maxdepth 5 -type l -ls):\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/directory.info\"\n", "find -L . -maxdepth 5 -type l -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/directory.info\"\n", "echo \"Launching container\"\n", "exec /bin/bash -c \"$JAVA_HOME/bin/java -Djava.net.preferIPv4Stack=true -Dhadoop.metrics.log.level=WARN -Xmx820m -Djava.io.tmpdir=$PWD/tmp -Dlog4j.configuration=container-log4j.properties -Dyarn.app.container.log.dir=/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003 -Dyarn.app.container.log.filesize=0 -Dhadoop.root.logger=INFO,CLA -Dhadoop.root.logfile=syslog org.apache.hadoop.mapred.YarnChild 127.0.0.1 40041 attempt_1722798834650_0001_m_000001_0 3 1>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/stdout 2>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000003/stderr \"\n", "\n", "End of LogType:launch_container.sh\n", "************************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000003 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.err\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:prelaunch.err\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000003 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.out\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:100\n", "LogContents:\n", "Setting up env variables\n", "Setting up job resources\n", "Copying debugging information\n", "Launching container\n", "\n", "End of LogType:prelaunch.out\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000003 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stderr\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stderr\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000003 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stdout\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stdout\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000003 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:syslog\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:31510\n", "LogContents:\n", "2024-08-04 19:14:26,096 INFO [main] org.apache.hadoop.security.SecurityUtil: Updating Configuration\n", "2024-08-04 19:14:26,500 INFO [main] org.apache.hadoop.metrics2.impl.MetricsConfig: Loaded properties from hadoop-metrics2.properties\n", "2024-08-04 19:14:26,997 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Scheduled Metric snapshot period at 10 second(s).\n", "2024-08-04 19:14:26,998 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system started\n", "2024-08-04 19:14:27,330 INFO [main] org.apache.hadoop.mapred.YarnChild: Executing with tokens: [Kind: mapreduce.job, Service: job_1722798834650_0001, Ident: (org.apache.hadoop.mapreduce.security.token.JobTokenIdentifier@1fa1cab1)]\n", "2024-08-04 19:14:27,429 INFO [main] org.apache.hadoop.mapred.YarnChild: Sleeping for 0ms before retrying again. Got null now.\n", "2024-08-04 19:14:28,423 INFO [main] org.apache.hadoop.mapred.YarnChild: mapreduce.cluster.local.dir for child: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\n", "2024-08-04 19:14:30,060 INFO [main] org.apache.hadoop.mapred.YarnChild: \n", "/************************************************************\n", "[system properties]\n", "os.name: Linux\n", "os.version: 6.1.85+\n", "java.home: /usr/lib/jvm/java-11-openjdk-amd64\n", "java.runtime.version: 11.0.24+8-post-Ubuntu-1ubuntu322.04\n", "java.vendor: Ubuntu\n", "java.version: 11.0.24\n", "java.vm.name: OpenJDK 64-Bit Server VM\n", "java.class.path: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000003:/content/hadoop-3.4.0/etc/hadoop:/content/hadoop-3.4.0/share/hadoop/common/hadoop-kms-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsp-api-2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/bcprov-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-api-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-reload4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jul-to-slf4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-httpfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/json-simple-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/HikariCP-4.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/leveldbjni-all-1.8.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-mawo-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-resourcemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-web-proxy-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-router-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-timeline-pluginstorage-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-sharedcachemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-distributedshell-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-unmanaged-am-launcher-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-applicationhistoryservice-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-nodemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-globalpolicygenerator-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-tests-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jakarta.xml.bind-api-2.3.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-plus-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/objenesis-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-module-jaxb-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/protobuf-java-2.5.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.inject-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/swagger-annotations-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jna-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-client-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcpkix-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/snakeyaml-2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/commons-lang-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-servlet-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/mssql-jdbc-6.2.1.jre7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/aopalliance-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/codemodel-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/geronimo-jcache_1.0_spec-1.0-alpha-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-tree-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-api-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/ehcache-3.3.1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcutil-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/fst-2.50.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-client-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jsonschema2pojo-core-1.0.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-common-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-jndi-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-commons-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-server-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-guice-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-client-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-annotations-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-json-provider-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-base-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-uploader-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-shuffle-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/mockito-core-2.28.2.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-app-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-nativetask-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-plugins-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/job.jar:job.jar/classes/:job.jar/lib/*:/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000003/job.jar\n", "java.io.tmpdir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000003/tmp\n", "user.dir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000003\n", "user.name: root\n", "************************************************************/\n", "2024-08-04 19:14:30,111 INFO [main] org.apache.hadoop.conf.Configuration.deprecation: session.id is deprecated. Instead, use dfs.metrics.session-id\n", "2024-08-04 19:14:31,735 INFO [main] org.apache.hadoop.mapreduce.lib.output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:14:31,737 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:14:31,737 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:14:31,857 INFO [main] org.apache.hadoop.mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:14:32,725 INFO [main] org.apache.hadoop.mapred.MapTask: Processing split: hdfs://localhost:8902/user/root/QuasiMonteCarlo_1722798838891_1650860168/in/part1:0+118\n", "2024-08-04 19:14:33,224 INFO [main] org.apache.hadoop.mapred.MapTask: (EQUATOR) 0 kvi 26214396(104857584)\n", "2024-08-04 19:14:33,225 INFO [main] org.apache.hadoop.mapred.MapTask: mapreduce.task.io.sort.mb: 100\n", "2024-08-04 19:14:33,225 INFO [main] org.apache.hadoop.mapred.MapTask: soft limit at 83886080\n", "2024-08-04 19:14:33,225 INFO [main] org.apache.hadoop.mapred.MapTask: bufstart = 0; bufvoid = 104857600\n", "2024-08-04 19:14:33,225 INFO [main] org.apache.hadoop.mapred.MapTask: kvstart = 26214396; length = 6553600\n", "2024-08-04 19:14:33,266 INFO [main] org.apache.hadoop.mapred.MapTask: Map output collector class = org.apache.hadoop.mapred.MapTask$MapOutputBuffer\n", "2024-08-04 19:14:33,436 INFO [main] org.apache.hadoop.mapred.MapTask: Starting flush of map output\n", "2024-08-04 19:14:33,436 INFO [main] org.apache.hadoop.mapred.MapTask: Spilling map output\n", "2024-08-04 19:14:33,436 INFO [main] org.apache.hadoop.mapred.MapTask: bufstart = 0; bufend = 18; bufvoid = 104857600\n", "2024-08-04 19:14:33,436 INFO [main] org.apache.hadoop.mapred.MapTask: kvstart = 26214396(104857584); kvend = 26214392(104857568); length = 5/6553600\n", "2024-08-04 19:14:33,459 INFO [main] org.apache.hadoop.mapred.MapTask: Finished spill 0\n", "2024-08-04 19:14:33,555 INFO [main] org.apache.hadoop.mapred.Task: Task:attempt_1722798834650_0001_m_000001_0 is done. And is in the process of committing\n", "2024-08-04 19:14:33,652 INFO [main] org.apache.hadoop.mapred.Task: Task 'attempt_1722798834650_0001_m_000001_0' done.\n", "2024-08-04 19:14:33,767 INFO [main] org.apache.hadoop.mapred.Task: Final Counters for attempt_1722798834650_0001_m_000001_0: Counters: 28\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=0\n", "\t\tFILE: Number of bytes written=309460\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\t\tHDFS: Number of bytes read=264\n", "\t\tHDFS: Number of bytes written=0\n", "\t\tHDFS: Number of read operations=4\n", "\t\tHDFS: Number of large read operations=0\n", "\t\tHDFS: Number of write operations=0\n", "\t\tHDFS: Number of bytes read erasure-coded=0\n", "\tMap-Reduce Framework\n", "\t\tMap input records=1\n", "\t\tMap output records=2\n", "\t\tMap output bytes=18\n", "\t\tMap output materialized bytes=28\n", "\t\tInput split bytes=146\n", "\t\tCombine input records=0\n", "\t\tSpilled Records=2\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=0\n", "\t\tGC time elapsed (ms)=80\n", "\t\tCPU time spent (ms)=980\n", "\t\tPhysical memory (bytes) snapshot=383688704\n", "\t\tVirtual memory (bytes) snapshot=2723983360\n", "\t\tTotal committed heap usage (bytes)=298844160\n", "\t\tPeak Map Physical memory (bytes)=383688704\n", "\t\tPeak Map Virtual memory (bytes)=2723983360\n", "\tFile Input Format Counters \n", "\t\tBytes Read=118\n", "2024-08-04 19:14:33,771 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Stopping MapTask metrics system...\n", "2024-08-04 19:14:33,771 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system stopped.\n", "2024-08-04 19:14:33,772 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system shutdown complete.\n", "\n", "End of LogType:syslog\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000001 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:directory.info\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:2444\n", "LogContents:\n", "ls -l:\n", "total 36\n", "-rw-r--r-- 1 root root 105 Aug 4 19:14 container_tokens\n", "-rwx------ 1 root root 964 Aug 4 19:14 default_container_executor_session.sh\n", "-rwx------ 1 root root 1019 Aug 4 19:14 default_container_executor.sh\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.jar -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\n", "drwxr-xr-x 2 root root 4096 Aug 4 19:14 jobSubmitDir\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.xml -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\n", "-rwx------ 1 root root 8184 Aug 4 19:14 launch_container.sh\n", "drwx--x--- 2 root root 4096 Aug 4 19:14 tmp\n", "find -L . -maxdepth 5 -ls:\n", " 809763 4 drwx--x--- 4 root root 4096 Aug 4 19:14 .\n", " 809778 4 -rwx------ 1 root root 1019 Aug 4 19:14 ./default_container_executor.sh\n", " 809751 260 -r-x------ 1 root root 264361 Aug 4 19:14 ./job.xml\n", " 809772 4 -rw-r--r-- 1 root root 105 Aug 4 19:14 ./container_tokens\n", " 809776 4 -rwx------ 1 root root 964 Aug 4 19:14 ./default_container_executor_session.sh\n", " 809774 8 -rwx------ 1 root root 8184 Aug 4 19:14 ./launch_container.sh\n", " 809779 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor.sh.crc\n", " 809775 4 -rw-r--r-- 1 root root 72 Aug 4 19:14 ./.launch_container.sh.crc\n", " 809745 4 drwx------ 2 root root 4096 Aug 4 19:14 ./job.jar\n", " 809746 276 -r-x------ 1 root root 281609 Aug 4 19:14 ./job.jar/job.jar\n", " 809773 4 -rw-r--r-- 1 root root 12 Aug 4 19:14 ./.container_tokens.crc\n", " 809784 4 drwxr-xr-x 2 root root 4096 Aug 4 19:14 ./jobSubmitDir\n", " 809748 4 -r-x------ 1 root root 737 Aug 4 19:14 ./jobSubmitDir/job.split\n", " 809738 4 -r-x------ 1 root root 82 Aug 4 19:14 ./jobSubmitDir/job.splitmetainfo\n", " 809777 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor_session.sh.crc\n", " 809771 4 drwx--x--- 2 root root 4096 Aug 4 19:14 ./tmp\n", "broken symlinks(find -L . -maxdepth 5 -type l -ls):\n", "\n", "End of LogType:directory.info\n", "*******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000001 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:launch_container.sh\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:8184\n", "LogContents:\n", "#!/bin/bash\n", "\n", "set -o pipefail -e\n", "export PRELAUNCH_OUT=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/prelaunch.out\"\n", "exec >\"${PRELAUNCH_OUT}\"\n", "export PRELAUNCH_ERR=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/prelaunch.err\"\n", "exec 2>\"${PRELAUNCH_ERR}\"\n", "echo \"Setting up env variables\"\n", "export JAVA_HOME=${JAVA_HOME:-\"/usr/lib/jvm/java-11-openjdk-amd64\"}\n", "export HADOOP_COMMON_HOME=${HADOOP_COMMON_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HDFS_HOME=${HADOOP_HDFS_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_CONF_DIR=${HADOOP_CONF_DIR:-\"/content/hadoop-3.4.0/etc/hadoop\"}\n", "export HADOOP_YARN_HOME=${HADOOP_YARN_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HOME=${HADOOP_HOME:-\"/content/hadoop-3.4.0\"}\n", "export PATH=${PATH:-\"/content/hadoop-3.4.0/bin:/opt/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/tools/node/bin:/tools/google-cloud-sdk/bin\"}\n", "export LANG=${LANG:-\"en_US.UTF-8\"}\n", "export HADOOP_TOKEN_FILE_LOCATION=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000001/container_tokens\"\n", "export CONTAINER_ID=\"container_1722798834650_0001_01_000001\"\n", "export NM_PORT=\"34535\"\n", "export NM_HOST=\"localhost\"\n", "export NM_HTTP_PORT=\"37361\"\n", "export LOCAL_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\"\n", "export LOCAL_USER_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/\"\n", "export LOG_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000001\"\n", "export USER=\"root\"\n", "export LOGNAME=\"root\"\n", "export HOME=\"/home/\"\n", "export PWD=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000001\"\n", "export LOCALIZATION_COUNTERS=\"548893,0,4,0,818\"\n", "export JVM_PID=\"$$\"\n", "export NM_AUX_SERVICE_mapreduce_shuffle=\"AACrRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n", "export APPLICATION_WEB_PROXY_BASE=\"/proxy/application_1722798834650_0001\"\n", "export SHELL=\"/bin/bash\"\n", "export CLASSPATH=\"$PWD:$HADOOP_CONF_DIR:$HADOOP_COMMON_HOME/share/hadoop/common/*:$HADOOP_COMMON_HOME/share/hadoop/common/lib/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/lib/*:$HADOOP_YARN_HOME/share/hadoop/yarn/*:$HADOOP_YARN_HOME/share/hadoop/yarn/lib/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/*:job.jar/classes/:job.jar/lib/*:$PWD/*\"\n", "export APP_SUBMIT_TIME_ENV=\"1722798847160\"\n", "export LD_LIBRARY_PATH=\"$PWD:$HADOOP_COMMON_HOME/lib/native\"\n", "export MALLOC_ARENA_MAX=\"4\"\n", "echo \"Setting up job resources\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\" \"job.xml\"\n", "mkdir -p jobSubmitDir\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001/filecache/12/job.split\" \"jobSubmitDir/job.split\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\" \"job.jar\"\n", "mkdir -p jobSubmitDir\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/filecache/10/job.splitmetainfo\" \"jobSubmitDir/job.splitmetainfo\"\n", "echo \"Copying debugging information\"\n", "# Creating copy of launch script\n", "cp \"launch_container.sh\" \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/launch_container.sh\"\n", "chmod 640 \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/launch_container.sh\"\n", "# Determining directory contents\n", "echo \"ls -l:\" 1>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/directory.info\"\n", "ls -l 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/directory.info\"\n", "echo \"find -L . -maxdepth 5 -ls:\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/directory.info\"\n", "find -L . -maxdepth 5 -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/directory.info\"\n", "echo \"broken symlinks(find -L . -maxdepth 5 -type l -ls):\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/directory.info\"\n", "find -L . -maxdepth 5 -type l -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/directory.info\"\n", "echo \"Launching container\"\n", "exec /bin/bash -c \"$JAVA_HOME/bin/java -Djava.io.tmpdir=$PWD/tmp -Dlog4j.configuration=container-log4j.properties -Dyarn.app.container.log.dir=/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001 -Dyarn.app.container.log.filesize=0 -Dhadoop.root.logger=INFO,CLA -Dhadoop.root.logfile=syslog -Xmx1024m org.apache.hadoop.mapreduce.v2.app.MRAppMaster 1>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/stdout 2>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000001/stderr \"\n", "\n", "End of LogType:launch_container.sh\n", "************************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000001 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.err\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:prelaunch.err\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000001 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.out\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:100\n", "LogContents:\n", "Setting up env variables\n", "Setting up job resources\n", "Copying debugging information\n", "Launching container\n", "\n", "End of LogType:prelaunch.out\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000001 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stderr\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:2344\n", "LogContents:\n", "WARNING: An illegal reflective access operation has occurred\n", "WARNING: Illegal reflective access by com.google.inject.internal.cglib.core.$ReflectUtils$1 (file:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-4.2.3.jar) to method java.lang.ClassLoader.defineClass(java.lang.String,byte[],int,int,java.security.ProtectionDomain)\n", "WARNING: Please consider reporting this to the maintainers of com.google.inject.internal.cglib.core.$ReflectUtils$1\n", "WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations\n", "WARNING: All illegal access operations will be denied in a future release\n", "Aug 04, 2024 7:14:17 PM com.sun.jersey.guice.spi.container.GuiceComponentProviderFactory register\n", "INFO: Registering org.apache.hadoop.mapreduce.v2.app.webapp.JAXBContextResolver as a provider class\n", "Aug 04, 2024 7:14:17 PM com.sun.jersey.guice.spi.container.GuiceComponentProviderFactory register\n", "INFO: Registering org.apache.hadoop.yarn.webapp.GenericExceptionHandler as a provider class\n", "Aug 04, 2024 7:14:17 PM com.sun.jersey.guice.spi.container.GuiceComponentProviderFactory register\n", "INFO: Registering org.apache.hadoop.mapreduce.v2.app.webapp.AMWebServices as a root resource class\n", "Aug 04, 2024 7:14:17 PM com.sun.jersey.server.impl.application.WebApplicationImpl _initiate\n", "INFO: Initiating Jersey application, version 'Jersey: 1.19.4 05/24/2017 03:20 PM'\n", "Aug 04, 2024 7:14:17 PM com.sun.jersey.guice.spi.container.GuiceComponentProviderFactory getComponentProvider\n", "INFO: Binding org.apache.hadoop.mapreduce.v2.app.webapp.JAXBContextResolver to GuiceManagedComponentProvider with the scope \"Singleton\"\n", "Aug 04, 2024 7:14:18 PM com.sun.jersey.guice.spi.container.GuiceComponentProviderFactory getComponentProvider\n", "INFO: Binding org.apache.hadoop.yarn.webapp.GenericExceptionHandler to GuiceManagedComponentProvider with the scope \"Singleton\"\n", "Aug 04, 2024 7:14:19 PM com.sun.jersey.guice.spi.container.GuiceComponentProviderFactory getComponentProvider\n", "INFO: Binding org.apache.hadoop.mapreduce.v2.app.webapp.AMWebServices to GuiceManagedComponentProvider with the scope \"PerRequest\"\n", "log4j:WARN No appenders could be found for logger (org.apache.hadoop.mapreduce.v2.app.MRAppMaster).\n", "log4j:WARN Please initialize the log4j system properly.\n", "log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.\n", "\n", "End of LogType:stderr\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000001 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stdout\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stdout\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000001 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:syslog\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:97284\n", "LogContents:\n", "2024-08-04 19:14:12,495 INFO [main] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: Created MRAppMaster for application appattempt_1722798834650_0001_000001\n", "2024-08-04 19:14:12,717 INFO [main] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: \n", "/************************************************************\n", "[system properties]\n", "os.name: Linux\n", "os.version: 6.1.85+\n", "java.home: /usr/lib/jvm/java-11-openjdk-amd64\n", "java.runtime.version: 11.0.24+8-post-Ubuntu-1ubuntu322.04\n", "java.vendor: Ubuntu\n", "java.version: 11.0.24\n", "java.vm.name: OpenJDK 64-Bit Server VM\n", "java.class.path: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000001:/content/hadoop-3.4.0/etc/hadoop:/content/hadoop-3.4.0/share/hadoop/common/hadoop-kms-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsp-api-2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/bcprov-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-api-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-reload4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jul-to-slf4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-httpfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/json-simple-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/HikariCP-4.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/leveldbjni-all-1.8.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-mawo-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-resourcemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-web-proxy-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-router-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-timeline-pluginstorage-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-sharedcachemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-distributedshell-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-unmanaged-am-launcher-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-applicationhistoryservice-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-nodemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-globalpolicygenerator-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-tests-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jakarta.xml.bind-api-2.3.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-plus-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/objenesis-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-module-jaxb-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/protobuf-java-2.5.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.inject-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/swagger-annotations-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jna-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-client-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcpkix-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/snakeyaml-2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/commons-lang-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-servlet-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/mssql-jdbc-6.2.1.jre7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/aopalliance-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/codemodel-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/geronimo-jcache_1.0_spec-1.0-alpha-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-tree-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-api-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/ehcache-3.3.1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcutil-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/fst-2.50.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-client-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jsonschema2pojo-core-1.0.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-common-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-jndi-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-commons-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-server-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-guice-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-client-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-annotations-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-json-provider-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-base-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-uploader-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-shuffle-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/mockito-core-2.28.2.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-app-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-nativetask-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-plugins-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/job.jar:job.jar/classes/:job.jar/lib/*:/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000001/job.jar\n", "java.io.tmpdir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000001/tmp\n", "user.dir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000001\n", "user.name: root\n", "************************************************************/\n", "2024-08-04 19:14:12,821 INFO [main] org.apache.hadoop.security.SecurityUtil: Updating Configuration\n", "2024-08-04 19:14:13,142 INFO [main] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: Executing with tokens: [Kind: YARN_AM_RM_TOKEN, Service: , Ident: (appAttemptId { application_id { id: 1 cluster_timestamp: 1722798834650 } attemptId: 1 } keyId: -675888397)]\n", "2024-08-04 19:14:13,219 INFO [main] org.apache.hadoop.conf.Configuration: resource-types.xml not found\n", "2024-08-04 19:14:13,222 INFO [main] org.apache.hadoop.yarn.util.resource.ResourceUtils: Unable to find 'resource-types.xml'.\n", "2024-08-04 19:14:13,246 INFO [main] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: Using mapred newApiCommitter.\n", "2024-08-04 19:14:13,249 INFO [main] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: OutputCommitter set in config null\n", "2024-08-04 19:14:13,350 INFO [main] org.apache.hadoop.mapreduce.lib.output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:14:13,352 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:14:13,352 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:14:14,156 INFO [main] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: OutputCommitter is org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter\n", "2024-08-04 19:14:14,475 INFO [main] org.apache.hadoop.yarn.event.AsyncDispatcher: Registering class org.apache.hadoop.mapreduce.jobhistory.EventType for class org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler\n", "2024-08-04 19:14:14,477 INFO [main] org.apache.hadoop.yarn.event.AsyncDispatcher: Registering class org.apache.hadoop.mapreduce.v2.app.job.event.JobEventType for class org.apache.hadoop.mapreduce.v2.app.MRAppMaster$JobEventDispatcher\n", "2024-08-04 19:14:14,478 INFO [main] org.apache.hadoop.yarn.event.AsyncDispatcher: Registering class org.apache.hadoop.mapreduce.v2.app.job.event.TaskEventType for class org.apache.hadoop.mapreduce.v2.app.MRAppMaster$TaskEventDispatcher\n", "2024-08-04 19:14:14,480 INFO [main] org.apache.hadoop.yarn.event.AsyncDispatcher: Registering class org.apache.hadoop.mapreduce.v2.app.job.event.TaskAttemptEventType for class org.apache.hadoop.mapreduce.v2.app.MRAppMaster$TaskAttemptEventDispatcher\n", "2024-08-04 19:14:14,480 INFO [main] org.apache.hadoop.yarn.event.AsyncDispatcher: Registering class org.apache.hadoop.mapreduce.v2.app.commit.CommitterEventType for class org.apache.hadoop.mapreduce.v2.app.commit.CommitterEventHandler\n", "2024-08-04 19:14:14,482 INFO [main] org.apache.hadoop.yarn.event.AsyncDispatcher: Registering class org.apache.hadoop.mapreduce.v2.app.speculate.Speculator$EventType for class org.apache.hadoop.mapreduce.v2.app.MRAppMaster$SpeculatorEventDispatcher\n", "2024-08-04 19:14:14,482 INFO [main] org.apache.hadoop.yarn.event.AsyncDispatcher: Registering class org.apache.hadoop.mapreduce.v2.app.rm.ContainerAllocator$EventType for class org.apache.hadoop.mapreduce.v2.app.MRAppMaster$ContainerAllocatorRouter\n", "2024-08-04 19:14:14,484 INFO [main] org.apache.hadoop.yarn.event.AsyncDispatcher: Registering class org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncher$EventType for class org.apache.hadoop.mapreduce.v2.app.MRAppMaster$ContainerLauncherRouter\n", "2024-08-04 19:14:14,532 INFO [main] org.apache.hadoop.mapreduce.v2.jobhistory.JobHistoryUtils: Default file system [hdfs://localhost:8902]\n", "2024-08-04 19:14:14,562 INFO [main] org.apache.hadoop.mapreduce.v2.jobhistory.JobHistoryUtils: Default file system [hdfs://localhost:8902]\n", "2024-08-04 19:14:14,608 INFO [main] org.apache.hadoop.mapreduce.v2.jobhistory.JobHistoryUtils: Default file system [hdfs://localhost:8902]\n", "2024-08-04 19:14:14,620 INFO [main] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Creating intermediate history logDir: [hdfs://localhost:8902/tmp/hadoop-yarn/staging/history/done_intermediate] + based on conf. Should ideally be created by the JobHistoryServer: yarn.app.mapreduce.am.create-intermediate-jh-base-dir\n", "2024-08-04 19:14:14,635 INFO [main] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Perms after creating 493, Expected: 1023\n", "2024-08-04 19:14:14,635 INFO [main] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Explicitly setting permissions to : 1023, rwxrwxrwt\n", "2024-08-04 19:14:14,659 INFO [main] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Perms after creating 488, Expected: 504\n", "2024-08-04 19:14:14,659 INFO [main] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Explicitly setting permissions to : 504, rwxrwx---\n", "2024-08-04 19:14:14,663 INFO [main] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Emitting job history data to the timeline server is not enabled\n", "2024-08-04 19:14:14,730 INFO [main] org.apache.hadoop.yarn.event.AsyncDispatcher: Registering class org.apache.hadoop.mapreduce.v2.app.job.event.JobFinishEvent$Type for class org.apache.hadoop.mapreduce.v2.app.MRAppMaster$JobFinishEventHandler\n", "2024-08-04 19:14:15,157 INFO [main] org.apache.hadoop.metrics2.impl.MetricsConfig: Loaded properties from hadoop-metrics2.properties\n", "2024-08-04 19:14:15,287 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Scheduled Metric snapshot period at 10 second(s).\n", "2024-08-04 19:14:15,287 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MRAppMaster metrics system started\n", "2024-08-04 19:14:15,303 INFO [main] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: Adding job token for job_1722798834650_0001 to jobTokenSecretManager\n", "2024-08-04 19:14:15,550 INFO [main] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: Not uberizing job_1722798834650_0001 because: not enabled;\n", "2024-08-04 19:14:15,581 INFO [main] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: Input size for job job_1722798834650_0001 = 590. Number of splits = 5\n", "2024-08-04 19:14:15,583 INFO [main] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: Number of reduces for job job_1722798834650_0001 = 1\n", "2024-08-04 19:14:15,583 INFO [main] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: job_1722798834650_0001Job Transitioned from NEW to INITED\n", "2024-08-04 19:14:15,585 INFO [main] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: MRAppMaster launching normal, non-uberized, multi-container job job_1722798834650_0001.\n", "2024-08-04 19:14:15,656 INFO [main] org.apache.hadoop.ipc.CallQueueManager: Using callQueue: class java.util.concurrent.LinkedBlockingQueue, queueCapacity: 100, scheduler: class org.apache.hadoop.ipc.DefaultRpcScheduler, ipcBackoff: false, ipcFailOver: false.\n", "2024-08-04 19:14:15,663 INFO [main] org.apache.hadoop.ipc.Server: Listener at 0.0.0.0:34269\n", "2024-08-04 19:14:15,665 INFO [Socket Reader #1 for port 0] org.apache.hadoop.ipc.Server: Starting Socket Reader #1 for port 0\n", "2024-08-04 19:14:15,719 INFO [main] org.apache.hadoop.yarn.factories.impl.pb.RpcServerFactoryPBImpl: Adding protocol org.apache.hadoop.mapreduce.v2.api.MRClientProtocolPB to the server\n", "2024-08-04 19:14:15,720 INFO [IPC Server Responder] org.apache.hadoop.ipc.Server: IPC Server Responder: starting\n", "2024-08-04 19:14:15,722 INFO [main] org.apache.hadoop.mapreduce.v2.app.client.MRClientService: Instantiated MRClientService at localhost/127.0.0.1:34269\n", "2024-08-04 19:14:15,723 INFO [IPC Server listener on 0] org.apache.hadoop.ipc.Server: IPC Server listener on 0: starting\n", "2024-08-04 19:14:15,761 INFO [main] org.eclipse.jetty.util.log: Logging initialized @4949ms to org.eclipse.jetty.util.log.Slf4jLog\n", "2024-08-04 19:14:15,894 WARN [main] org.apache.hadoop.security.authentication.server.AuthenticationFilter: Unable to initialize FileSignerSecretProvider, falling back to use random secrets. Reason: Could not read signature secret file: /root/hadoop-http-auth-signature-secret\n", "2024-08-04 19:14:15,954 INFO [main] org.apache.hadoop.http.HttpServer2: Added global filter 'safety' (class=org.apache.hadoop.http.HttpServer2$QuotingInputFilter)\n", "2024-08-04 19:14:16,010 INFO [main] org.apache.hadoop.http.HttpServer2: Added filter AM_PROXY_FILTER (class=org.apache.hadoop.yarn.server.webproxy.amfilter.AmIpFilter) to context mapreduce\n", "2024-08-04 19:14:16,011 INFO [main] org.apache.hadoop.http.HttpServer2: Added filter AM_PROXY_FILTER (class=org.apache.hadoop.yarn.server.webproxy.amfilter.AmIpFilter) to context static\n", "2024-08-04 19:14:16,017 INFO [main] org.apache.hadoop.http.HttpServer2: ASYNC_PROFILER_HOME environment variable and async.profiler.home system property not specified. Disabling /prof endpoint.\n", "2024-08-04 19:14:16,782 INFO [main] org.apache.hadoop.yarn.webapp.WebApps: Registered webapp guice modules\n", "2024-08-04 19:14:16,784 INFO [main] org.apache.hadoop.http.HttpServer2: Jetty bound to port 38235\n", "2024-08-04 19:14:16,786 INFO [main] org.eclipse.jetty.server.Server: jetty-9.4.53.v20231009; built: 2023-10-09T12:29:09.265Z; git: 27bde00a0b95a1d5bbee0eae7984f891d2d0f8c9; jvm 11.0.24+8-post-Ubuntu-1ubuntu322.04\n", "2024-08-04 19:14:16,825 INFO [main] org.eclipse.jetty.server.session: DefaultSessionIdManager workerName=node0\n", "2024-08-04 19:14:16,826 INFO [main] org.eclipse.jetty.server.session: No SessionScavenger set, using defaults\n", "2024-08-04 19:14:16,827 INFO [main] org.eclipse.jetty.server.session: node0 Scavenging every 660000ms\n", "2024-08-04 19:14:16,845 INFO [main] org.eclipse.jetty.server.handler.ContextHandler: Started o.e.j.s.ServletContextHandler@48a663e9{static,/static,jar:file:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-common-3.4.0.jar!/webapps/static,AVAILABLE}\n", "2024-08-04 19:14:19,462 INFO [main] org.eclipse.jetty.server.handler.ContextHandler: Started o.e.j.w.WebAppContext@7a1ddbf1{mapreduce,/,file:///content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000001/tmp/jetty-0_0_0_0-38235-hadoop-yarn-common-3_4_0_jar-_-any-17571332027292415163/webapp/,AVAILABLE}{jar:file:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-common-3.4.0.jar!/webapps/mapreduce}\n", "2024-08-04 19:14:19,487 INFO [main] org.eclipse.jetty.server.AbstractConnector: Started ServerConnector@58fbd02e{HTTP/1.1, (http/1.1)}{0.0.0.0:38235}\n", "2024-08-04 19:14:19,489 INFO [main] org.eclipse.jetty.server.Server: Started @8678ms\n", "2024-08-04 19:14:19,502 INFO [main] org.apache.hadoop.yarn.webapp.WebApps: Web app mapreduce started at 38235\n", "2024-08-04 19:14:19,543 INFO [main] org.apache.hadoop.ipc.CallQueueManager: Using callQueue: class java.util.concurrent.LinkedBlockingQueue, queueCapacity: 3000, scheduler: class org.apache.hadoop.ipc.DefaultRpcScheduler, ipcBackoff: false, ipcFailOver: false.\n", "2024-08-04 19:14:19,543 INFO [main] org.apache.hadoop.ipc.Server: Listener at 0.0.0.0:40041\n", "2024-08-04 19:14:19,544 INFO [Socket Reader #1 for port 0] org.apache.hadoop.ipc.Server: Starting Socket Reader #1 for port 0\n", "2024-08-04 19:14:19,579 INFO [IPC Server listener on 0] org.apache.hadoop.ipc.Server: IPC Server listener on 0: starting\n", "2024-08-04 19:14:19,579 INFO [IPC Server Responder] org.apache.hadoop.ipc.Server: IPC Server Responder: starting\n", "2024-08-04 19:14:19,667 INFO [main] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerRequestor: nodeBlacklistingEnabled:true\n", "2024-08-04 19:14:19,667 INFO [main] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerRequestor: maxTaskFailuresPerNode is 3\n", "2024-08-04 19:14:19,667 INFO [main] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerRequestor: blacklistDisablePercent is 33\n", "2024-08-04 19:14:19,678 INFO [main] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: 0% of the mappers will be scheduled using OPPORTUNISTIC containers\n", "2024-08-04 19:14:19,770 INFO [main] org.apache.hadoop.yarn.client.DefaultNoHARMFailoverProxyProvider: Connecting to ResourceManager at /0.0.0.0:8030\n", "2024-08-04 19:14:20,077 INFO [main] org.apache.hadoop.mapreduce.v2.app.rm.RMCommunicator: maxContainerCapability: \n", "2024-08-04 19:14:20,077 INFO [main] org.apache.hadoop.mapreduce.v2.app.rm.RMCommunicator: queue: root.default\n", "2024-08-04 19:14:20,093 INFO [main] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Upper limit on the thread pool size is 500\n", "2024-08-04 19:14:20,093 INFO [main] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: The thread pool initial size is 10\n", "2024-08-04 19:14:20,169 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: job_1722798834650_0001Job Transitioned from INITED to SETUP\n", "2024-08-04 19:14:20,174 INFO [CommitterEvent Processor #0] org.apache.hadoop.mapreduce.v2.app.commit.CommitterEventHandler: Processing the event EventType: JOB_SETUP\n", "2024-08-04 19:14:20,205 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: job_1722798834650_0001Job Transitioned from SETUP to RUNNING\n", "2024-08-04 19:14:20,448 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: Resource capability of task type MAP is set to \n", "2024-08-04 19:14:20,523 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000000 Task Transitioned from NEW to SCHEDULED\n", "2024-08-04 19:14:20,530 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000001 Task Transitioned from NEW to SCHEDULED\n", "2024-08-04 19:14:20,536 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000002 Task Transitioned from NEW to SCHEDULED\n", "2024-08-04 19:14:20,536 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000003 Task Transitioned from NEW to SCHEDULED\n", "2024-08-04 19:14:20,536 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000004 Task Transitioned from NEW to SCHEDULED\n", "2024-08-04 19:14:20,551 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: Resource capability of task type REDUCE is set to \n", "2024-08-04 19:14:20,551 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_r_000000 Task Transitioned from NEW to SCHEDULED\n", "2024-08-04 19:14:20,571 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000000_0 TaskAttempt Transitioned from NEW to UNASSIGNED\n", "2024-08-04 19:14:20,571 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000001_0 TaskAttempt Transitioned from NEW to UNASSIGNED\n", "2024-08-04 19:14:20,571 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000002_0 TaskAttempt Transitioned from NEW to UNASSIGNED\n", "2024-08-04 19:14:20,571 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000003_0 TaskAttempt Transitioned from NEW to UNASSIGNED\n", "2024-08-04 19:14:20,571 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000004_0 TaskAttempt Transitioned from NEW to UNASSIGNED\n", "2024-08-04 19:14:20,571 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_r_000000_0 TaskAttempt Transitioned from NEW to UNASSIGNED\n", "2024-08-04 19:14:20,573 INFO [eventHandlingThread] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Event Writer setup for JobId: job_1722798834650_0001, File: hdfs://localhost:8902/tmp/hadoop-yarn/staging/root/.staging/job_1722798834650_0001/job_1722798834650_0001_1.jhist\n", "2024-08-04 19:14:20,584 INFO [Thread-57] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: mapResourceRequest:\n", "2024-08-04 19:14:20,726 INFO [Thread-57] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: reduceResourceRequest:\n", "2024-08-04 19:14:21,107 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Before Scheduling: PendingReds:1 ScheduledMaps:5 ScheduledReds:0 AssignedMaps:0 AssignedReds:0 CompletedMaps:0 CompletedReds:0 ContAlloc:0 ContRel:0 HostLocal:0 RackLocal:0\n", "2024-08-04 19:14:21,633 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerRequestor: applicationId=application_1722798834650_0001: ask=3 release=0 newContainers=0 finishedContainers=0 resourceLimit= knownNMs=1\n", "2024-08-04 19:14:21,652 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:21,653 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:22,677 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Got allocated containers 2\n", "2024-08-04 19:14:22,680 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Assigned container container_1722798834650_0001_01_000002 to attempt_1722798834650_0001_m_000000_0\n", "2024-08-04 19:14:22,686 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Assigned container container_1722798834650_0001_01_000003 to attempt_1722798834650_0001_m_000001_0\n", "2024-08-04 19:14:22,689 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:22,689 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:22,689 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: After Scheduling: PendingReds:1 ScheduledMaps:3 ScheduledReds:0 AssignedMaps:2 AssignedReds:0 CompletedMaps:0 CompletedReds:0 ContAlloc:2 ContRel:0 HostLocal:2 RackLocal:0\n", "2024-08-04 19:14:22,802 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: The job-jar file on the remote FS is hdfs://localhost:8902/tmp/hadoop-yarn/staging/root/.staging/job_1722798834650_0001/job.jar\n", "2024-08-04 19:14:22,813 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: The job-conf file on the remote FS is /tmp/hadoop-yarn/staging/root/.staging/job_1722798834650_0001/job.xml\n", "2024-08-04 19:14:22,816 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: Adding #0 tokens and #1 secret keys for NM use for launching container\n", "2024-08-04 19:14:22,816 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: Size of containertokens_dob is 1\n", "2024-08-04 19:14:22,816 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: Putting shuffle token in serviceData\n", "2024-08-04 19:14:22,897 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapred.JobConf: Task java-opts do not specify heap size. Setting task attempt jvm max heap size to -Xmx820m\n", "2024-08-04 19:14:22,901 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000000_0 TaskAttempt Transitioned from UNASSIGNED to ASSIGNED\n", "2024-08-04 19:14:22,912 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapred.JobConf: Task java-opts do not specify heap size. Setting task attempt jvm max heap size to -Xmx820m\n", "2024-08-04 19:14:22,913 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000001_0 TaskAttempt Transitioned from UNASSIGNED to ASSIGNED\n", "2024-08-04 19:14:22,915 INFO [ContainerLauncher #0] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Processing the event EventType: CONTAINER_REMOTE_LAUNCH for container container_1722798834650_0001_01_000002 taskAttempt attempt_1722798834650_0001_m_000000_0\n", "2024-08-04 19:14:22,918 INFO [ContainerLauncher #0] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Launching attempt_1722798834650_0001_m_000000_0\n", "2024-08-04 19:14:22,922 INFO [ContainerLauncher #1] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Processing the event EventType: CONTAINER_REMOTE_LAUNCH for container container_1722798834650_0001_01_000003 taskAttempt attempt_1722798834650_0001_m_000001_0\n", "2024-08-04 19:14:22,922 INFO [ContainerLauncher #1] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Launching attempt_1722798834650_0001_m_000001_0\n", "2024-08-04 19:14:23,109 INFO [ContainerLauncher #0] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Shuffle port returned by ContainerManager for attempt_1722798834650_0001_m_000000_0 : 43847\n", "2024-08-04 19:14:23,111 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: TaskAttempt: [attempt_1722798834650_0001_m_000000_0] using containerId: [container_1722798834650_0001_01_000002 on NM: [localhost:34535]\n", "2024-08-04 19:14:23,116 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000000_0 TaskAttempt Transitioned from ASSIGNED to RUNNING\n", "2024-08-04 19:14:23,118 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000000 Task Transitioned from SCHEDULED to RUNNING\n", "2024-08-04 19:14:23,144 INFO [ContainerLauncher #1] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Shuffle port returned by ContainerManager for attempt_1722798834650_0001_m_000001_0 : 43847\n", "2024-08-04 19:14:23,149 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: TaskAttempt: [attempt_1722798834650_0001_m_000001_0] using containerId: [container_1722798834650_0001_01_000003 on NM: [localhost:34535]\n", "2024-08-04 19:14:23,149 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000001_0 TaskAttempt Transitioned from ASSIGNED to RUNNING\n", "2024-08-04 19:14:23,149 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000001 Task Transitioned from SCHEDULED to RUNNING\n", "2024-08-04 19:14:23,697 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerRequestor: applicationId=application_1722798834650_0001: ask=3 release=0 newContainers=0 finishedContainers=0 resourceLimit= knownNMs=1\n", "2024-08-04 19:14:23,698 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:23,698 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:24,706 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:24,706 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:25,714 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:25,715 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:26,723 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:26,723 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:27,732 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:27,732 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:27,816 INFO [Socket Reader #1 for port 0] SecurityLogger.org.apache.hadoop.ipc.Server: Auth successful for job_1722798834650_0001 (auth:SIMPLE) from localhost:34572 / 127.0.0.1:34572\n", "2024-08-04 19:14:27,918 INFO [IPC Server handler 7 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID : jvm_1722798834650_0001_m_000003 asked for a task\n", "2024-08-04 19:14:27,918 INFO [IPC Server handler 7 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID: jvm_1722798834650_0001_m_000003 given task: attempt_1722798834650_0001_m_000001_0\n", "2024-08-04 19:14:28,136 INFO [Socket Reader #1 for port 0] SecurityLogger.org.apache.hadoop.ipc.Server: Auth successful for job_1722798834650_0001 (auth:SIMPLE) from localhost:34586 / 127.0.0.1:34586\n", "2024-08-04 19:14:28,222 INFO [IPC Server handler 6 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID : jvm_1722798834650_0001_m_000002 asked for a task\n", "2024-08-04 19:14:28,222 INFO [IPC Server handler 6 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID: jvm_1722798834650_0001_m_000002 given task: attempt_1722798834650_0001_m_000000_0\n", "2024-08-04 19:14:28,739 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:28,739 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:29,744 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:29,744 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:30,750 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:30,750 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:31,757 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:31,757 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:32,763 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:32,764 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold not met. completedMapsForReduceSlowstart 1\n", "2024-08-04 19:14:33,414 INFO [IPC Server handler 4 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_m_000001_0 is : 0.0\n", "2024-08-04 19:14:33,632 INFO [IPC Server handler 22 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_m_000001_0 is : 1.0\n", "2024-08-04 19:14:33,651 INFO [IPC Server handler 7 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Done acknowledgment from attempt_1722798834650_0001_m_000001_0\n", "2024-08-04 19:14:33,659 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000001_0 TaskAttempt Transitioned from RUNNING to SUCCESS_FINISHING_CONTAINER\n", "2024-08-04 19:14:33,736 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: Task succeeded with attempt attempt_1722798834650_0001_m_000001_0\n", "2024-08-04 19:14:33,741 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000001 Task Transitioned from RUNNING to SUCCEEDED\n", "2024-08-04 19:14:33,766 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: Num completed Tasks: 1\n", "2024-08-04 19:14:33,786 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:33,786 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Reduce slow start threshold reached. Scheduling reduces.\n", "2024-08-04 19:14:33,786 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.2 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:33,786 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: After Scheduling: PendingReds:1 ScheduledMaps:3 ScheduledReds:0 AssignedMaps:2 AssignedReds:0 CompletedMaps:1 CompletedReds:0 ContAlloc:2 ContRel:0 HostLocal:2 RackLocal:0\n", "2024-08-04 19:14:33,969 INFO [IPC Server handler 6 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_m_000000_0 is : 0.0\n", "2024-08-04 19:14:34,103 INFO [IPC Server handler 4 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_m_000000_0 is : 1.0\n", "2024-08-04 19:14:34,111 INFO [IPC Server handler 5 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Done acknowledgment from attempt_1722798834650_0001_m_000000_0\n", "2024-08-04 19:14:34,112 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000000_0 TaskAttempt Transitioned from RUNNING to SUCCESS_FINISHING_CONTAINER\n", "2024-08-04 19:14:34,113 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: Task succeeded with attempt attempt_1722798834650_0001_m_000000_0\n", "2024-08-04 19:14:34,113 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000000 Task Transitioned from RUNNING to SUCCEEDED\n", "2024-08-04 19:14:34,113 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: Num completed Tasks: 2\n", "2024-08-04 19:14:34,787 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Before Scheduling: PendingReds:1 ScheduledMaps:3 ScheduledReds:0 AssignedMaps:2 AssignedReds:0 CompletedMaps:2 CompletedReds:0 ContAlloc:2 ContRel:0 HostLocal:2 RackLocal:0\n", "2024-08-04 19:14:34,814 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Received completed container container_1722798834650_0001_01_000003\n", "2024-08-04 19:14:34,815 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Received completed container container_1722798834650_0001_01_000002\n", "2024-08-04 19:14:34,815 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Got allocated containers 2\n", "2024-08-04 19:14:34,815 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: Diagnostics report from attempt_1722798834650_0001_m_000001_0: \n", "2024-08-04 19:14:34,816 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000001_0 TaskAttempt Transitioned from SUCCESS_FINISHING_CONTAINER to SUCCEEDED\n", "2024-08-04 19:14:34,816 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: Diagnostics report from attempt_1722798834650_0001_m_000000_0: \n", "2024-08-04 19:14:34,816 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000000_0 TaskAttempt Transitioned from SUCCESS_FINISHING_CONTAINER to SUCCEEDED\n", "2024-08-04 19:14:34,816 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Assigned container container_1722798834650_0001_01_000004 to attempt_1722798834650_0001_m_000002_0\n", "2024-08-04 19:14:34,817 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Assigned container container_1722798834650_0001_01_000005 to attempt_1722798834650_0001_m_000003_0\n", "2024-08-04 19:14:34,817 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:34,817 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.4 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:34,817 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: After Scheduling: PendingReds:1 ScheduledMaps:1 ScheduledReds:0 AssignedMaps:2 AssignedReds:0 CompletedMaps:2 CompletedReds:0 ContAlloc:4 ContRel:0 HostLocal:4 RackLocal:0\n", "2024-08-04 19:14:34,817 INFO [ContainerLauncher #3] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Processing the event EventType: CONTAINER_COMPLETED for container container_1722798834650_0001_01_000002 taskAttempt attempt_1722798834650_0001_m_000000_0\n", "2024-08-04 19:14:34,818 INFO [ContainerLauncher #2] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Processing the event EventType: CONTAINER_COMPLETED for container container_1722798834650_0001_01_000003 taskAttempt attempt_1722798834650_0001_m_000001_0\n", "2024-08-04 19:14:34,821 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapred.JobConf: Task java-opts do not specify heap size. Setting task attempt jvm max heap size to -Xmx820m\n", "2024-08-04 19:14:34,822 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000002_0 TaskAttempt Transitioned from UNASSIGNED to ASSIGNED\n", "2024-08-04 19:14:34,825 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapred.JobConf: Task java-opts do not specify heap size. Setting task attempt jvm max heap size to -Xmx820m\n", "2024-08-04 19:14:34,825 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000003_0 TaskAttempt Transitioned from UNASSIGNED to ASSIGNED\n", "2024-08-04 19:14:34,829 INFO [ContainerLauncher #4] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Processing the event EventType: CONTAINER_REMOTE_LAUNCH for container container_1722798834650_0001_01_000004 taskAttempt attempt_1722798834650_0001_m_000002_0\n", "2024-08-04 19:14:34,829 INFO [ContainerLauncher #4] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Launching attempt_1722798834650_0001_m_000002_0\n", "2024-08-04 19:14:34,835 INFO [ContainerLauncher #5] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Processing the event EventType: CONTAINER_REMOTE_LAUNCH for container container_1722798834650_0001_01_000005 taskAttempt attempt_1722798834650_0001_m_000003_0\n", "2024-08-04 19:14:34,835 INFO [ContainerLauncher #5] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Launching attempt_1722798834650_0001_m_000003_0\n", "2024-08-04 19:14:34,903 INFO [ContainerLauncher #4] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Shuffle port returned by ContainerManager for attempt_1722798834650_0001_m_000002_0 : 43847\n", "2024-08-04 19:14:34,904 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: TaskAttempt: [attempt_1722798834650_0001_m_000002_0] using containerId: [container_1722798834650_0001_01_000004 on NM: [localhost:34535]\n", "2024-08-04 19:14:34,904 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000002_0 TaskAttempt Transitioned from ASSIGNED to RUNNING\n", "2024-08-04 19:14:34,904 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000002 Task Transitioned from SCHEDULED to RUNNING\n", "2024-08-04 19:14:34,929 INFO [ContainerLauncher #5] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Shuffle port returned by ContainerManager for attempt_1722798834650_0001_m_000003_0 : 43847\n", "2024-08-04 19:14:34,930 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: TaskAttempt: [attempt_1722798834650_0001_m_000003_0] using containerId: [container_1722798834650_0001_01_000005 on NM: [localhost:34535]\n", "2024-08-04 19:14:34,930 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000003_0 TaskAttempt Transitioned from ASSIGNED to RUNNING\n", "2024-08-04 19:14:34,931 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000003 Task Transitioned from SCHEDULED to RUNNING\n", "2024-08-04 19:14:35,827 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerRequestor: applicationId=application_1722798834650_0001: ask=3 release=0 newContainers=0 finishedContainers=0 resourceLimit= knownNMs=1\n", "2024-08-04 19:14:35,827 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:35,827 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.4 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:36,854 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:36,854 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.4 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:37,863 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:37,863 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.4 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:38,869 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:38,869 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.4 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:39,876 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:39,876 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.4 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:40,881 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:40,881 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.4 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:41,051 INFO [Socket Reader #1 for port 0] SecurityLogger.org.apache.hadoop.ipc.Server: Auth successful for job_1722798834650_0001 (auth:SIMPLE) from localhost:34438 / 127.0.0.1:34438\n", "2024-08-04 19:14:41,087 INFO [IPC Server handler 4 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID : jvm_1722798834650_0001_m_000005 asked for a task\n", "2024-08-04 19:14:41,087 INFO [IPC Server handler 4 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID: jvm_1722798834650_0001_m_000005 given task: attempt_1722798834650_0001_m_000003_0\n", "2024-08-04 19:14:41,270 INFO [Socket Reader #1 for port 0] SecurityLogger.org.apache.hadoop.ipc.Server: Auth successful for job_1722798834650_0001 (auth:SIMPLE) from localhost:34442 / 127.0.0.1:34442\n", "2024-08-04 19:14:41,315 INFO [IPC Server handler 2 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID : jvm_1722798834650_0001_m_000004 asked for a task\n", "2024-08-04 19:14:41,315 INFO [IPC Server handler 2 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID: jvm_1722798834650_0001_m_000004 given task: attempt_1722798834650_0001_m_000002_0\n", "2024-08-04 19:14:41,895 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:41,895 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.4 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:42,901 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:42,901 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.4 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:43,910 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:43,910 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.4 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:44,917 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:44,917 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.4 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:45,337 INFO [IPC Server handler 0 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_m_000003_0 is : 0.0\n", "2024-08-04 19:14:45,475 INFO [IPC Server handler 3 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_m_000003_0 is : 1.0\n", "2024-08-04 19:14:45,485 INFO [IPC Server handler 11 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Done acknowledgment from attempt_1722798834650_0001_m_000003_0\n", "2024-08-04 19:14:45,489 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000003_0 TaskAttempt Transitioned from RUNNING to SUCCESS_FINISHING_CONTAINER\n", "2024-08-04 19:14:45,489 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: Task succeeded with attempt attempt_1722798834650_0001_m_000003_0\n", "2024-08-04 19:14:45,489 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000003 Task Transitioned from RUNNING to SUCCEEDED\n", "2024-08-04 19:14:45,489 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: Num completed Tasks: 3\n", "2024-08-04 19:14:45,525 INFO [IPC Server handler 1 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_m_000002_0 is : 0.0\n", "2024-08-04 19:14:45,634 INFO [IPC Server handler 14 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_m_000002_0 is : 1.0\n", "2024-08-04 19:14:45,639 INFO [IPC Server handler 21 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Done acknowledgment from attempt_1722798834650_0001_m_000002_0\n", "2024-08-04 19:14:45,641 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000002_0 TaskAttempt Transitioned from RUNNING to SUCCESS_FINISHING_CONTAINER\n", "2024-08-04 19:14:45,647 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: Task succeeded with attempt attempt_1722798834650_0001_m_000002_0\n", "2024-08-04 19:14:45,647 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000002 Task Transitioned from RUNNING to SUCCEEDED\n", "2024-08-04 19:14:45,647 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: Num completed Tasks: 4\n", "2024-08-04 19:14:45,918 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Before Scheduling: PendingReds:1 ScheduledMaps:1 ScheduledReds:0 AssignedMaps:2 AssignedReds:0 CompletedMaps:4 CompletedReds:0 ContAlloc:4 ContRel:0 HostLocal:4 RackLocal:0\n", "2024-08-04 19:14:45,923 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Recalculating schedule, headroom=\n", "2024-08-04 19:14:45,923 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: completedMapPercent 0.8 totalResourceLimit: finalMapResourceLimit: finalReduceResourceLimit: netScheduledMapResource: netScheduledReduceResource:\n", "2024-08-04 19:14:45,923 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Ramping up 1\n", "2024-08-04 19:14:45,923 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: After Scheduling: PendingReds:0 ScheduledMaps:1 ScheduledReds:1 AssignedMaps:2 AssignedReds:0 CompletedMaps:4 CompletedReds:0 ContAlloc:4 ContRel:0 HostLocal:4 RackLocal:0\n", "2024-08-04 19:14:46,933 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerRequestor: applicationId=application_1722798834650_0001: ask=1 release=0 newContainers=1 finishedContainers=2 resourceLimit= knownNMs=1\n", "2024-08-04 19:14:46,933 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Received completed container container_1722798834650_0001_01_000005\n", "2024-08-04 19:14:46,933 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Received completed container container_1722798834650_0001_01_000004\n", "2024-08-04 19:14:46,933 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Got allocated containers 1\n", "2024-08-04 19:14:46,933 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: Diagnostics report from attempt_1722798834650_0001_m_000003_0: \n", "2024-08-04 19:14:46,934 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000003_0 TaskAttempt Transitioned from SUCCESS_FINISHING_CONTAINER to SUCCEEDED\n", "2024-08-04 19:14:46,934 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: Diagnostics report from attempt_1722798834650_0001_m_000002_0: \n", "2024-08-04 19:14:46,934 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Assigned container container_1722798834650_0001_01_000006 to attempt_1722798834650_0001_m_000004_0\n", "2024-08-04 19:14:46,934 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000002_0 TaskAttempt Transitioned from SUCCESS_FINISHING_CONTAINER to SUCCEEDED\n", "2024-08-04 19:14:46,934 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: After Scheduling: PendingReds:0 ScheduledMaps:0 ScheduledReds:1 AssignedMaps:1 AssignedReds:0 CompletedMaps:4 CompletedReds:0 ContAlloc:5 ContRel:0 HostLocal:5 RackLocal:0\n", "2024-08-04 19:14:46,937 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapred.JobConf: Task java-opts do not specify heap size. Setting task attempt jvm max heap size to -Xmx820m\n", "2024-08-04 19:14:46,938 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000004_0 TaskAttempt Transitioned from UNASSIGNED to ASSIGNED\n", "2024-08-04 19:14:46,939 INFO [ContainerLauncher #6] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Processing the event EventType: CONTAINER_COMPLETED for container container_1722798834650_0001_01_000005 taskAttempt attempt_1722798834650_0001_m_000003_0\n", "2024-08-04 19:14:46,942 INFO [ContainerLauncher #7] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Processing the event EventType: CONTAINER_COMPLETED for container container_1722798834650_0001_01_000004 taskAttempt attempt_1722798834650_0001_m_000002_0\n", "2024-08-04 19:14:46,946 INFO [ContainerLauncher #8] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Processing the event EventType: CONTAINER_REMOTE_LAUNCH for container container_1722798834650_0001_01_000006 taskAttempt attempt_1722798834650_0001_m_000004_0\n", "2024-08-04 19:14:46,946 INFO [ContainerLauncher #8] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Launching attempt_1722798834650_0001_m_000004_0\n", "2024-08-04 19:14:46,985 INFO [ContainerLauncher #8] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Shuffle port returned by ContainerManager for attempt_1722798834650_0001_m_000004_0 : 43847\n", "2024-08-04 19:14:46,985 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: TaskAttempt: [attempt_1722798834650_0001_m_000004_0] using containerId: [container_1722798834650_0001_01_000006 on NM: [localhost:34535]\n", "2024-08-04 19:14:46,985 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000004_0 TaskAttempt Transitioned from ASSIGNED to RUNNING\n", "2024-08-04 19:14:46,986 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000004 Task Transitioned from SCHEDULED to RUNNING\n", "2024-08-04 19:14:47,949 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerRequestor: applicationId=application_1722798834650_0001: ask=3 release=0 newContainers=1 finishedContainers=0 resourceLimit= knownNMs=1\n", "2024-08-04 19:14:47,949 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Got allocated containers 1\n", "2024-08-04 19:14:47,949 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Assigned to reduce\n", "2024-08-04 19:14:47,949 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Assigned container container_1722798834650_0001_01_000007 to attempt_1722798834650_0001_r_000000_0\n", "2024-08-04 19:14:47,949 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: After Scheduling: PendingReds:0 ScheduledMaps:0 ScheduledReds:0 AssignedMaps:1 AssignedReds:1 CompletedMaps:4 CompletedReds:0 ContAlloc:6 ContRel:0 HostLocal:5 RackLocal:0\n", "2024-08-04 19:14:47,989 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapred.JobConf: Task java-opts do not specify heap size. Setting task attempt jvm max heap size to -Xmx820m\n", "2024-08-04 19:14:48,000 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_r_000000_0 TaskAttempt Transitioned from UNASSIGNED to ASSIGNED\n", "2024-08-04 19:14:48,008 INFO [ContainerLauncher #9] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Processing the event EventType: CONTAINER_REMOTE_LAUNCH for container container_1722798834650_0001_01_000007 taskAttempt attempt_1722798834650_0001_r_000000_0\n", "2024-08-04 19:14:48,008 INFO [ContainerLauncher #9] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Launching attempt_1722798834650_0001_r_000000_0\n", "2024-08-04 19:14:48,112 INFO [ContainerLauncher #9] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Shuffle port returned by ContainerManager for attempt_1722798834650_0001_r_000000_0 : 43847\n", "2024-08-04 19:14:48,112 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: TaskAttempt: [attempt_1722798834650_0001_r_000000_0] using containerId: [container_1722798834650_0001_01_000007 on NM: [localhost:34535]\n", "2024-08-04 19:14:48,112 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_r_000000_0 TaskAttempt Transitioned from ASSIGNED to RUNNING\n", "2024-08-04 19:14:48,113 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_r_000000 Task Transitioned from SCHEDULED to RUNNING\n", "2024-08-04 19:14:48,954 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerRequestor: applicationId=application_1722798834650_0001: ask=1 release=0 newContainers=0 finishedContainers=0 resourceLimit= knownNMs=1\n", "2024-08-04 19:14:53,473 INFO [Socket Reader #1 for port 0] SecurityLogger.org.apache.hadoop.ipc.Server: Auth successful for job_1722798834650_0001 (auth:SIMPLE) from localhost:58978 / 127.0.0.1:58978\n", "2024-08-04 19:14:53,530 INFO [IPC Server handler 1 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID : jvm_1722798834650_0001_m_000006 asked for a task\n", "2024-08-04 19:14:53,530 INFO [IPC Server handler 1 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID: jvm_1722798834650_0001_m_000006 given task: attempt_1722798834650_0001_m_000004_0\n", "2024-08-04 19:14:54,873 INFO [Socket Reader #1 for port 0] SecurityLogger.org.apache.hadoop.ipc.Server: Auth successful for job_1722798834650_0001 (auth:SIMPLE) from localhost:58994 / 127.0.0.1:58994\n", "2024-08-04 19:14:54,935 INFO [IPC Server handler 6 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID : jvm_1722798834650_0001_r_000007 asked for a task\n", "2024-08-04 19:14:54,935 INFO [IPC Server handler 6 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: JVM with ID: jvm_1722798834650_0001_r_000007 given task: attempt_1722798834650_0001_r_000000_0\n", "2024-08-04 19:14:57,673 INFO [IPC Server handler 6 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_m_000004_0 is : 0.0\n", "2024-08-04 19:14:57,820 INFO [IPC Server handler 4 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_m_000004_0 is : 1.0\n", "2024-08-04 19:14:57,841 INFO [IPC Server handler 5 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Done acknowledgment from attempt_1722798834650_0001_m_000004_0\n", "2024-08-04 19:14:57,843 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000004_0 TaskAttempt Transitioned from RUNNING to SUCCESS_FINISHING_CONTAINER\n", "2024-08-04 19:14:57,843 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: Task succeeded with attempt attempt_1722798834650_0001_m_000004_0\n", "2024-08-04 19:14:57,845 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_m_000004 Task Transitioned from RUNNING to SUCCEEDED\n", "2024-08-04 19:14:57,845 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: Num completed Tasks: 5\n", "2024-08-04 19:14:58,031 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Before Scheduling: PendingReds:0 ScheduledMaps:0 ScheduledReds:0 AssignedMaps:1 AssignedReds:1 CompletedMaps:5 CompletedReds:0 ContAlloc:6 ContRel:0 HostLocal:5 RackLocal:0\n", "2024-08-04 19:14:58,052 INFO [IPC Server handler 2 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: MapCompletionEvents request from attempt_1722798834650_0001_r_000000_0. startIndex 0 maxEvents 10000\n", "2024-08-04 19:14:58,388 INFO [IPC Server handler 3 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_r_000000_0 is : 0.0\n", "2024-08-04 19:14:59,042 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Received completed container container_1722798834650_0001_01_000006\n", "2024-08-04 19:14:59,042 INFO [RMCommunicator Allocator] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: After Scheduling: PendingReds:0 ScheduledMaps:0 ScheduledReds:0 AssignedMaps:0 AssignedReds:1 CompletedMaps:5 CompletedReds:0 ContAlloc:6 ContRel:0 HostLocal:5 RackLocal:0\n", "2024-08-04 19:14:59,043 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: Diagnostics report from attempt_1722798834650_0001_m_000004_0: \n", "2024-08-04 19:14:59,043 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_m_000004_0 TaskAttempt Transitioned from SUCCESS_FINISHING_CONTAINER to SUCCEEDED\n", "2024-08-04 19:14:59,043 INFO [ContainerLauncher #0] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: Processing the event EventType: CONTAINER_COMPLETED for container container_1722798834650_0001_01_000006 taskAttempt attempt_1722798834650_0001_m_000004_0\n", "2024-08-04 19:14:59,151 INFO [IPC Server handler 0 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Commit-pending state update from attempt_1722798834650_0001_r_000000_0\n", "2024-08-04 19:14:59,154 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_r_000000_0 TaskAttempt Transitioned from RUNNING to COMMIT_PENDING\n", "2024-08-04 19:14:59,155 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: attempt_1722798834650_0001_r_000000_0 given a go for committing the task output.\n", "2024-08-04 19:14:59,159 INFO [IPC Server handler 3 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Commit go/no-go request from attempt_1722798834650_0001_r_000000_0\n", "2024-08-04 19:14:59,159 INFO [IPC Server handler 3 on default port 40041] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: Result of canCommit for attempt_1722798834650_0001_r_000000_0:true\n", "2024-08-04 19:14:59,210 INFO [IPC Server handler 11 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Progress of TaskAttempt attempt_1722798834650_0001_r_000000_0 is : 1.0\n", "2024-08-04 19:14:59,215 INFO [IPC Server handler 1 on default port 40041] org.apache.hadoop.mapred.TaskAttemptListenerImpl: Done acknowledgment from attempt_1722798834650_0001_r_000000_0\n", "2024-08-04 19:14:59,218 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_r_000000_0 TaskAttempt Transitioned from COMMIT_PENDING to SUCCESS_FINISHING_CONTAINER\n", "2024-08-04 19:14:59,221 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: Task succeeded with attempt attempt_1722798834650_0001_r_000000_0\n", "2024-08-04 19:14:59,222 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskImpl: task_1722798834650_0001_r_000000 Task Transitioned from RUNNING to SUCCEEDED\n", "2024-08-04 19:14:59,222 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: Num completed Tasks: 6\n", "2024-08-04 19:14:59,223 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: job_1722798834650_0001Job Transitioned from RUNNING to COMMITTING\n", "2024-08-04 19:14:59,249 INFO [CommitterEvent Processor #1] org.apache.hadoop.mapreduce.v2.app.commit.CommitterEventHandler: Processing the event EventType: JOB_COMMIT\n", "2024-08-04 19:14:59,341 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: Calling handler for JobFinishedEvent \n", "2024-08-04 19:14:59,342 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.JobImpl: job_1722798834650_0001Job Transitioned from COMMITTING to SUCCEEDED\n", "2024-08-04 19:14:59,356 INFO [Thread-78] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: Job finished cleanly, recording last MRAppMaster retry\n", "2024-08-04 19:14:59,356 INFO [Thread-78] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: Notify RMCommunicator isAMLastRetry: true\n", "2024-08-04 19:14:59,356 INFO [Thread-78] org.apache.hadoop.mapreduce.v2.app.rm.RMCommunicator: RMCommunicator notified that shouldUnregistered is: true\n", "2024-08-04 19:14:59,356 INFO [Thread-78] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: Notify JHEH isAMLastRetry: true\n", "2024-08-04 19:14:59,356 INFO [Thread-78] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: JobHistoryEventHandler notified that forceJobCompletion is true\n", "2024-08-04 19:14:59,356 INFO [Thread-78] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: Calling stop for all the services\n", "2024-08-04 19:14:59,362 INFO [Thread-78] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Stopping JobHistoryEventHandler. Size of the outstanding queue size is 0\n", "2024-08-04 19:14:59,410 INFO [eventHandlingThread] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Copying hdfs://localhost:8902/tmp/hadoop-yarn/staging/root/.staging/job_1722798834650_0001/job_1722798834650_0001_1.jhist to hdfs://localhost:8902/tmp/hadoop-yarn/staging/history/done_intermediate/root/job_1722798834650_0001-1722798847160-root-QuasiMonteCarlo-1722798899334-5-1-SUCCEEDED-root.default-1722798860122.jhist_tmp\n", "2024-08-04 19:14:59,453 INFO [eventHandlingThread] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Copied from: hdfs://localhost:8902/tmp/hadoop-yarn/staging/root/.staging/job_1722798834650_0001/job_1722798834650_0001_1.jhist to done location: hdfs://localhost:8902/tmp/hadoop-yarn/staging/history/done_intermediate/root/job_1722798834650_0001-1722798847160-root-QuasiMonteCarlo-1722798899334-5-1-SUCCEEDED-root.default-1722798860122.jhist_tmp\n", "2024-08-04 19:14:59,454 INFO [eventHandlingThread] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Set historyUrl to http://446a375b7fe4:19888/jobhistory/job/job_1722798834650_0001\n", "2024-08-04 19:14:59,456 INFO [eventHandlingThread] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Copying hdfs://localhost:8902/tmp/hadoop-yarn/staging/root/.staging/job_1722798834650_0001/job_1722798834650_0001_1_conf.xml to hdfs://localhost:8902/tmp/hadoop-yarn/staging/history/done_intermediate/root/job_1722798834650_0001_conf.xml_tmp\n", "2024-08-04 19:14:59,508 INFO [eventHandlingThread] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Copied from: hdfs://localhost:8902/tmp/hadoop-yarn/staging/root/.staging/job_1722798834650_0001/job_1722798834650_0001_1_conf.xml to done location: hdfs://localhost:8902/tmp/hadoop-yarn/staging/history/done_intermediate/root/job_1722798834650_0001_conf.xml_tmp\n", "2024-08-04 19:14:59,521 INFO [eventHandlingThread] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Moved tmp to done: hdfs://localhost:8902/tmp/hadoop-yarn/staging/history/done_intermediate/root/job_1722798834650_0001.summary_tmp to hdfs://localhost:8902/tmp/hadoop-yarn/staging/history/done_intermediate/root/job_1722798834650_0001.summary\n", "2024-08-04 19:14:59,530 INFO [eventHandlingThread] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Moved tmp to done: hdfs://localhost:8902/tmp/hadoop-yarn/staging/history/done_intermediate/root/job_1722798834650_0001_conf.xml_tmp to hdfs://localhost:8902/tmp/hadoop-yarn/staging/history/done_intermediate/root/job_1722798834650_0001_conf.xml\n", "2024-08-04 19:14:59,536 INFO [eventHandlingThread] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Moved tmp to done: hdfs://localhost:8902/tmp/hadoop-yarn/staging/history/done_intermediate/root/job_1722798834650_0001-1722798847160-root-QuasiMonteCarlo-1722798899334-5-1-SUCCEEDED-root.default-1722798860122.jhist_tmp to hdfs://localhost:8902/tmp/hadoop-yarn/staging/history/done_intermediate/root/job_1722798834650_0001-1722798847160-root-QuasiMonteCarlo-1722798899334-5-1-SUCCEEDED-root.default-1722798860122.jhist\n", "2024-08-04 19:14:59,540 INFO [Thread-78] org.apache.hadoop.mapreduce.jobhistory.JobHistoryEventHandler: Stopped JobHistoryEventHandler. super.stop()\n", "2024-08-04 19:14:59,541 INFO [Thread-78] org.apache.hadoop.mapreduce.v2.app.launcher.ContainerLauncherImpl: KILLING attempt_1722798834650_0001_r_000000_0\n", "2024-08-04 19:14:59,582 INFO [AsyncDispatcher event handler] org.apache.hadoop.mapreduce.v2.app.job.impl.TaskAttemptImpl: attempt_1722798834650_0001_r_000000_0 TaskAttempt Transitioned from SUCCESS_FINISHING_CONTAINER to SUCCEEDED\n", "2024-08-04 19:14:59,589 INFO [Thread-78] org.apache.hadoop.mapreduce.v2.app.rm.RMCommunicator: Setting job diagnostics to \n", "2024-08-04 19:14:59,589 INFO [Thread-78] org.apache.hadoop.mapreduce.v2.app.rm.RMCommunicator: History url is http://446a375b7fe4:19888/jobhistory/job/job_1722798834650_0001\n", "2024-08-04 19:14:59,638 INFO [Thread-78] org.apache.hadoop.mapreduce.v2.app.rm.RMCommunicator: Waiting for application to be successfully unregistered.\n", "2024-08-04 19:15:00,641 INFO [Thread-78] org.apache.hadoop.mapreduce.v2.app.rm.RMContainerAllocator: Final Stats: PendingReds:0 ScheduledMaps:0 ScheduledReds:0 AssignedMaps:0 AssignedReds:1 CompletedMaps:5 CompletedReds:0 ContAlloc:6 ContRel:0 HostLocal:5 RackLocal:0\n", "2024-08-04 19:15:00,643 INFO [Thread-78] org.apache.hadoop.mapreduce.v2.app.MRAppMaster: Deleting staging directory hdfs://localhost:8902/ /tmp/hadoop-yarn/staging/root/.staging/job_1722798834650_0001\n", "2024-08-04 19:15:00,646 INFO [Thread-78] org.apache.hadoop.ipc.Server: Stopping server on 40041\n", "2024-08-04 19:15:00,647 INFO [IPC Server listener on 0] org.apache.hadoop.ipc.Server: Stopping IPC Server listener on 0\n", "2024-08-04 19:15:00,649 INFO [IPC Server Responder] org.apache.hadoop.ipc.Server: Stopping IPC Server Responder\n", "2024-08-04 19:15:00,654 INFO [TaskHeartbeatHandler PingChecker] org.apache.hadoop.mapreduce.v2.app.TaskHeartbeatHandler: TaskHeartbeatHandler thread interrupted\n", "2024-08-04 19:15:00,655 INFO [Ping Checker for TaskAttemptFinishingMonitor] org.apache.hadoop.yarn.util.AbstractLivelinessMonitor: TaskAttemptFinishingMonitor thread interrupted\n", "2024-08-04 19:15:05,657 INFO [Thread-78] org.apache.hadoop.ipc.Server: Stopping server on 34269\n", "2024-08-04 19:15:05,658 INFO [IPC Server Responder] org.apache.hadoop.ipc.Server: Stopping IPC Server Responder\n", "2024-08-04 19:15:05,658 INFO [IPC Server listener on 0] org.apache.hadoop.ipc.Server: Stopping IPC Server listener on 0\n", "2024-08-04 19:15:05,674 INFO [Thread-78] org.eclipse.jetty.server.handler.ContextHandler: Stopped o.e.j.w.WebAppContext@7a1ddbf1{mapreduce,/,null,STOPPED}{jar:file:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-common-3.4.0.jar!/webapps/mapreduce}\n", "2024-08-04 19:15:05,691 INFO [Thread-78] org.eclipse.jetty.server.AbstractConnector: Stopped ServerConnector@58fbd02e{HTTP/1.1, (http/1.1)}{0.0.0.0:0}\n", "2024-08-04 19:15:05,691 INFO [Thread-78] org.eclipse.jetty.server.session: node0 Stopped scavenging\n", "2024-08-04 19:15:05,692 INFO [Thread-78] org.eclipse.jetty.server.handler.ContextHandler: Stopped o.e.j.s.ServletContextHandler@48a663e9{static,/static,jar:file:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-common-3.4.0.jar!/webapps/static,STOPPED}\n", "\n", "End of LogType:syslog\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000006 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:directory.info\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:2101\n", "LogContents:\n", "ls -l:\n", "total 32\n", "-rw-r--r-- 1 root root 129 Aug 4 19:14 container_tokens\n", "-rwx------ 1 root root 964 Aug 4 19:14 default_container_executor_session.sh\n", "-rwx------ 1 root root 1019 Aug 4 19:14 default_container_executor.sh\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.jar -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.xml -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\n", "-rwx------ 1 root root 8159 Aug 4 19:14 launch_container.sh\n", "drwx--x--- 2 root root 4096 Aug 4 19:14 tmp\n", "find -L . -maxdepth 5 -ls:\n", " 809806 4 drwx--x--- 3 root root 4096 Aug 4 19:14 .\n", " 809828 4 -rwx------ 1 root root 1019 Aug 4 19:14 ./default_container_executor.sh\n", " 809751 260 -r-x------ 1 root root 264361 Aug 4 19:14 ./job.xml\n", " 809822 4 -rw-r--r-- 1 root root 129 Aug 4 19:14 ./container_tokens\n", " 809826 4 -rwx------ 1 root root 964 Aug 4 19:14 ./default_container_executor_session.sh\n", " 809824 8 -rwx------ 1 root root 8159 Aug 4 19:14 ./launch_container.sh\n", " 809829 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor.sh.crc\n", " 809825 4 -rw-r--r-- 1 root root 72 Aug 4 19:14 ./.launch_container.sh.crc\n", " 809745 4 drwx------ 2 root root 4096 Aug 4 19:14 ./job.jar\n", " 809746 276 -r-x------ 1 root root 281609 Aug 4 19:14 ./job.jar/job.jar\n", " 809823 4 -rw-r--r-- 1 root root 12 Aug 4 19:14 ./.container_tokens.crc\n", " 809827 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor_session.sh.crc\n", " 809821 4 drwx--x--- 2 root root 4096 Aug 4 19:14 ./tmp\n", "broken symlinks(find -L . -maxdepth 5 -type l -ls):\n", "\n", "End of LogType:directory.info\n", "*******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000006 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:launch_container.sh\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:8159\n", "LogContents:\n", "#!/bin/bash\n", "\n", "set -o pipefail -e\n", "export PRELAUNCH_OUT=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/prelaunch.out\"\n", "exec >\"${PRELAUNCH_OUT}\"\n", "export PRELAUNCH_ERR=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/prelaunch.err\"\n", "exec 2>\"${PRELAUNCH_ERR}\"\n", "echo \"Setting up env variables\"\n", "export JAVA_HOME=${JAVA_HOME:-\"/usr/lib/jvm/java-11-openjdk-amd64\"}\n", "export HADOOP_COMMON_HOME=${HADOOP_COMMON_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HDFS_HOME=${HADOOP_HDFS_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_CONF_DIR=${HADOOP_CONF_DIR:-\"/content/hadoop-3.4.0/etc/hadoop\"}\n", "export HADOOP_YARN_HOME=${HADOOP_YARN_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HOME=${HADOOP_HOME:-\"/content/hadoop-3.4.0\"}\n", "export PATH=${PATH:-\"/content/hadoop-3.4.0/bin:/opt/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/tools/node/bin:/tools/google-cloud-sdk/bin\"}\n", "export LANG=${LANG:-\"en_US.UTF-8\"}\n", "export HADOOP_TOKEN_FILE_LOCATION=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000006/container_tokens\"\n", "export CONTAINER_ID=\"container_1722798834650_0001_01_000006\"\n", "export NM_PORT=\"34535\"\n", "export NM_HOST=\"localhost\"\n", "export NM_HTTP_PORT=\"37361\"\n", "export LOCAL_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\"\n", "export LOCAL_USER_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/\"\n", "export LOG_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000006,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000006,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000006,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006\"\n", "export USER=\"root\"\n", "export LOGNAME=\"root\"\n", "export HOME=\"/home/\"\n", "export PWD=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000006\"\n", "export LOCALIZATION_COUNTERS=\"0,548046,0,2,1\"\n", "export JVM_PID=\"$$\"\n", "export NM_AUX_SERVICE_mapreduce_shuffle=\"AACrRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n", "export STDOUT_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/stdout\"\n", "export SHELL=\"/bin/bash\"\n", "export HADOOP_ROOT_LOGGER=\"INFO,console\"\n", "export CLASSPATH=\"$PWD:$HADOOP_CONF_DIR:$HADOOP_COMMON_HOME/share/hadoop/common/*:$HADOOP_COMMON_HOME/share/hadoop/common/lib/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/lib/*:$HADOOP_YARN_HOME/share/hadoop/yarn/*:$HADOOP_YARN_HOME/share/hadoop/yarn/lib/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/*:job.jar/classes/:job.jar/lib/*:$PWD/*\"\n", "export LD_LIBRARY_PATH=\"$PWD:$HADOOP_COMMON_HOME/lib/native\"\n", "export STDERR_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/stderr\"\n", "export HADOOP_CLIENT_OPTS=\"\"\n", "export MALLOC_ARENA_MAX=\"4\"\n", "echo \"Setting up job resources\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\" \"job.xml\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\" \"job.jar\"\n", "echo \"Copying debugging information\"\n", "# Creating copy of launch script\n", "cp \"launch_container.sh\" \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/launch_container.sh\"\n", "chmod 640 \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/launch_container.sh\"\n", "# Determining directory contents\n", "echo \"ls -l:\" 1>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/directory.info\"\n", "ls -l 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/directory.info\"\n", "echo \"find -L . -maxdepth 5 -ls:\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/directory.info\"\n", "find -L . -maxdepth 5 -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/directory.info\"\n", "echo \"broken symlinks(find -L . -maxdepth 5 -type l -ls):\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/directory.info\"\n", "find -L . -maxdepth 5 -type l -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/directory.info\"\n", "echo \"Launching container\"\n", "exec /bin/bash -c \"$JAVA_HOME/bin/java -Djava.net.preferIPv4Stack=true -Dhadoop.metrics.log.level=WARN -Xmx820m -Djava.io.tmpdir=$PWD/tmp -Dlog4j.configuration=container-log4j.properties -Dyarn.app.container.log.dir=/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006 -Dyarn.app.container.log.filesize=0 -Dhadoop.root.logger=INFO,CLA -Dhadoop.root.logfile=syslog org.apache.hadoop.mapred.YarnChild 127.0.0.1 40041 attempt_1722798834650_0001_m_000004_0 6 1>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/stdout 2>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000006/stderr \"\n", "\n", "End of LogType:launch_container.sh\n", "************************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000006 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.err\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:prelaunch.err\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000006 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.out\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:100\n", "LogContents:\n", "Setting up env variables\n", "Setting up job resources\n", "Copying debugging information\n", "Launching container\n", "\n", "End of LogType:prelaunch.out\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000006 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stderr\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stderr\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000006 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stdout\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stdout\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000006 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:syslog\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:31510\n", "LogContents:\n", "2024-08-04 19:14:51,129 INFO [main] org.apache.hadoop.security.SecurityUtil: Updating Configuration\n", "2024-08-04 19:14:51,786 INFO [main] org.apache.hadoop.metrics2.impl.MetricsConfig: Loaded properties from hadoop-metrics2.properties\n", "2024-08-04 19:14:52,527 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Scheduled Metric snapshot period at 10 second(s).\n", "2024-08-04 19:14:52,527 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system started\n", "2024-08-04 19:14:52,926 INFO [main] org.apache.hadoop.mapred.YarnChild: Executing with tokens: [Kind: mapreduce.job, Service: job_1722798834650_0001, Ident: (org.apache.hadoop.mapreduce.security.token.JobTokenIdentifier@70f02c32)]\n", "2024-08-04 19:14:53,089 INFO [main] org.apache.hadoop.mapred.YarnChild: Sleeping for 0ms before retrying again. Got null now.\n", "2024-08-04 19:14:53,846 INFO [main] org.apache.hadoop.mapred.YarnChild: mapreduce.cluster.local.dir for child: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\n", "2024-08-04 19:14:55,154 INFO [main] org.apache.hadoop.mapred.YarnChild: \n", "/************************************************************\n", "[system properties]\n", "os.name: Linux\n", "os.version: 6.1.85+\n", "java.home: /usr/lib/jvm/java-11-openjdk-amd64\n", "java.runtime.version: 11.0.24+8-post-Ubuntu-1ubuntu322.04\n", "java.vendor: Ubuntu\n", "java.version: 11.0.24\n", "java.vm.name: OpenJDK 64-Bit Server VM\n", "java.class.path: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000006:/content/hadoop-3.4.0/etc/hadoop:/content/hadoop-3.4.0/share/hadoop/common/hadoop-kms-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsp-api-2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/bcprov-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-api-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-reload4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jul-to-slf4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-httpfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/json-simple-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/HikariCP-4.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/leveldbjni-all-1.8.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-mawo-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-resourcemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-web-proxy-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-router-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-timeline-pluginstorage-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-sharedcachemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-distributedshell-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-unmanaged-am-launcher-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-applicationhistoryservice-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-nodemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-globalpolicygenerator-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-tests-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jakarta.xml.bind-api-2.3.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-plus-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/objenesis-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-module-jaxb-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/protobuf-java-2.5.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.inject-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/swagger-annotations-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jna-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-client-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcpkix-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/snakeyaml-2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/commons-lang-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-servlet-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/mssql-jdbc-6.2.1.jre7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/aopalliance-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/codemodel-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/geronimo-jcache_1.0_spec-1.0-alpha-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-tree-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-api-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/ehcache-3.3.1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcutil-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/fst-2.50.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-client-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jsonschema2pojo-core-1.0.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-common-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-jndi-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-commons-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-server-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-guice-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-client-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-annotations-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-json-provider-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-base-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-uploader-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-shuffle-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/mockito-core-2.28.2.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-app-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-nativetask-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-plugins-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/job.jar:job.jar/classes/:job.jar/lib/*:/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000006/job.jar\n", "java.io.tmpdir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000006/tmp\n", "user.dir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000006\n", "user.name: root\n", "************************************************************/\n", "2024-08-04 19:14:55,155 INFO [main] org.apache.hadoop.conf.Configuration.deprecation: session.id is deprecated. Instead, use dfs.metrics.session-id\n", "2024-08-04 19:14:56,696 INFO [main] org.apache.hadoop.mapreduce.lib.output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:14:56,703 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:14:56,703 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:14:56,760 INFO [main] org.apache.hadoop.mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:14:57,364 INFO [main] org.apache.hadoop.mapred.MapTask: Processing split: hdfs://localhost:8902/user/root/QuasiMonteCarlo_1722798838891_1650860168/in/part4:0+118\n", "2024-08-04 19:14:57,582 INFO [main] org.apache.hadoop.mapred.MapTask: (EQUATOR) 0 kvi 26214396(104857584)\n", "2024-08-04 19:14:57,583 INFO [main] org.apache.hadoop.mapred.MapTask: mapreduce.task.io.sort.mb: 100\n", "2024-08-04 19:14:57,583 INFO [main] org.apache.hadoop.mapred.MapTask: soft limit at 83886080\n", "2024-08-04 19:14:57,583 INFO [main] org.apache.hadoop.mapred.MapTask: bufstart = 0; bufvoid = 104857600\n", "2024-08-04 19:14:57,583 INFO [main] org.apache.hadoop.mapred.MapTask: kvstart = 26214396; length = 6553600\n", "2024-08-04 19:14:57,591 INFO [main] org.apache.hadoop.mapred.MapTask: Map output collector class = org.apache.hadoop.mapred.MapTask$MapOutputBuffer\n", "2024-08-04 19:14:57,683 INFO [main] org.apache.hadoop.mapred.MapTask: Starting flush of map output\n", "2024-08-04 19:14:57,683 INFO [main] org.apache.hadoop.mapred.MapTask: Spilling map output\n", "2024-08-04 19:14:57,683 INFO [main] org.apache.hadoop.mapred.MapTask: bufstart = 0; bufend = 18; bufvoid = 104857600\n", "2024-08-04 19:14:57,683 INFO [main] org.apache.hadoop.mapred.MapTask: kvstart = 26214396(104857584); kvend = 26214392(104857568); length = 5/6553600\n", "2024-08-04 19:14:57,692 INFO [main] org.apache.hadoop.mapred.MapTask: Finished spill 0\n", "2024-08-04 19:14:57,787 INFO [main] org.apache.hadoop.mapred.Task: Task:attempt_1722798834650_0001_m_000004_0 is done. And is in the process of committing\n", "2024-08-04 19:14:57,844 INFO [main] org.apache.hadoop.mapred.Task: Task 'attempt_1722798834650_0001_m_000004_0' done.\n", "2024-08-04 19:14:57,878 INFO [main] org.apache.hadoop.mapred.Task: Final Counters for attempt_1722798834650_0001_m_000004_0: Counters: 28\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=0\n", "\t\tFILE: Number of bytes written=309460\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\t\tHDFS: Number of bytes read=264\n", "\t\tHDFS: Number of bytes written=0\n", "\t\tHDFS: Number of read operations=4\n", "\t\tHDFS: Number of large read operations=0\n", "\t\tHDFS: Number of write operations=0\n", "\t\tHDFS: Number of bytes read erasure-coded=0\n", "\tMap-Reduce Framework\n", "\t\tMap input records=1\n", "\t\tMap output records=2\n", "\t\tMap output bytes=18\n", "\t\tMap output materialized bytes=28\n", "\t\tInput split bytes=146\n", "\t\tCombine input records=0\n", "\t\tSpilled Records=2\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=0\n", "\t\tGC time elapsed (ms)=91\n", "\t\tCPU time spent (ms)=840\n", "\t\tPhysical memory (bytes) snapshot=361263104\n", "\t\tVirtual memory (bytes) snapshot=2716454912\n", "\t\tTotal committed heap usage (bytes)=273678336\n", "\t\tPeak Map Physical memory (bytes)=361263104\n", "\t\tPeak Map Virtual memory (bytes)=2716454912\n", "\tFile Input Format Counters \n", "\t\tBytes Read=118\n", "2024-08-04 19:14:57,880 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Stopping MapTask metrics system...\n", "2024-08-04 19:14:57,883 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system stopped.\n", "2024-08-04 19:14:57,883 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: MapTask metrics system shutdown complete.\n", "\n", "End of LogType:syslog\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000007 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:directory.info\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:2101\n", "LogContents:\n", "ls -l:\n", "total 36\n", "-rw-r--r-- 1 root root 129 Aug 4 19:14 container_tokens\n", "-rwx------ 1 root root 964 Aug 4 19:14 default_container_executor_session.sh\n", "-rwx------ 1 root root 1019 Aug 4 19:14 default_container_executor.sh\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.jar -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\n", "lrwxrwxrwx 1 root root 179 Aug 4 19:14 job.xml -> /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\n", "-rwx------ 1 root root 8351 Aug 4 19:14 launch_container.sh\n", "drwx--x--- 2 root root 4096 Aug 4 19:14 tmp\n", "find -L . -maxdepth 5 -ls:\n", " 809887 4 drwx--x--- 3 root root 4096 Aug 4 19:14 .\n", " 809917 4 -rwx------ 1 root root 1019 Aug 4 19:14 ./default_container_executor.sh\n", " 809751 260 -r-x------ 1 root root 264361 Aug 4 19:14 ./job.xml\n", " 809911 4 -rw-r--r-- 1 root root 129 Aug 4 19:14 ./container_tokens\n", " 809915 4 -rwx------ 1 root root 964 Aug 4 19:14 ./default_container_executor_session.sh\n", " 809913 12 -rwx------ 1 root root 8351 Aug 4 19:14 ./launch_container.sh\n", " 809918 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor.sh.crc\n", " 809914 4 -rw-r--r-- 1 root root 76 Aug 4 19:14 ./.launch_container.sh.crc\n", " 809745 4 drwx------ 2 root root 4096 Aug 4 19:14 ./job.jar\n", " 809746 276 -r-x------ 1 root root 281609 Aug 4 19:14 ./job.jar/job.jar\n", " 809912 4 -rw-r--r-- 1 root root 12 Aug 4 19:14 ./.container_tokens.crc\n", " 809916 4 -rw-r--r-- 1 root root 16 Aug 4 19:14 ./.default_container_executor_session.sh.crc\n", " 809910 4 drwx--x--- 2 root root 4096 Aug 4 19:14 ./tmp\n", "broken symlinks(find -L . -maxdepth 5 -type l -ls):\n", "\n", "End of LogType:directory.info\n", "*******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000007 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:launch_container.sh\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:8351\n", "LogContents:\n", "#!/bin/bash\n", "\n", "set -o pipefail -e\n", "export PRELAUNCH_OUT=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/prelaunch.out\"\n", "exec >\"${PRELAUNCH_OUT}\"\n", "export PRELAUNCH_ERR=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/prelaunch.err\"\n", "exec 2>\"${PRELAUNCH_ERR}\"\n", "echo \"Setting up env variables\"\n", "export JAVA_HOME=${JAVA_HOME:-\"/usr/lib/jvm/java-11-openjdk-amd64\"}\n", "export HADOOP_COMMON_HOME=${HADOOP_COMMON_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HDFS_HOME=${HADOOP_HDFS_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_CONF_DIR=${HADOOP_CONF_DIR:-\"/content/hadoop-3.4.0/etc/hadoop\"}\n", "export HADOOP_YARN_HOME=${HADOOP_YARN_HOME:-\"/content/hadoop-3.4.0\"}\n", "export HADOOP_HOME=${HADOOP_HOME:-\"/content/hadoop-3.4.0\"}\n", "export PATH=${PATH:-\"/content/hadoop-3.4.0/bin:/opt/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/tools/node/bin:/tools/google-cloud-sdk/bin\"}\n", "export LANG=${LANG:-\"en_US.UTF-8\"}\n", "export HADOOP_TOKEN_FILE_LOCATION=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000007/container_tokens\"\n", "export CONTAINER_ID=\"container_1722798834650_0001_01_000007\"\n", "export NM_PORT=\"34535\"\n", "export NM_HOST=\"localhost\"\n", "export NM_HTTP_PORT=\"37361\"\n", "export LOCAL_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\"\n", "export LOCAL_USER_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/\"\n", "export LOG_DIRS=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_0/application_1722798834650_0001/container_1722798834650_0001_01_000007,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_2/application_1722798834650_0001/container_1722798834650_0001_01_000007,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_3/application_1722798834650_0001/container_1722798834650_0001_01_000007\"\n", "export USER=\"root\"\n", "export LOGNAME=\"root\"\n", "export HOME=\"/home/\"\n", "export PWD=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000007\"\n", "export LOCALIZATION_COUNTERS=\"0,548046,0,2,14\"\n", "export JVM_PID=\"$$\"\n", "export NM_AUX_SERVICE_mapreduce_shuffle=\"AACrRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\"\n", "export STDOUT_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/stdout\"\n", "export SHELL=\"/bin/bash\"\n", "export HADOOP_ROOT_LOGGER=\"INFO,console\"\n", "export CLASSPATH=\"$PWD:$HADOOP_CONF_DIR:$HADOOP_COMMON_HOME/share/hadoop/common/*:$HADOOP_COMMON_HOME/share/hadoop/common/lib/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/*:$HADOOP_HDFS_HOME/share/hadoop/hdfs/lib/*:$HADOOP_YARN_HOME/share/hadoop/yarn/*:$HADOOP_YARN_HOME/share/hadoop/yarn/lib/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/*:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/*:job.jar/classes/:job.jar/lib/*:$PWD/*\"\n", "export LD_LIBRARY_PATH=\"$PWD:$HADOOP_COMMON_HOME/lib/native\"\n", "export STDERR_LOGFILE_ENV=\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/stderr\"\n", "export HADOOP_CLIENT_OPTS=\"\"\n", "export MALLOC_ARENA_MAX=\"4\"\n", "echo \"Setting up job resources\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/13/job.xml\" \"job.xml\"\n", "ln -sf -- \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001/filecache/11/job.jar\" \"job.jar\"\n", "echo \"Copying debugging information\"\n", "# Creating copy of launch script\n", "cp \"launch_container.sh\" \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/launch_container.sh\"\n", "chmod 640 \"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/launch_container.sh\"\n", "# Determining directory contents\n", "echo \"ls -l:\" 1>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/directory.info\"\n", "ls -l 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/directory.info\"\n", "echo \"find -L . -maxdepth 5 -ls:\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/directory.info\"\n", "find -L . -maxdepth 5 -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/directory.info\"\n", "echo \"broken symlinks(find -L . -maxdepth 5 -type l -ls):\" 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/directory.info\"\n", "find -L . -maxdepth 5 -type l -ls 1>>\"/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/directory.info\"\n", "echo \"Launching container\"\n", "exec /bin/bash -c \"$JAVA_HOME/bin/java -Djava.net.preferIPv4Stack=true -Dhadoop.metrics.log.level=WARN -Xmx820m -Djava.io.tmpdir=$PWD/tmp -Dlog4j.configuration=container-log4j.properties -Dyarn.app.container.log.dir=/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007 -Dyarn.app.container.log.filesize=0 -Dhadoop.root.logger=INFO,CLA -Dhadoop.root.logfile=syslog -Dyarn.app.mapreduce.shuffle.logger=INFO,shuffleCLA -Dyarn.app.mapreduce.shuffle.logfile=syslog.shuffle -Dyarn.app.mapreduce.shuffle.log.filesize=0 -Dyarn.app.mapreduce.shuffle.log.backups=0 org.apache.hadoop.mapred.YarnChild 127.0.0.1 40041 attempt_1722798834650_0001_r_000000_0 7 1>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/stdout 2>/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-logDir-nm-0_1/application_1722798834650_0001/container_1722798834650_0001_01_000007/stderr \"\n", "\n", "End of LogType:launch_container.sh\n", "************************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000007 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.err\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:prelaunch.err\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000007 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:prelaunch.out\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:100\n", "LogContents:\n", "Setting up env variables\n", "Setting up job resources\n", "Copying debugging information\n", "Launching container\n", "\n", "End of LogType:prelaunch.out\n", "******************************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000007 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stderr\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stderr\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000007 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:stdout\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:0\n", "LogContents:\n", "\n", "End of LogType:stdout\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000007 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:syslog\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:31103\n", "LogContents:\n", "2024-08-04 19:14:53,552 INFO [main] org.apache.hadoop.security.SecurityUtil: Updating Configuration\n", "2024-08-04 19:14:53,885 INFO [main] org.apache.hadoop.metrics2.impl.MetricsConfig: Loaded properties from hadoop-metrics2.properties\n", "2024-08-04 19:14:54,218 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Scheduled Metric snapshot period at 10 second(s).\n", "2024-08-04 19:14:54,218 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: ReduceTask metrics system started\n", "2024-08-04 19:14:54,418 INFO [main] org.apache.hadoop.mapred.YarnChild: Executing with tokens: [Kind: mapreduce.job, Service: job_1722798834650_0001, Ident: (org.apache.hadoop.mapreduce.security.token.JobTokenIdentifier@1fa1cab1)]\n", "2024-08-04 19:14:54,585 INFO [main] org.apache.hadoop.mapred.YarnChild: Sleeping for 0ms before retrying again. Got null now.\n", "2024-08-04 19:14:55,264 INFO [main] org.apache.hadoop.mapred.YarnChild: mapreduce.cluster.local.dir for child: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_0/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_1/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001,/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_3/usercache/root/appcache/application_1722798834650_0001\n", "2024-08-04 19:14:56,558 INFO [main] org.apache.hadoop.mapred.YarnChild: \n", "/************************************************************\n", "[system properties]\n", "os.name: Linux\n", "os.version: 6.1.85+\n", "java.home: /usr/lib/jvm/java-11-openjdk-amd64\n", "java.runtime.version: 11.0.24+8-post-Ubuntu-1ubuntu322.04\n", "java.vendor: Ubuntu\n", "java.version: 11.0.24\n", "java.vm.name: OpenJDK 64-Bit Server VM\n", "java.class.path: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000007:/content/hadoop-3.4.0/etc/hadoop:/content/hadoop-3.4.0/share/hadoop/common/hadoop-kms-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/hadoop-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsp-api-2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/bcprov-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-api-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/slf4j-reload4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jul-to-slf4j-1.7.36.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/common/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-httpfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-client-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-nfs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-rbf-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/hadoop-hdfs-native-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/j2objc-annotations-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-guava-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-beanutils-1.9.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsch-0.1.55.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-io-2.14.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-all-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-cli-1.5.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/woodstox-core-5.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-servlet-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/json-simple-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/token-provider-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-crypto-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-logging-1.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-buffer-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-auth-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/guava-27.0-jre.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-xdr-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-proxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/re2j-1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-memcache-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-ajax-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-text-1.10.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/HikariCP-4.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/metrics-core-3.2.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-unix-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/avro-1.9.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/reload4j-1.2.22.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-configuration2-2.8.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-math3-3.6.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-daemon-1.0.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-core-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-codec-1.15.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-xml-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-lang3-3.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/animal-sniffer-annotations-1.17.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-api-2.2.11.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-client-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jettison-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-config-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-server-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-redis-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-asn1-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-identity-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-udt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-ssl-ocsp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/gson-2.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr305-3.0.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-framework-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-databind-2.12.7.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-stomp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpcore-4.4.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-socks-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-annotations-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jackson-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-kqueue-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-webapp-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-admin-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/curator-recipes-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-server-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerby-pkix-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jsr311-api-1.1.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jaxb-impl-2.2.3-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-xml-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/javax.servlet-api-3.1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-classes-epoll-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-io-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-haproxy-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-http-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jline-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/checker-qual-2.5.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-client-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-simplekdc-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-core-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/leveldbjni-all-1.8.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-util-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-http2-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-collections-3.2.2.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jakarta.activation-api-1.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-classes-macos-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-rxtx-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/zookeeper-jute-3.8.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jetty-security-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-net-3.9.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-dns-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/failureaccess-1.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/commons-compress-1.24.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/stax2-api-4.2.1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-core-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jersey-json-1.20.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/audience-annotations-0.12.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/dnsjava-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/nimbus-jose-jwt-9.31.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-util-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-handler-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/kerb-common-2.0.3.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/hadoop-shaded-protobuf_3_21-1.2.0.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/httpclient-4.5.13.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-mqtt-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-kqueue-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-native-epoll-4.1.100.Final-linux-x86_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-codec-smtp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/snappy-java-1.1.10.4.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-common-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/jcip-annotations-1.0-1.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-resolver-dns-native-macos-4.1.100.Final-osx-aarch_64.jar:/content/hadoop-3.4.0/share/hadoop/hdfs/lib/netty-transport-sctp-4.1.100.Final.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-mawo-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-resourcemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-web-proxy-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-router-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-timeline-pluginstorage-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-sharedcachemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-distributedshell-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-applications-unmanaged-am-launcher-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-client-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-applicationhistoryservice-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-registry-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-nodemanager-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-globalpolicygenerator-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-services-api-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/hadoop-yarn-server-tests-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jakarta.xml.bind-api-2.3.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-plus-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/objenesis-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-module-jaxb-annotations-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/protobuf-java-2.5.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.inject-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/swagger-annotations-1.5.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jna-5.2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-client-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcpkix-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/snakeyaml-2.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/commons-lang-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-servlet-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/mssql-jdbc-6.2.1.jre7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/aopalliance-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/codemodel-2.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/geronimo-jcache_1.0_spec-1.0-alpha-1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-tree-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-api-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/ehcache-3.3.1.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-client-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/bcutil-jdk15on-1.70.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/fst-2.50.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-client-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax.websocket-api-1.0.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/guice-4.2.3.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jsonschema2pojo-core-1.0.2.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-common-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-jndi-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/asm-commons-9.6.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/javax-websocket-server-impl-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-guice-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jersey-client-1.19.4.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-servlet-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jetty-annotations-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-json-provider-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/jackson-jaxrs-base-2.12.7.jar:/content/hadoop-3.4.0/share/hadoop/yarn/lib/websocket-server-9.4.53.v20231009.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-uploader-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-shuffle-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-common-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/mockito-core-2.28.2.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-app-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.4.0-tests.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-nativetask-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/hadoop-mapreduce-client-hs-plugins-3.4.0.jar:/content/hadoop-3.4.0/share/hadoop/mapreduce/lib/*:job.jar/job.jar:job.jar/classes/:job.jar/lib/*:/content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000007/job.jar\n", "java.io.tmpdir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000007/tmp\n", "user.dir: /content/target/test/data/MiniHadoopClusterManager/yarn-857754/MiniHadoopClusterManager-localDir-nm-0_2/usercache/root/appcache/application_1722798834650_0001/container_1722798834650_0001_01_000007\n", "user.name: root\n", "************************************************************/\n", "2024-08-04 19:14:56,559 INFO [main] org.apache.hadoop.conf.Configuration.deprecation: session.id is deprecated. Instead, use dfs.metrics.session-id\n", "2024-08-04 19:14:57,910 INFO [main] org.apache.hadoop.mapreduce.lib.output.PathOutputCommitterFactory: No output committer factory defined, defaulting to FileOutputCommitterFactory\n", "2024-08-04 19:14:57,914 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: File Output Committer Algorithm version is 2\n", "2024-08-04 19:14:57,915 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: FileOutputCommitter skip cleanup _temporary folders under output directory:false, ignore cleanup failures: false\n", "2024-08-04 19:14:57,986 INFO [main] org.apache.hadoop.mapred.Task: Using ResourceCalculatorProcessTree : [ ]\n", "2024-08-04 19:14:58,019 INFO [main] org.apache.hadoop.mapred.ReduceTask: Using ShuffleConsumerPlugin: org.apache.hadoop.mapreduce.task.reduce.Shuffle@889d9e8\n", "2024-08-04 19:14:58,022 WARN [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: ReduceTask metrics system already initialized!\n", "2024-08-04 19:14:58,788 INFO [main] org.apache.hadoop.conf.Configuration.deprecation: mapred.skip.on is deprecated. Instead, use mapreduce.job.skiprecords\n", "2024-08-04 19:14:59,138 INFO [main] org.apache.hadoop.mapred.Task: Task:attempt_1722798834650_0001_r_000000_0 is done. And is in the process of committing\n", "2024-08-04 19:14:59,160 INFO [main] org.apache.hadoop.mapred.Task: Task attempt_1722798834650_0001_r_000000_0 is allowed to commit now\n", "2024-08-04 19:14:59,189 INFO [main] org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter: Saved output of task 'attempt_1722798834650_0001_r_000000_0' to hdfs://localhost:8902/user/root/QuasiMonteCarlo_1722798838891_1650860168/out\n", "2024-08-04 19:14:59,217 INFO [main] org.apache.hadoop.mapred.Task: Task 'attempt_1722798834650_0001_r_000000_0' done.\n", "2024-08-04 19:14:59,241 INFO [main] org.apache.hadoop.mapred.Task: Final Counters for attempt_1722798834650_0001_r_000000_0: Counters: 35\n", "\tFile System Counters\n", "\t\tFILE: Number of bytes read=116\n", "\t\tFILE: Number of bytes written=309493\n", "\t\tFILE: Number of read operations=0\n", "\t\tFILE: Number of large read operations=0\n", "\t\tFILE: Number of write operations=0\n", "\t\tHDFS: Number of bytes read=0\n", "\t\tHDFS: Number of bytes written=215\n", "\t\tHDFS: Number of read operations=5\n", "\t\tHDFS: Number of large read operations=0\n", "\t\tHDFS: Number of write operations=3\n", "\t\tHDFS: Number of bytes read erasure-coded=0\n", "\tMap-Reduce Framework\n", "\t\tCombine input records=0\n", "\t\tCombine output records=0\n", "\t\tReduce input groups=2\n", "\t\tReduce shuffle bytes=140\n", "\t\tReduce input records=10\n", "\t\tReduce output records=0\n", "\t\tSpilled Records=10\n", "\t\tShuffled Maps =5\n", "\t\tFailed Shuffles=0\n", "\t\tMerged Map outputs=5\n", "\t\tGC time elapsed (ms)=92\n", "\t\tCPU time spent (ms)=1050\n", "\t\tPhysical memory (bytes) snapshot=217210880\n", "\t\tVirtual memory (bytes) snapshot=2730729472\n", "\t\tTotal committed heap usage (bytes)=216006656\n", "\t\tPeak Reduce Physical memory (bytes)=217210880\n", "\t\tPeak Reduce Virtual memory (bytes)=2730729472\n", "\tShuffle Errors\n", "\t\tBAD_ID=0\n", "\t\tCONNECTION=0\n", "\t\tIO_ERROR=0\n", "\t\tWRONG_LENGTH=0\n", "\t\tWRONG_MAP=0\n", "\t\tWRONG_REDUCE=0\n", "\tFile Output Format Counters \n", "\t\tBytes Written=97\n", "2024-08-04 19:14:59,243 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: Stopping ReduceTask metrics system...\n", "2024-08-04 19:14:59,243 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: ReduceTask metrics system stopped.\n", "2024-08-04 19:14:59,243 INFO [main] org.apache.hadoop.metrics2.impl.MetricsSystemImpl: ReduceTask metrics system shutdown complete.\n", "\n", "End of LogType:syslog\n", "***********************************************************************\n", "\n", "Container: container_1722798834650_0001_01_000007 on localhost_34535\n", "LogAggregationType: AGGREGATED\n", "====================================================================\n", "LogType:syslog.shuffle\n", "LogLastModifiedTime:Sun Aug 04 19:15:07 +0000 2024\n", "LogLength:4984\n", "LogContents:\n", "2024-08-04 19:14:58,045 INFO [main] org.apache.hadoop.mapreduce.task.reduce.MergeManagerImpl: MergerManager: memoryLimit=601882624, maxSingleShuffleLimit=150470656, mergeThreshold=397242560, ioSortFactor=10, memToMemMergeOutputsThreshold=10\n", "2024-08-04 19:14:58,048 INFO [EventFetcher for fetching Map Completion Events] org.apache.hadoop.mapreduce.task.reduce.EventFetcher: attempt_1722798834650_0001_r_000000_0 Thread started: EventFetcher for fetching Map Completion Events\n", "2024-08-04 19:14:58,069 INFO [EventFetcher for fetching Map Completion Events] org.apache.hadoop.mapreduce.task.reduce.EventFetcher: attempt_1722798834650_0001_r_000000_0: Got 5 new map-outputs\n", "2024-08-04 19:14:58,348 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.Fetcher: fetcher#1 about to shuffle output of map attempt_1722798834650_0001_m_000001_0 decomp: 24 len: 28 to MEMORY\n", "2024-08-04 19:14:58,359 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.InMemoryMapOutput: Read 24 bytes from map-output for attempt_1722798834650_0001_m_000001_0\n", "2024-08-04 19:14:58,362 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.MergeManagerImpl: closeInMemoryFile -> map-output of size: 24, inMemoryMapOutputs.size() -> 1, commitMemory -> 0, usedMemory ->24\n", "2024-08-04 19:14:58,370 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.Fetcher: fetcher#1 about to shuffle output of map attempt_1722798834650_0001_m_000000_0 decomp: 24 len: 28 to MEMORY\n", "2024-08-04 19:14:58,370 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.InMemoryMapOutput: Read 24 bytes from map-output for attempt_1722798834650_0001_m_000000_0\n", "2024-08-04 19:14:58,372 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.MergeManagerImpl: closeInMemoryFile -> map-output of size: 24, inMemoryMapOutputs.size() -> 2, commitMemory -> 24, usedMemory ->48\n", "2024-08-04 19:14:58,374 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.Fetcher: fetcher#1 about to shuffle output of map attempt_1722798834650_0001_m_000003_0 decomp: 24 len: 28 to MEMORY\n", "2024-08-04 19:14:58,375 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.InMemoryMapOutput: Read 24 bytes from map-output for attempt_1722798834650_0001_m_000003_0\n", "2024-08-04 19:14:58,375 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.MergeManagerImpl: closeInMemoryFile -> map-output of size: 24, inMemoryMapOutputs.size() -> 3, commitMemory -> 48, usedMemory ->72\n", "2024-08-04 19:14:58,378 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.Fetcher: fetcher#1 about to shuffle output of map attempt_1722798834650_0001_m_000002_0 decomp: 24 len: 28 to MEMORY\n", "2024-08-04 19:14:58,378 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.InMemoryMapOutput: Read 24 bytes from map-output for attempt_1722798834650_0001_m_000002_0\n", "2024-08-04 19:14:58,378 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.MergeManagerImpl: closeInMemoryFile -> map-output of size: 24, inMemoryMapOutputs.size() -> 4, commitMemory -> 72, usedMemory ->96\n", "2024-08-04 19:14:58,379 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.Fetcher: fetcher#1 about to shuffle output of map attempt_1722798834650_0001_m_000004_0 decomp: 24 len: 28 to MEMORY\n", "2024-08-04 19:14:58,379 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.InMemoryMapOutput: Read 24 bytes from map-output for attempt_1722798834650_0001_m_000004_0\n", "2024-08-04 19:14:58,379 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.MergeManagerImpl: closeInMemoryFile -> map-output of size: 24, inMemoryMapOutputs.size() -> 5, commitMemory -> 96, usedMemory ->120\n", "2024-08-04 19:14:58,381 INFO [EventFetcher for fetching Map Completion Events] org.apache.hadoop.mapreduce.task.reduce.EventFetcher: EventFetcher is interrupted.. Returning\n", "2024-08-04 19:14:58,381 INFO [fetcher#1] org.apache.hadoop.mapreduce.task.reduce.ShuffleSchedulerImpl: localhost:43847 freed by fetcher#1 in 312ms\n", "2024-08-04 19:14:58,394 INFO [main] org.apache.hadoop.mapreduce.task.reduce.MergeManagerImpl: finalMerge called with 5 in-memory map-outputs and 0 on-disk map-outputs\n", "2024-08-04 19:14:58,423 INFO [main] org.apache.hadoop.mapred.Merger: Merging 5 sorted segments\n", "2024-08-04 19:14:58,423 INFO [main] org.apache.hadoop.mapred.Merger: Down to the last merge-pass, with 5 segments left of total size: 105 bytes\n", "2024-08-04 19:14:58,440 INFO [main] org.apache.hadoop.mapreduce.task.reduce.MergeManagerImpl: Merged 5 segments, 120 bytes to disk to satisfy reduce memory limit\n", "2024-08-04 19:14:58,447 INFO [main] org.apache.hadoop.mapreduce.task.reduce.MergeManagerImpl: Merging 1 files, 116 bytes from disk\n", "2024-08-04 19:14:58,448 INFO [main] org.apache.hadoop.mapreduce.task.reduce.MergeManagerImpl: Merging 0 segments, 0 bytes from memory into reduce\n", "2024-08-04 19:14:58,448 INFO [main] org.apache.hadoop.mapred.Merger: Merging 1 sorted segments\n", "2024-08-04 19:14:58,486 INFO [main] org.apache.hadoop.mapred.Merger: Down to the last merge-pass, with 1 segments left of total size: 109 bytes\n", "\n", "End of LogType:syslog.shuffle\n", "*******************************************************************************\n", "\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "2024-08-04 19:15:45,913 INFO client.DefaultNoHARMFailoverProxyProvider: Connecting to ResourceManager at localhost/127.0.0.1:8903\n" ] } ] }, { "cell_type": "code", "source": [], "metadata": { "id": "tiDceHeBGInO" }, "execution_count": 81, "outputs": [] } ] }