Example usage for org.apache.hadoop.yarn.api.records ContainerLaunchContext setEnvironment

List of usage examples for org.apache.hadoop.yarn.api.records ContainerLaunchContext setEnvironment

Introduction

In this page you can find the example usage for org.apache.hadoop.yarn.api.records ContainerLaunchContext setEnvironment.

Prototype

@Public
@Stable
public abstract void setEnvironment(Map<String, String> environment);

Source Link

Document

Add environment variables for the container.

Usage

From source file:org.springframework.yarn.examples.CustomAppmaster.java

License:Apache License

@Override
public ContainerLaunchContext preLaunch(Container container, ContainerLaunchContext context) {
    ContainerId containerId = container.getId();
    Integer attempt = 1;/*from   w w w. j a v  a2s .c  o  m*/
    ContainerId failedContainerId = failed.poll();
    Object assignedData = (failedContainerId != null ? getContainerAssign().getAssignedData(failedContainerId)
            : null);
    if (assignedData != null) {
        attempt = (Integer) assignedData;
        attempt += 1;
    }
    getContainerAssign().assign(containerId, attempt);

    Map<String, String> env = new HashMap<String, String>(context.getEnvironment());
    env.put("customappmaster_attempt", attempt.toString());
    context.setEnvironment(env);
    return context;
}

From source file:org.springframework.yarn.examples.ThriftHeartbeatAppmaster.java

License:Apache License

@Override
public ContainerLaunchContext preLaunch(ContainerLaunchContext context) {
    log.info("preLaunch: " + context);

    AppmasterService service = getAppmasterService();
    if (service != null) {
        int port = service.getPort();
        String address = service.getHost();
        Map<String, String> env = new HashMap<String, String>(context.getEnvironment());
        env.put(YarnSystemConstants.AMSERVICE_PORT, Integer.toString(port));
        env.put(YarnSystemConstants.AMSERVICE_HOST, address);
        // for now always use same id
        env.put("syarn.amservice.nodeid", "1");
        context.setEnvironment(env);
        return context;
    } else {// ww  w .jav  a 2 s.  c o  m
        return context;
    }

    // below uncommented code is from other example which
    // tracked failed containers by assigning 'some' data
    // with container id order to have some understanding
    // what was the actual task container was doing.
    //
    // I believe we should add similar info to thrift
    // so that when heartbeat system notifies that container is
    // down, we'd know which container was it and what
    // was it doing.

    //      ContainerId containerId = context.getContainerId();
    //      Integer attempt = 1;
    //      ContainerId failedContainerId = failed.poll();
    //      Object assignedData = (failedContainerId != null ? getContainerAssing().getAssignedData(failedContainerId) : null);
    //      if (assignedData != null) {
    //         attempt = (Integer) assignedData;
    //         attempt += 1;
    //      }
    //      getContainerAssing().assign(containerId, attempt);
    //
    //      Map<String, String> env = new HashMap<String, String>(context.getEnvironment());
    //      env.put("customappmaster.attempt", attempt.toString());
    //      context.setEnvironment(env);
    //      return context;
}

From source file:org.springframework.yarn.examples.XdAppmaster.java

License:Apache License

@Override
public ContainerLaunchContext preLaunch(ContainerLaunchContext context) {
    if (log.isDebugEnabled()) {
        log.debug("preLaunch: " + context);
    }/*w ww  .  j  a va  2  s  .c  om*/

    AppmasterService service = getAppmasterService();
    if (service != null) {
        int port = service.getPort();
        String address = service.getHost();
        Map<String, String> env = new HashMap<String, String>(context.getEnvironment());
        env.put(YarnSystemConstants.AMSERVICE_PORT, Integer.toString(port));
        env.put(YarnSystemConstants.AMSERVICE_HOST, address);
        env.put(YarnSystemConstants.SYARN_CONTAINER_ID, ConverterUtils.toString(context.getContainerId()));
        //         String xdGroup = getManagedGroups().findGroupNameByMember(ConverterUtils.toString(context.getContainerId()));
        String xdGroup = getManagedGroups().getGroupByMember(ConverterUtils.toString(context.getContainerId()))
                .getId();
        env.put("syarn.cg.group", xdGroup != null ? xdGroup : "");
        context.setEnvironment(env);

        // testing
        try {
            Credentials credentials = new Credentials();
            credentials.addSecretKey(new Text(YarnSystemConstants.SYARN_SEC_SESSIONID), sessionId.getBytes());
            DataOutputBuffer dob = new DataOutputBuffer();
            credentials.writeTokenStorageToStream(dob);
            ByteBuffer containerToken = ByteBuffer.wrap(dob.getData(), 0, dob.getLength());
            context.setContainerTokens(containerToken);
        } catch (IOException e) {
            log.error("XXX error setContainerTokens", e);
        }

        return context;
    } else {
        return context;
    }
}

From source file:proxyyarn.ProxyYarn.java

License:Apache License

public boolean run() throws Exception {
    Configuration conf = new YarnConfiguration(new Configuration());

    YarnClient yarnClient = YarnClient.createYarnClient();
    yarnClient.init(conf);//w  w w.ja v  a  2s  .co m
    yarnClient.start();

    YarnClusterMetrics clusterMetrics = yarnClient.getYarnClusterMetrics();
    log.info("Got Cluster metric info from ASM" + ", numNodeManagers=" + clusterMetrics.getNumNodeManagers());

    List<NodeReport> clusterNodeReports = yarnClient.getNodeReports(NodeState.RUNNING);
    log.info("Got Cluster node info from ASM");
    for (NodeReport node : clusterNodeReports) {
        log.info("Got node report from ASM for" + ", nodeId=" + node.getNodeId() + ", nodeAddress"
                + node.getHttpAddress() + ", nodeRackName" + node.getRackName() + ", nodeNumContainers"
                + node.getNumContainers());
    }

    QueueInfo queueInfo = yarnClient.getQueueInfo("default");
    log.info("Queue info" + ", queueName=" + queueInfo.getQueueName() + ", queueCurrentCapacity="
            + queueInfo.getCurrentCapacity() + ", queueMaxCapacity=" + queueInfo.getMaximumCapacity()
            + ", queueApplicationCount=" + queueInfo.getApplications().size() + ", queueChildQueueCount="
            + queueInfo.getChildQueues().size());

    List<QueueUserACLInfo> listAclInfo = yarnClient.getQueueAclsInfo();
    for (QueueUserACLInfo aclInfo : listAclInfo) {
        for (QueueACL userAcl : aclInfo.getUserAcls()) {
            log.info("User ACL Info for Queue" + ", queueName=" + aclInfo.getQueueName() + ", userAcl="
                    + userAcl.name());
        }
    }

    FileSystem fs = FileSystem.get(conf);
    if (!fs.getClass().equals(DistributedFileSystem.class)) {
        log.error("Expected DistributedFileSystem, but was {}", fs.getClass().getSimpleName());
        System.exit(1);
    }

    //    ApplicationClientProtocol applicationsManager;
    //    InetSocketAddress rmAddress = NetUtils.createSocketAddr(yarnConf.get(YarnConfiguration.RM_ADDRESS, YarnConfiguration.DEFAULT_RM_ADDRESS));

    //    log.info("Connecting to ResourceManager at {}", rmAddress);
    //    Configuration appManagerServerConf = new Configuration(conf);
    //    YarnRPC rpc = YarnRPC.create(appManagerServerConf);
    //    ApplicationClientProtocol applicationManager = (ApplicationClientProtocol) rpc.getProxy(ApplicationClientProtocol.class, rmAddress, appManagerServerConf);

    String appName = "AccumuloProxyYarn";
    YarnClientApplication app = yarnClient.createApplication();

    // set the application name
    ApplicationSubmissionContext appContext = app.getApplicationSubmissionContext();
    ApplicationId appId = appContext.getApplicationId();
    appContext.setApplicationName(appName);

    //    GetNewApplicationRequest request = Records.newRecord(GetNewApplicationRequest.class);
    //    GetNewApplicationResponse response = applicationManager.getNewApplication(request);
    //    log.info("Got new ApplicationId=" + response.getApplicationId());

    //    ApplicationId appId = response.getApplicationId();

    // Create a new ApplicationSubmissionContext
    //    ApplicationSubmissionContext appContext = Records.newRecord(ApplicationSubmissionContext.class);
    // set the ApplicationId
    //    appContext.setApplicationId(appId);
    // set the application name
    //    appContext.setApplicationName(appName);

    // Create a new container launch context for the AM's container
    ContainerLaunchContext amContainer = Records.newRecord(ContainerLaunchContext.class);

    // Define the local resources required
    Map<String, LocalResource> localResources = new HashMap<String, LocalResource>();

    // Lets assume the jar we need for our ApplicationMaster is available in
    // HDFS at a certain known path to us and we want to make it available to
    // the ApplicationMaster in the launched container
    Path localJarPath = new Path(
            "file:///Users/jelser/projects/accumulo-proxy-yarn/target/accumulo-proxy-yarn-0.0.1-SNAPSHOT.jar");
    Path jarPath = new Path("hdfs:///accumulo-proxy-yarn-0.0.1-SNAPSHOT.jar");
    fs.copyFromLocalFile(false, true, localJarPath, jarPath);
    FileStatus jarStatus = fs.getFileStatus(jarPath);
    LocalResource amJarRsrc = Records.newRecord(LocalResource.class);

    // Set the type of resource - file or archive
    // archives are untarred at the destination by the framework
    amJarRsrc.setType(LocalResourceType.FILE);

    // Set visibility of the resource
    // Setting to most private option i.e. this file will only
    // be visible to this instance of the running application
    amJarRsrc.setVisibility(LocalResourceVisibility.APPLICATION);

    // Set the location of resource to be copied over into the
    // working directory
    amJarRsrc.setResource(ConverterUtils.getYarnUrlFromPath(jarPath));

    // Set timestamp and length of file so that the framework
    // can do basic sanity checks for the local resource
    // after it has been copied over to ensure it is the same
    // resource the client intended to use with the application
    amJarRsrc.setTimestamp(jarStatus.getModificationTime());
    amJarRsrc.setSize(jarStatus.getLen());

    // The framework will create a symlink called AppMaster.jar in the
    // working directory that will be linked back to the actual file.
    // The ApplicationMaster, if needs to reference the jar file, would
    // need to use the symlink filename.
    localResources.put("AppMaster.jar", amJarRsrc);

    // Set the local resources into the launch context
    amContainer.setLocalResources(localResources);

    // Set up the environment needed for the launch context
    Map<String, String> env = new HashMap<String, String>();

    // For example, we could setup the classpath needed.
    // Assuming our classes or jars are available as local resources in the
    // working directory from which the command will be run, we need to append
    // "." to the path.
    // By default, all the hadoop specific classpaths will already be available
    // in $CLASSPATH, so we should be careful not to overwrite it.
    String classPathEnv = "$CLASSPATH:./*:/Users/jelser/projects/accumulo-proxy-yarn/target/lib/*";
    env.put("CLASSPATH", classPathEnv);
    amContainer.setEnvironment(env);

    // Construct the command to be executed on the launched container
    String command = "${JAVA_HOME}" + "/bin/java" + " proxyyarn.ProxyYarnAppMaster 1>"
            + ApplicationConstants.LOG_DIR_EXPANSION_VAR + "/stdout" + " 2>"
            + ApplicationConstants.LOG_DIR_EXPANSION_VAR + "/stderr";

    List<String> commands = new ArrayList<String>();
    commands.add(command);
    // add additional commands if needed

    // Set the command array into the container spec
    amContainer.setCommands(commands);

    // Define the resource requirements for the container
    // For now, YARN only supports memory so we set the memory
    // requirements.
    // If the process takes more than its allocated memory, it will
    // be killed by the framework.
    // Memory being requested for should be less than max capability
    // of the cluster and all asks should be a multiple of the min capability.
    Resource capability = Records.newRecord(Resource.class);
    capability.setMemory(256);
    appContext.setResource(capability);

    // Create the request to send to the ApplicationsManager
    //    SubmitApplicationRequest appRequest = Records.newRecord(SubmitApplicationRequest.class);
    //    appRequest.setApplicationSubmissionContext(appContext);

    // Submit the application to the ApplicationsManager
    // Ignore the response as either a valid response object is returned on
    // success or an exception thrown to denote the failure
    //    applicationManager.submitApplication(appRequest);

    // Set the container launch content into the ApplicationSubmissionContext
    appContext.setAMContainerSpec(amContainer);

    // Set the priority for the application master
    Priority pri = Records.newRecord(Priority.class);
    // TODO - what is the range for priority? how to decide? 
    pri.setPriority(0);
    appContext.setPriority(pri);

    // Set the queue to which this application is to be submitted in the RM
    appContext.setQueue("default");

    // Submit the application to the applications manager
    // SubmitApplicationResponse submitResp = applicationsManager.submitApplication(appRequest);
    // Ignore the response as either a valid response object is returned on success 
    // or an exception thrown to denote some form of a failure
    log.info("Submitting application to ASM");

    yarnClient.submitApplication(appContext);

    return monitorApplication(yarnClient, appId);
    /*    Thread.sleep(200);
                
        boolean running = false;
        while(true) {
          GetApplicationReportRequest reportRequest = Records.newRecord(GetApplicationReportRequest.class);
          reportRequest.setApplicationId(appId);
          GetApplicationReportResponse reportResponse = applicationManager.getApplicationReport(reportRequest);
          ApplicationReport report = reportResponse.getApplicationReport();
                  
          log.info(report.toString());
                  
          YarnApplicationState state = report.getYarnApplicationState();
          switch (state) {
            case NEW:
            case NEW_SAVING:
            case SUBMITTED:
            case ACCEPTED:
              log.info("State: {}", state);
              break;
            case RUNNING:
              log.info("Running application");
              running = true;
              break;
            case FINISHED:
            case FAILED:
            case KILLED:
              log.info("State: {}", state);
              return;
            default:
              log.info("Unknown state: {}", state);
              return;
          }
                  
          if (!running) {
            Thread.sleep(1000);
          }
        }*/

}

From source file:runtime.starter.MPJAppMaster.java

License:Open Source License

public void run() throws Exception {
    try {/*from w w  w  . ja va2s .  co  m*/
        appMasterSock = new Socket(serverName, ioServerPort);

        //redirecting stdout and stderr
        System.setOut(new PrintStream(appMasterSock.getOutputStream(), true));
        System.setErr(new PrintStream(appMasterSock.getOutputStream(), true));
    } catch (Exception exp) {
        exp.printStackTrace();
    }

    FileSystem fs = FileSystem.get(conf);
    Path wrapperDest = new Path(wrapperPath);
    FileStatus destStatus = fs.getFileStatus(wrapperDest);

    Path userFileDest = new Path(userJarPath);
    FileStatus destStatusClass = fs.getFileStatus(userFileDest);

    // Initialize AM <--> RM communication protocol
    AMRMClient<ContainerRequest> rmClient = AMRMClient.createAMRMClient();
    rmClient.init(conf);
    rmClient.start();

    // Initialize AM <--> NM communication protocol
    NMClient nmClient = NMClient.createNMClient();
    nmClient.init(conf);
    nmClient.start();

    // Register with ResourceManager
    RegisterApplicationMasterResponse registerResponse = rmClient.registerApplicationMaster("", 0, "");
    // Priority for containers - priorities are intra-application
    Priority priority = Records.newRecord(Priority.class);
    priority.setPriority(mpjContainerPriority);

    maxMem = registerResponse.getMaximumResourceCapability().getMemory();

    if (debugYarn) {
        System.out.println("[MPJAppMaster]: Max memory capability resources " + "in cluster: " + maxMem);
    }

    if (containerMem > maxMem) {
        System.out.println("[MPJAppMaster]: container  memory specified above "
                + "threshold of cluster! Using maximum memory for " + "containers: " + containerMem);
        containerMem = maxMem;
    }

    maxCores = registerResponse.getMaximumResourceCapability().getVirtualCores();

    if (debugYarn) {
        System.out.println("[MPJAppMaster]: Max v-cores capability resources " + "in cluster: " + maxCores);
    }

    if (containerCores > maxCores) {
        System.out.println("[MPJAppMaster]: virtual cores specified above "
                + "threshold of cluster! Using maximum v-cores for " + "containers: " + containerCores);
        containerCores = maxCores;
    }

    // Resource requirements for containers
    Resource capability = Records.newRecord(Resource.class);
    capability.setMemory(containerMem);
    capability.setVirtualCores(containerCores);

    // Make container requests to ResourceManager
    for (int i = 0; i < np; ++i) {
        ContainerRequest containerReq = new ContainerRequest(capability, null, null, priority);

        rmClient.addContainerRequest(containerReq);
    }

    Map<String, LocalResource> localResources = new HashMap<String, LocalResource>();
    // Creating Local Resource for Wrapper   
    LocalResource wrapperJar = Records.newRecord(LocalResource.class);

    wrapperJar.setResource(ConverterUtils.getYarnUrlFromPath(wrapperDest));
    wrapperJar.setSize(destStatus.getLen());
    wrapperJar.setTimestamp(destStatus.getModificationTime());
    wrapperJar.setType(LocalResourceType.ARCHIVE);
    wrapperJar.setVisibility(LocalResourceVisibility.APPLICATION);

    // Creating Local Resource for UserClass
    LocalResource userClass = Records.newRecord(LocalResource.class);

    userClass.setResource(ConverterUtils.getYarnUrlFromPath(userFileDest));
    userClass.setSize(destStatusClass.getLen());
    userClass.setTimestamp(destStatusClass.getModificationTime());
    userClass.setType(LocalResourceType.ARCHIVE);
    userClass.setVisibility(LocalResourceVisibility.APPLICATION);

    localResources.put("mpj-yarn-wrapper.jar", wrapperJar);
    localResources.put("user-code.jar", userClass);

    while (allocatedContainers < np) {
        AllocateResponse response = rmClient.allocate(0);
        mpiContainers.addAll(response.getAllocatedContainers());
        allocatedContainers = mpiContainers.size();

        if (allocatedContainers != np) {
            Thread.sleep(100);
        }
    }

    if (debugYarn) {
        System.out.println("[MPJAppMaster]: launching " + allocatedContainers + " containers");
    }

    for (Container container : mpiContainers) {

        ContainerLaunchContext ctx = Records.newRecord(ContainerLaunchContext.class);

        List<String> commands = new ArrayList<String>();

        commands.add(" $JAVA_HOME/bin/java");
        commands.add(" -Xmx" + containerMem + "m");
        commands.add(" runtime.starter.MPJYarnWrapper");
        commands.add("--serverName");
        commands.add(serverName); // server name
        commands.add("--ioServerPort");
        commands.add(Integer.toString(ioServerPort)); // IO server port
        commands.add("--deviceName");
        commands.add(deviceName); // device name
        commands.add("--className");
        commands.add(className); // class name
        commands.add("--psl");
        commands.add(psl); // protocol switch limit
        commands.add("--np");
        commands.add(Integer.toString(np)); // no. of containers
        commands.add("--rank");
        commands.add(" " + Integer.toString(rank++)); // rank

        //temp sock port to share rank and ports
        commands.add("--wireUpPort");
        commands.add(wireUpPort);

        if (appArgs != null) {
            commands.add("--appArgs");
            for (int i = 0; i < appArgs.length; i++) {
                commands.add(appArgs[i]);
            }
        }

        ctx.setCommands(commands);

        // Set local resource for containers
        ctx.setLocalResources(localResources);

        // Set environment for container
        Map<String, String> containerEnv = new HashMap<String, String>();
        setupEnv(containerEnv);
        ctx.setEnvironment(containerEnv);

        // Time to start the container
        nmClient.startContainer(container, ctx);

    }

    while (completedContainers < np) {
        // argument to allocate() is the progress indicator
        AllocateResponse response = rmClient.allocate(completedContainers / np);

        for (ContainerStatus status : response.getCompletedContainersStatuses()) {
            if (debugYarn) {
                System.out.println("\n[MPJAppMaster]: Container Id - " + status.getContainerId());
                System.out.println("[MPJAppMaster]: Container State - " + status.getState().toString());
                System.out.println("[MPJAppMaster]: Container Diagnostics - " + status.getDiagnostics());

            }
            ++completedContainers;
        }

        if (completedContainers != np) {
            Thread.sleep(100);
        }
        ;
    }
    // Un-register with ResourceManager 
    rmClient.unregisterApplicationMaster(FinalApplicationStatus.SUCCEEDED, "", "");
    //shutDown AppMaster IO
    System.out.println("EXIT");
}

From source file:runtime.starter.MPJYarnClient.java

License:Open Source License

public void run() throws Exception {

    Map<String, String> map = System.getenv();

    try {/*ww  w  . jav  a 2 s  .c o m*/
        mpjHomeDir = map.get("MPJ_HOME");

        if (mpjHomeDir == null) {
            throw new Exception("[MPJRun.java]:MPJ_HOME environment found..");
        }
    } catch (Exception exc) {
        System.out.println("[MPJRun.java]:" + exc.getMessage());
        exc.printStackTrace();
        return;
    }

    // Copy the application master jar to HDFS
    // Create a local resource to point to the destination jar path
    FileSystem fs = FileSystem.get(conf);
    /*
          Path dataset = new Path(fs.getHomeDirectory(),"/dataset");
          FileStatus datasetFile = fs.getFileStatus(dataset);
                 
          BlockLocation myBlocks [] = fs.getFileBlockLocations(datasetFile,0,datasetFile.getLen());
          for(BlockLocation b : myBlocks){
            System.out.println("\n--------------------");
            System.out.println("Length "+b.getLength());
            for(String host : b.getHosts()){
              System.out.println("host "+host);
            }
          }
    */
    Path source = new Path(mpjHomeDir + "/lib/mpj-app-master.jar");
    String pathSuffix = hdfsFolder + "mpj-app-master.jar";
    Path dest = new Path(fs.getHomeDirectory(), pathSuffix);

    if (debugYarn) {
        logger.info("Uploading mpj-app-master.jar to: " + dest.toString());
    }

    fs.copyFromLocalFile(false, true, source, dest);
    FileStatus destStatus = fs.getFileStatus(dest);

    Path wrapperSource = new Path(mpjHomeDir + "/lib/mpj-yarn-wrapper.jar");
    String wrapperSuffix = hdfsFolder + "mpj-yarn-wrapper.jar";
    Path wrapperDest = new Path(fs.getHomeDirectory(), wrapperSuffix);

    if (debugYarn) {
        logger.info("Uploading mpj-yarn-wrapper.jar to: " + wrapperDest.toString());
    }

    fs.copyFromLocalFile(false, true, wrapperSource, wrapperDest);

    Path userJar = new Path(jarPath);
    String userJarSuffix = hdfsFolder + "user-code.jar";
    Path userJarDest = new Path(fs.getHomeDirectory(), userJarSuffix);

    if (debugYarn) {
        logger.info("Uploading user-code.jar to: " + userJarDest.toString());
    }

    fs.copyFromLocalFile(false, true, userJar, userJarDest);

    YarnConfiguration conf = new YarnConfiguration();
    YarnClient yarnClient = YarnClient.createYarnClient();
    yarnClient.init(conf);
    yarnClient.start();

    if (debugYarn) {
        YarnClusterMetrics metrics = yarnClient.getYarnClusterMetrics();
        logger.info("\nNodes Information");
        logger.info("Number of NM: " + metrics.getNumNodeManagers() + "\n");

        List<NodeReport> nodeReports = yarnClient.getNodeReports(NodeState.RUNNING);
        for (NodeReport n : nodeReports) {
            logger.info("NodeId: " + n.getNodeId());
            logger.info("RackName: " + n.getRackName());
            logger.info("Total Memory: " + n.getCapability().getMemory());
            logger.info("Used Memory: " + n.getUsed().getMemory());
            logger.info("Total vCores: " + n.getCapability().getVirtualCores());
            logger.info("Used vCores: " + n.getUsed().getVirtualCores() + "\n");
        }
    }

    logger.info("Creating server socket at HOST " + serverName + " PORT " + serverPort + " \nWaiting for " + np
            + " processes to connect...");

    // Creating a server socket for incoming connections
    try {
        servSock = new ServerSocket(serverPort);
        infoSock = new ServerSocket();
        TEMP_PORT = findPort(infoSock);
    } catch (Exception e) {
        e.printStackTrace();
    }

    // Create application via yarnClient
    YarnClientApplication app = yarnClient.createApplication();
    GetNewApplicationResponse appResponse = app.getNewApplicationResponse();

    int maxMem = appResponse.getMaximumResourceCapability().getMemory();

    if (debugYarn) {
        logger.info("Max memory capability resources in cluster: " + maxMem);
    }

    if (amMem > maxMem) {
        amMem = maxMem;
        logger.info("AM memory specified above threshold of cluster "
                + "Using maximum memory for AM container: " + amMem);
    }
    int maxVcores = appResponse.getMaximumResourceCapability().getVirtualCores();

    if (debugYarn) {
        logger.info("Max vCores capability resources in cluster: " + maxVcores);
    }

    if (amCores > maxVcores) {
        amCores = maxVcores;
        logger.info("AM virtual cores specified above threshold of cluster "
                + "Using maximum virtual cores for AM container: " + amCores);
    }

    // Set up the container launch context for the application master
    ContainerLaunchContext amContainer = Records.newRecord(ContainerLaunchContext.class);

    List<String> commands = new ArrayList<String>();
    commands.add("$JAVA_HOME/bin/java");
    commands.add("-Xmx" + amMem + "m");
    commands.add("runtime.starter.MPJAppMaster");
    commands.add("--np");
    commands.add(String.valueOf(np));
    commands.add("--serverName");
    commands.add(serverName); //server name
    commands.add("--ioServerPort");
    commands.add(Integer.toString(serverPort)); //server port
    commands.add("--deviceName");
    commands.add(deviceName); //device name
    commands.add("--className");
    commands.add(className); //class name
    commands.add("--wdir");
    commands.add(workingDirectory); //wdir
    commands.add("--psl");
    commands.add(Integer.toString(psl)); //protocol switch limit
    commands.add("--wireUpPort");
    commands.add(String.valueOf(TEMP_PORT)); //for sharing ports & rank
    commands.add("--wrapperPath");
    commands.add(wrapperDest.toString());//MPJYarnWrapper.jar HDFS path
    commands.add("--userJarPath");
    commands.add(userJarDest.toString());//User Jar File HDFS path
    commands.add("--mpjContainerPriority");
    commands.add(mpjContainerPriority);// priority for mpj containers 
    commands.add("--containerMem");
    commands.add(containerMem);
    commands.add("--containerCores");
    commands.add(containerCores);

    if (debugYarn) {
        commands.add("--debugYarn");
    }

    if (appArgs != null) {

        commands.add("--appArgs");

        for (int i = 0; i < appArgs.length; i++) {
            commands.add(appArgs[i]);
        }
    }

    amContainer.setCommands(commands); //set commands

    // Setup local Resource for ApplicationMaster
    LocalResource appMasterJar = Records.newRecord(LocalResource.class);

    appMasterJar.setResource(ConverterUtils.getYarnUrlFromPath(dest));
    appMasterJar.setSize(destStatus.getLen());
    appMasterJar.setTimestamp(destStatus.getModificationTime());
    appMasterJar.setType(LocalResourceType.ARCHIVE);
    appMasterJar.setVisibility(LocalResourceVisibility.APPLICATION);

    amContainer.setLocalResources(Collections.singletonMap("mpj-app-master.jar", appMasterJar));

    // Setup CLASSPATH for ApplicationMaster
    // Setting up the environment
    Map<String, String> appMasterEnv = new HashMap<String, String>();
    setupAppMasterEnv(appMasterEnv);
    amContainer.setEnvironment(appMasterEnv);

    // Set up resource type requirements for ApplicationMaster
    Resource capability = Records.newRecord(Resource.class);
    capability.setMemory(amMem);
    capability.setVirtualCores(amCores);

    // Finally, set-up ApplicationSubmissionContext for the application
    ApplicationSubmissionContext appContext = app.getApplicationSubmissionContext();

    appContext.setApplicationName(appName);
    appContext.setAMContainerSpec(amContainer);
    appContext.setResource(capability);
    appContext.setQueue(yarnQueue); // queue

    Priority priority = Priority.newInstance(amPriority);
    appContext.setPriority(priority);

    ApplicationId appId = appContext.getApplicationId();

    //Adding ShutDown Hook
    Runtime.getRuntime().addShutdownHook(new KillYarnApp(appId, yarnClient));

    // Submit application
    System.out.println("Submitting Application: " + appContext.getApplicationName() + "\n");

    try {
        isRunning = true;
        yarnClient.submitApplication(appContext);
    } catch (Exception exp) {
        System.err.println("Error Submitting Application");
        exp.printStackTrace();
    }

    // np = number of processes , + 1 for Application Master container
    IOMessagesThread[] ioThreads = new IOMessagesThread[np + 1];

    peers = new String[np];
    socketList = new Vector<Socket>();
    int wport = 0;
    int rport = 0;
    int rank = 0;

    // np + 1 IOThreads
    for (int i = 0; i < (np + 1); i++) {
        try {
            sock = servSock.accept();

            //start IO thread to read STDOUT and STDERR from wrappers
            IOMessagesThread io = new IOMessagesThread(sock);
            ioThreads[i] = io;
            ioThreads[i].start();
        } catch (Exception e) {
            System.err.println("Error accepting connection from peer socket..");
            e.printStackTrace();
        }
    }

    // Loop to read port numbers from Wrapper.java processes
    // and to create WRAPPER_INFO (containing all IPs and ports)
    String WRAPPER_INFO = "#Peer Information";
    for (int i = np; i > 0; i--) {
        try {
            sock = infoSock.accept();

            DataOutputStream out = new DataOutputStream(sock.getOutputStream());
            DataInputStream in = new DataInputStream(sock.getInputStream());
            if (in.readUTF().startsWith("Sending Info")) {
                wport = in.readInt();
                rport = in.readInt();
                rank = in.readInt();
                peers[rank] = ";" + sock.getInetAddress().getHostAddress() + "@" + rport + "@" + wport + "@"
                        + rank;
                socketList.add(sock);
            }
        } catch (Exception e) {
            System.err.println("[MPJYarnClient.java]: Error accepting" + " connection from peer socket!");
            e.printStackTrace();
        }
    }

    for (int i = 0; i < np; i++) {
        WRAPPER_INFO += peers[i];
    }
    // Loop to broadcast WRAPPER_INFO to all Wrappers
    for (int i = np; i > 0; i--) {
        try {
            sock = socketList.get(np - i);
            DataOutputStream out = new DataOutputStream(sock.getOutputStream());

            out.writeUTF(WRAPPER_INFO);
            out.flush();

            sock.close();
        } catch (Exception e) {
            System.err.println("[MPJYarnClient.java]: Error closing" + " connection from peer socket..");
            e.printStackTrace();
        }
    }

    try {
        infoSock.close();
    } catch (IOException exp) {
        exp.printStackTrace();
    }

    // wait for all IO Threads to complete 
    for (int i = 0; i < (np + 1); i++) {
        ioThreads[i].join();
    }
    isRunning = true;

    System.out.println("\nApplication Statistics!");
    while (true) {
        appReport = yarnClient.getApplicationReport(appId);
        appState = appReport.getYarnApplicationState();
        fStatus = appReport.getFinalApplicationStatus();
        if (appState == YarnApplicationState.FINISHED) {
            isRunning = false;
            if (fStatus == FinalApplicationStatus.SUCCEEDED) {
                System.out.println("State: " + fStatus);
            } else {
                System.out.println("State: " + fStatus);
            }
            break;
        } else if (appState == YarnApplicationState.KILLED) {
            isRunning = false;
            System.out.println("State: " + appState);
            break;
        } else if (appState == YarnApplicationState.FAILED) {
            isRunning = false;
            System.out.println("State: " + appState);
            break;
        }
        Thread.sleep(100);
    }

    try {

        if (debugYarn) {
            logger.info("Cleaning the files from hdfs: ");
            logger.info("1) " + dest.toString());
            logger.info("2) " + wrapperDest.toString());
            logger.info("3) " + userJarDest.toString());
        }

        fs.delete(dest);
        fs.delete(wrapperDest);
        fs.delete(userJarDest);
    } catch (IOException exp) {
        exp.printStackTrace();
    }
    System.out.println("Application ID: " + appId + "\n" + "Application User: " + appReport.getUser() + "\n"
            + "RM Queue: " + appReport.getQueue() + "\n" + "Start Time: " + appReport.getStartTime() + "\n"
            + "Finish Time: " + appReport.getFinishTime());
}

From source file:tachyon.yarn.ApplicationMaster.java

License:Apache License

private void launchTachyonWorkerContainers(List<Container> containers) {
    final String command = new CommandBuilder(
            PathUtils.concatPath(mTachyonHome, "integration", "bin", "tachyon-worker-yarn.sh"))
                    .addArg("1>" + ApplicationConstants.LOG_DIR_EXPANSION_VAR + "/stdout")
                    .addArg("2>" + ApplicationConstants.LOG_DIR_EXPANSION_VAR + "/stderr").toString();

    List<String> commands = Lists.newArrayList(command);
    Map<String, String> environmentMap = new HashMap<String, String>();
    environmentMap.put("TACHYON_MASTER_ADDRESS", mMasterContainerNetAddress);
    environmentMap.put("TACHYON_WORKER_MEMORY_SIZE",
            FormatUtils.getSizeFromBytes((long) mRamdiskMemInMB * Constants.MB));

    for (Container container : containers) {
        if (mNumAllocatedWorkerContainers >= mNumWorkers) {
            break;
        }/*from   w  w w  .  j  a  v a 2s .  c  o  m*/
        try {
            // Launch container by create ContainerLaunchContext
            ContainerLaunchContext ctx = Records.newRecord(ContainerLaunchContext.class);
            ctx.setCommands(commands);
            ctx.setEnvironment(environmentMap);
            LOG.info("Launching container {} for Tachyon worker {} on {} with worker command: {}",
                    container.getId(), mNumAllocatedWorkerContainers, container.getNodeHttpAddress(), command);
            mNMClient.startContainer(container, ctx);
            mNumAllocatedWorkerContainers++;
        } catch (Exception ex) {
            LOG.error("Error launching container " + container.getId() + " " + ex);
        }
    }
}

From source file:yarnkit.container.ContainerLaunchContextFactory.java

License:Apache License

@Nonnull
public ContainerLaunchContext create(@Nonnull ContainerLaunchParameters parameters) throws YarnkitException {
    ContainerLaunchContext context = Records.newRecord(ContainerLaunchContext.class);
    context.setCommands(Collections.synchronizedList(parameters.getCommands()));
    context.setEnvironment(Collections.synchronizedMap(parameters.getEnvironment()));
    try {//from  w w w .ja v a  2  s. co  m
        context.setLocalResources(Collections.synchronizedMap(parameters.getLocalResources()));
    } catch (IOException e) {
        throw new YarnkitException("Failed to setLocalResource to ContainerLaunchContext", e);
    }
    if (securityTokens != null) {
        context.setTokens(securityTokens.duplicate());
    }
    return context;
}

From source file:yarnkit.container.ContainerLaunchContextFactory.java

License:Apache License

public ContainerLaunchContext duplicate(@CheckForNull ContainerLaunchContext original) {
    Preconditions.checkNotNull(original, "ContainerLaunchContext should not be null");

    ContainerLaunchContext copy = Records.newRecord(ContainerLaunchContext.class);
    copy.setCommands(original.getCommands());
    copy.setEnvironment(original.getEnvironment());
    copy.setLocalResources(original.getLocalResources());
    ByteBuffer token = original.getTokens();
    if (token != null) {
        copy.setTokens(token.duplicate());
    }//  w  ww  . jav a2s.c  o  m
    return copy;
}

From source file:yrun.YarnRunner.java

License:Apache License

public void execute() throws IOException, YarnException, InterruptedException {
    LOG.info("Using application path [" + _installPath + "]");
    Path jarPath = installThisJar(_installPath, _appJarFile);
    LOG.info("Driver installed [" + jarPath + "]");
    List<Path> installedArchivePathList = install(_installPath, _archivePathList);
    for (Path p : installedArchivePathList) {
        LOG.info("Archive installed [" + p + "]");
    }/*from  w  w w  . j a va2 s.c o  m*/

    YarnRunnerArgs yarnRunnerArgs = new YarnRunnerArgs();
    yarnRunnerArgs.setCommand(_command);

    Path argsPath = installThisArgs(_installPath, yarnRunnerArgs);

    final YarnClient client = YarnClient.createYarnClient();
    _configuration.setInt("yarn.nodemanager.delete.debug-delay-sec", (int) TimeUnit.HOURS.toSeconds(1));
    client.init(_configuration);
    client.start();

    YarnClientApplication app = client.createApplication();
    ContainerLaunchContext amContainer = Records.newRecord(ContainerLaunchContext.class);

    Map<String, String> appMasterEnv = new HashMap<String, String>();
    setupAppMasterEnv(appMasterEnv, _appJarFile);

    Map<String, LocalResource> localResources = new HashMap<String, LocalResource>();
    {
        LocalResource appMasterJar = Records.newRecord(LocalResource.class);
        setupAppMasterJar(jarPath, appMasterJar);
        localResources.put(jarPath.getName(), appMasterJar);
    }
    {
        LocalResource appMasterArgs = Records.newRecord(LocalResource.class);
        setupAppMasterArgs(argsPath, appMasterArgs);
        localResources.put(MASTER_JSON, appMasterArgs);
    }

    List<String> vargs = new ArrayList<String>();
    vargs.add(Environment.JAVA_HOME.$() + "/bin/java");
    vargs.add("-Xmx256m");
    vargs.add("-Djava.net.preferIPv4Stack=true");
    vargs.add(YarnRunnerApplicationMaster.class.getName());

    String strCommand = "(echo ENV && set && echo CURRENT_DIR_LISTING && ls -la && echo PWD && pwd && ("
            + StringUtils.join(" ", vargs) + "))";
    strCommand += " 1>" + ApplicationConstants.LOG_DIR_EXPANSION_VAR + "/stdout";
    strCommand += " 2>" + ApplicationConstants.LOG_DIR_EXPANSION_VAR + "/stderr";
    LOG.debug("Application Master command [" + strCommand + "]");

    amContainer.setCommands(Collections.singletonList(strCommand));
    amContainer.setLocalResources(localResources);
    amContainer.setEnvironment(appMasterEnv);

    Resource capability = Records.newRecord(Resource.class);
    capability.setMemory(256);
    capability.setVirtualCores(1);

    ApplicationSubmissionContext appContext = app.getApplicationSubmissionContext();
    appContext.setApplicationName(_yarnName);
    appContext.setAMContainerSpec(amContainer);
    appContext.setResource(capability);
    if (_queue != null) {
        appContext.setQueue(_queue);
    }
    appContext.setApplicationType("yrun");

    ApplicationId appId = appContext.getApplicationId();
    AtomicBoolean shutdown = new AtomicBoolean();
    if (!_isDaemon) {
        addShutdownHook(client, appId, shutdown);
    }

    LOG.info("Submitting application with id [" + appId + "]");
    client.submitApplication(appContext);
    ApplicationReport report;
    YarnApplicationState state;
    do {
        report = client.getApplicationReport(appId);
        state = report.getYarnApplicationState();
        if (state == YarnApplicationState.RUNNING) {
            if (_isDaemon) {
                LOG.info("Application is running.  This is a daemon application driver program exiting.");
                return;
            }
        }
        Thread.sleep(100);
    } while (isNoLongerRunning(state));
    shutdown.set(true);
    LOG.info("Application has finished with state [" + state + "]");
}