/**
   * Fetch participants of TaskUpdate. Is called on creation of a new instance of TaskUpdate.
   *
   * @param repoUid the specified repository's identifier.
   * @return new Object[] with length of 2. The first item is a vector of Links that content is
   *     containing ComputerRemotes that are online and participating at the specified repository.
   *     <p>The second entry contains a link between the local computer and the specified
   *     repository.
   */
  private Object[] fetchTaskupdateParticipants(String repoUid) {

    Vector<Link> vec_parti = new Vector<Link>();
    Link ownRepoLink = null;

    for (int j = 0; j < combination.size(); j++) {

      final Link secondLnk = getCombination().get(j);

      if (secondLnk.getRepository().getUid().equals(repoUid)) {

        // inform the specified computer about the
        // changes
        final Computer currentComputer = secondLnk.getComputer();
        if (!currentComputer.matches(ComputerLocal.this)
            && currentComputer instanceof ComputerRemote) {

          vec_parti.addElement(secondLnk);
        } else if (currentComputer.getUid().equals(getUid())) {
          ownRepoLink = secondLnk;
        }
      }
    }

    return new Object[] {vec_parti, ownRepoLink};
  }
  @RequestMapping(value = "/update/{id}", method = RequestMethod.POST)
  public String update(
      @PathVariable Long id,
      @RequestParam(required = false) String name,
      @RequestParam(required = false) String introduced,
      @RequestParam(required = false) String discontinued,
      @RequestParam(required = false) String company,
      ModelMap model,
      RedirectAttributes redirectAttributes) {
    ComputerForm form = new ComputerForm();
    form.setId(id);
    form.setName(name);
    form.setIntroduced(introduced);
    form.setDiscontinued(discontinued);
    form.setCompany(company);

    if (!form.isValid()) {
      model.addAttribute("form", form);
      model.addAttribute("companies", companyService.findAll());

      return "/edit";
    } else {
      Computer computer = form.toComputer();
      computer = computerService.update(computer);

      redirectAttributes.addFlashAttribute(
          "success", "Computer with id " + computer.getId() + " has been updated");

      return "redirect:/computers";
    }
  }
Exemple #3
0
  public void testQueryComputers() throws Exception {
    String[] classNames = {
      "ctf.jdo.tc9x.Laptop", "ctf.jdo.tc9x.Laptop", "ctf.jdo.tc9x.Server", "ctf.jdo.tc9x.Server"
    };

    Database database = _category.getDatabase();

    database.begin();
    OQLQuery query =
        database.getOQLQuery(
            "select computer from "
                + Computer.class.getName()
                + " as computer order by computer.id");
    QueryResults results = query.execute();

    if (results.hasMore()) {
      int counter = 1;
      while (results.hasMore()) {
        Computer computer = (Computer) results.next();
        assertNotNull(computer);
        assertEquals(counter, computer.getId());
        assertEquals(classNames[counter - 1], computer.getClass().getName());

        counter += 1;
      }
    } else {
      fail("Query does not return any Computer instances.");
    }
    database.commit();

    database.close();
  }
Exemple #4
0
 public static void main(String[] args) {
   Computer computer = new Desktop(new Dell());
   computer.sale();
   computer = new Pad(new Dell());
   computer.sale();
   computer = new Notebook(new Dell());
   computer.sale();
 }
  /**
   * Adds an all-in-one computer (combined with four freely customizable parts) to the cart.
   *
   * @param article requested all-in-one computer
   * @param number the amount of requested articles
   * @param cart contains a fresh initialized cart
   * @param success notification about adding an article to the cart
   * @return redirect to template "allinone"
   */
  @RequestMapping(value = "/cart2", method = RequestMethod.POST)
  public String addcomp(
      @RequestParam("pid") Computer article,
      @RequestParam("number") int number,
      @ModelAttribute Cart cart,
      RedirectAttributes success) {

    Optional<InventoryItem> item = inventory.findByProductIdentifier(article.getIdentifier());

    Quantity quantity = item.map(InventoryItem::getQuantity).orElse(NONE);
    BigDecimal amount1 = quantity.getAmount();
    int i = amount1.intValue();
    int amount = number;
    if (number <= 0) {
      amount = 1;
    }
    if (number >= i) {
      amount = i;
    }

    cart.addOrUpdateItem(article, Quantity.of(amount));
    cart.addOrUpdateItem(article.getProzessor().get(0), Quantity.of(amount));
    cart.addOrUpdateItem(article.getGraka().get(0), Quantity.of(amount));
    cart.addOrUpdateItem(article.getHdd().get(0), Quantity.of(amount));
    cart.addOrUpdateItem(article.getRam().get(0), Quantity.of(amount));

    article.getGraka().clear();
    article.getHdd().clear();
    article.getProzessor().clear();
    article.getRam().clear();

    success.addFlashAttribute(
        "success", "Der Artikel wurde erfolgreich Ihrem Warenkorb hinzugefügt.");
    return "redirect:allinone";
  }
Exemple #6
0
  public void testCreateAndLoadComputer() throws Exception {
    Database database = _category.getDatabase();

    database.begin();
    Order order = new Order();
    order.setId(12);
    order.setName("order 12");
    database.create(order);
    database.commit();

    database.begin();
    ProductDetail detail = new ProductDetail();
    detail.setId(12);
    detail.setCategory("category 12");
    detail.setLocation("location 12");
    database.create(detail);
    database.commit();

    database.begin();
    Laptop laptop = new Laptop();
    laptop.setId(12);
    laptop.setName("laptop 12");
    laptop.setCpu("centrino");
    laptop.setResolution("1600");
    laptop.setWeight(2450);
    laptop.setDetail((ProductDetail) database.load(ProductDetail.class, new Integer(12)));
    database.create(laptop);
    Collection orders = new LinkedList();
    orders.add(database.load(Order.class, new Integer(12)));
    laptop.setOrders(orders);
    database.commit();

    database.begin();
    Computer computer = (Computer) database.load(Computer.class, new Integer(12));
    database.commit();

    assertNotNull(computer);
    assertEquals("ctf.jdo.tc9x.Laptop", computer.getClass().getName());
    assertEquals(12, computer.getId());
    assertEquals("laptop 12", computer.getName());

    database.begin();
    computer = (Computer) database.load(Computer.class, new Integer(12));
    database.remove(computer);
    database.remove(database.load(ProductDetail.class, new Integer(12)));
    database.remove(database.load(Order.class, new Integer(12)));
    database.commit();

    database.close();
  }
Exemple #7
0
  public void testLoadComputer() throws Exception {
    Database database = _category.getDatabase();

    database.begin();
    Computer computer = (Computer) database.load(Computer.class, new Integer(2));
    database.commit();

    assertNotNull(computer);
    assertEquals("ctf.jdo.tc9x.Laptop", computer.getClass().getName());
    assertEquals(2, computer.getId());
    assertEquals("laptop 2", computer.getName());

    database.close();
  }
  private Connection connectToSsh(Computer computer, PrintStream logger)
      throws RequestUnsuccessfulException, DigitalOceanException {

    final long timeout = TimeUnit2.MINUTES.toMillis(computer.getCloud().getTimeoutMinutes());
    final long startTime = System.currentTimeMillis();
    final int sleepTime = 10;

    long waitTime;

    while ((waitTime = System.currentTimeMillis() - startTime) < timeout) {

      // Hack to fetch this each time through the loop to get the latest information.
      final Droplet droplet =
          DigitalOcean.getDroplet(
              computer.getCloud().getAuthToken(), computer.getNode().getDropletId());

      if (isDropletStarting(droplet)) {
        logger.println(
            "Waiting for droplet to enter ACTIVE state. Sleeping " + sleepTime + " seconds.");
      } else {
        try {
          final String host = getIpAddress(computer);

          if (Strings.isNullOrEmpty(host) || "0.0.0.0".equals(host)) {
            logger.println(
                "No ip address yet, your host is most likely waiting for an ip address.");
          } else {
            int port = computer.getSshPort();

            Connection conn = getDropletConnection(host, port, logger);
            if (conn != null) {
              return conn;
            }
          }
        } catch (IOException e) {
          // Ignore, we'll retry.
        }
        logger.println("Waiting for SSH to come up. Sleeping " + sleepTime + " seconds.");
      }

      sleep(sleepTime);
    }

    throw new RuntimeException(
        format(
            "Timed out after %d seconds of waiting for ssh to become available (max timeout configured is %s)",
            waitTime / 1000, timeout / 1000));
  }
 /**
  * Creates the Peripherals frame.
  *
  * @param computer the computer control object
  * @param computerHardware the computer hardware object
  */
 public PeripheralsFrame(final Computer computer, final ComputerHardware computerHardware) {
   super(
       Application.getString(PeripheralsFrame.class, "peripherals.frameTitle"),
       computer.getIconLayout().getIcon(IconLayout.ICON_POSITION_CABLE));
   log.fine("New PeripheralsFrame creation started");
   assert computerHardware != null;
   peripherals =
       new Peripheral[] {
         new IOPanel(computerHardware),
         new LEDMatrix(),
         new ColorLEDMatrix(),
         new SiSDMatrix(),
         new PCKeyboard(),
         new ADC(),
         new DACAnalog(),
         new DACDigital(),
         new Counter(),
         new DebugOutput()
       };
   peripheralsPanel = new PeripheralsPanel(this, peripherals);
   add(peripheralsPanel);
   setUp();
   pack();
   log.fine("PeripheralsFrame set up");
 }
  @RequestMapping(value = "/save", method = RequestMethod.POST)
  public String save(
      @ModelAttribute Computer computer,
      BindingResult result,
      SessionStatus status,
      ModelMap model,
      RedirectAttributes redirectAttributes) {
    computerValidator.validate(computer, result);

    if (result.hasErrors()) {
      model.addAttribute("computer", computer);
      model.addAttribute("companies", companyService.findAll());
      model.addAttribute("result", result);

      return "/create";
    } else {
      computer = computerService.create(computer);

      status.setComplete();

      redirectAttributes.addFlashAttribute(
          "success", "Computer named " + computer.getName() + " has been created");

      return "redirect:/computers";
    }
  }
 protected boolean execute(int address, String expectedOutput) {
   boolean isSuccess = false;
   Cpu cpu = computer.getCpu();
   cpu.writeRegister(false, Cpu.PC, address);
   long startTime = System.currentTimeMillis();
   while ((System.currentTimeMillis() - startTime) < MAX_EXECUTION_TIME
       || terminal.getWrittenData().length() > Terminal.MAX_DATA_LENGTH) {
     try {
       cpu.executeNextOperation();
       if (cpu.isHaltMode()) {
         throw new IllegalStateException("HALT mode");
       }
     } catch (Exception e) {
       e.printStackTrace();
       fail(
           "can't execute operation, PC: 0"
               + Integer.toOctalString(cpu.readRegister(false, Cpu.PC)));
     }
     if (expectedOutput.equals(terminal.getWrittenData())) {
       isSuccess = true;
       break;
     }
   }
   return isSuccess;
 }
  public void createTables(DatabaseSession session) {
    dropTableConstraints(session);
    new InheritanceTableCreator().replaceTables(session);

    SchemaManager schemaManager = new SchemaManager(session);
    if (session.getLogin().getPlatform().isOracle()) {
      schemaManager.replaceObject(Computer.oracleView());
      schemaManager.replaceObject(Vehicle.oracleView());
    } else if (session.getLogin().getPlatform().isSybase()) {
      schemaManager.replaceObject(Computer.sybaseView());
      schemaManager.replaceObject(Vehicle.sybaseView());
      // CREATE VIEW statement was added in MySQL 5.0.1.  Uncomment it when we support MySQL 5
      // } else if (session.getLogin().getPlatform().isMySQL()) {
      // schemaManager.replaceObject(Computer.sybaseView());
      // schemaManager.replaceObject(Vehicle.mySQLView());
    }
  }
Exemple #13
0
 public static Request classes(Computer computer, Class<?>... classes) {
   try {
     return runner(computer.getSuite(new AllDefaultPossibilitiesBuilder(true), classes));
   } catch (InitializationError e) {
     throw new RuntimeException(
         "Bug in saff's brain: Suite constructor, called as above, should always complete");
   }
 }
 /**
  * Create a <code>Request</code> that, when processed, will run all the tests in a set of classes.
  *
  * @param computer Helps construct Runners from classes
  * @param classes the classes containing the tests
  * @return a <code>Request</code> that will cause all tests in the classes to be run
  */
 public static Request classes(Computer computer, Class<?>... classes) {
   try {
     AllDefaultPossibilitiesBuilder builder = new AllDefaultPossibilitiesBuilder(true);
     Runner suite = computer.getSuite(builder, classes);
     return runner(suite);
   } catch (InitializationError e) {
     return runner(new ErrorReportingRunner(e, classes));
   }
 }
  /**
   * In addition to the usual observer behavior, the addObserver fires a notify event on startup.
   *
   * <p>{@inheritDoc}.
   *
   * @param xo the observer that is to be set.
   * @author Julius Huelsmann
   * @version %I%, %U%
   * @since 1.0
   */
  public final void addObserver(final Observer xo) {
    super.addObserver(xo);

    setChanged();
    notifyObservers(new Object[] {View.ID_UPDATE_LINK, combination});
    setChanged();
    notifyObservers(new Object[] {View.ID_UPDATE_REPO, repositories});
    setChanged();
    notifyObservers(new Object[] {View.ID_UPDATE_COMPUTER, computer});
  }
  private static String getIpAddress(Computer computer)
      throws RequestUnsuccessfulException, DigitalOceanException {
    Droplet instance = computer.updateInstanceDescription();

    for (final Network network : instance.getNetworks().getVersion4Networks()) {
      String host = network.getIpAddress();
      if (host != null) {
        return host;
      }
    }

    return null;
  }
 /**
  * The player with "theSeed" makes one move, with input validation. Update cell's content, board's
  * currentRow and currentCol.
  */
 public void playerMove(Seed theSeed) {
   boolean validInput = false; // for validating input
   boolean loop = true;
   int row = -1;
   int col = -1;
   do {
     if (theSeed == Seed.NOUGHT) {
       System.out.println("Your turn");
       do {
         System.out.print("Enter your move (row[0-2] column[0-2]): ");
         String r = in.next();
         String c = in.next();
         try {
           row = Integer.parseInt(r);
           col = Integer.parseInt(c);
           loop = false;
         } catch (NumberFormatException e) {
           System.out.println("Invalid input");
         }
       } while (loop);
       if (row >= 0
           && row < Board.ROWS
           && col >= 0
           && col < Board.COLS
           && board.cells[row][col].content == Seed.EMPTY) {
         board.cells[row][col].content = theSeed;
         board.currentRow = row;
         board.currentCol = col;
         validInput = true; // input okay, exit loop
       } else {
         System.out.println(
             "This move at (" + (row) + "," + (col) + ") is not valid. Try again...");
       }
     } else {
       row = comp.move();
       col = comp.move();
       if (row >= 0
           && row < Board.ROWS
           && col >= 0
           && col < Board.COLS
           && board.cells[row][col].content == Seed.EMPTY) {
         board.cells[row][col].content = theSeed;
         board.currentRow = row;
         board.currentCol = col;
         validInput = true; // input okay, exit loop
       }
     }
   } while (!validInput); // repeat until input is valid
 }
  private void execute() {
    if (sourceFile == null) {
      printError("-i : No source file specified");
    }

    if (assembler == null || computer == null) {
      printError("-f : No format specified");
    }

    if (assembler.hasErrors()) {
      printError("Unable to execute file due to errors");
    }

    print("...preparing to execute program");

    if (trace) {
      print("...opening computer trace files");
      addTraceListeners();
    }

    computer.setExecutionSpeed(ExecutionSpeed.FULL);
    computer.setInstructions(assembler.getInstructions());

    computer.addComputerListener(
        new ComputerAdapter() {
          public void computerStarted(Computer computer) {
            print("...Execution started");
          }

          public void computerStopped(Computer computer) {
            print("...Execution complete");
          }
        });

    computer.execute();
  }
Exemple #19
0
 /** @param args */
 public static void main(String[] args) {
   Computer computer = new Computer();
   Component component = new Component(1, "dell");
   computer.setComponent(component);
   computer.setType("D630");
   try {
     Computer computer2 = (Computer) computer.clone();
     System.out.println(computer2.toString());
     component.setName("Lenovo");
     System.out.println(computer2.toString());
     System.out.println(computer == computer2);
   } catch (CloneNotSupportedException e) {
     e.printStackTrace();
   }
 }
 /** @throws java.lang.Exception */
 @Before
 public void setUp() throws Exception {
   computer = new Computer();
   computer.setClockFrequency(Computer.CLOCK_FREQUENCY_BK0010);
   workMemory = new RandomAccessMemory("TestWorkMemory", 0, 020000);
   computer.addMemory(workMemory);
   RandomAccessMemory videoMemory = new RandomAccessMemory("TestVideoMemory", 040000, 020000);
   computer.addMemory(videoMemory);
   computer.addMemory(new ReadOnlyMemory("TestReadOnlyMemory", 0100000, new byte[010000]));
   terminal = new Terminal();
   computer.addDevice(terminal);
   computer.getCpu().setPswState(0);
   computer.getCpu().writeRegister(false, Cpu.SP, 020000);
   computer.getCpu().writeRegister(false, Cpu.PC, 4);
 }
Exemple #21
0
  @Test
  @SuppressWarnings("unchecked")
  public void shouldIncludeParents() {

    deleteFromTable("computers");
    deleteFromTable("motherboards");
    deleteFromTable("keyboards");

    populateTable("motherboards");
    populateTable("keyboards");
    populateTable("computers");

    String json = Computer.findAll().include(Motherboard.class, Keyboard.class).toJson(true);
    List list = org.javalite.common.JsonHelper.toList(json);
    Map m = (Map) list.get(0);
    Map parents = (Map) m.get("parents");
    List motherboards = (List) parents.get("motherboards");
    List keyboards = (List) parents.get("keyboards");
    the(motherboards.size()).shouldBeEqual(1);
    the(keyboards.size()).shouldBeEqual(1);
  }
  private boolean runInitScript(
      final Computer computer, final PrintStream logger, final Connection conn, final SCPClient scp)
      throws IOException, InterruptedException {

    String initScript = Util.fixEmptyAndTrim(computer.getNode().getInitScript());

    if (initScript == null) {
      return true;
    }
    if (conn.exec("test -e ~/.hudson-run-init", logger) == 0) {
      return true;
    }

    logger.println("Executing init script");
    scp.put(initScript.getBytes("UTF-8"), "init.sh", "/tmp", "0700");
    Session session = conn.openSession();
    session.requestDumbPTY(); // so that the remote side bundles stdout and stderr
    session.execCommand(buildUpCommand(computer, "/tmp/init.sh"));

    session.getStdin().close(); // nothing to write here
    session.getStderr().close(); // we are not supposed to get anything from stderr
    IOUtils.copy(session.getStdout(), logger);

    int exitStatus = waitCompletion(session);
    if (exitStatus != 0) {
      logger.println("init script failed: exit code=" + exitStatus);
      return false;
    }
    session.close();

    // Needs a tty to run sudo.
    session = conn.openSession();
    session.requestDumbPTY(); // so that the remote side bundles stdout and stderr
    session.execCommand(buildUpCommand(computer, "touch ~/.hudson-run-init"));
    session.close();

    return true;
  }
Exemple #23
0
  public static void main(String[] args) {
    ApplicationContext context =
        new ClassPathXmlApplicationContext("step04/application-context02.xml");

    Computer c1 = (Computer) context.getBean("c1");
    Computer c2 = (Computer) context.getBean("c2");
    Computer c3 = (Computer) context.getBean("c3");
    System.out.println(c1);
    System.out.println(c2);
    System.out.println(c3);

    System.out.println(c1.getMonitor().hashCode());
    System.out.println(c3.getMonitor().hashCode());

    if (c1.getMonitor() == c3.getMonitor()) {
      System.out.println("c1의 모니터 == c3의 모니터");
    }
  }
 private static void printSpecs(ArrayList<Computer> computerList) {
   // print specs for reference
   DecimalFormat price = new DecimalFormat("$0.00");
   DecimalFormat speed = new DecimalFormat("0.0 GHz");
   DecimalFormat memory = new DecimalFormat("0.0 GB");
   for (Computer c : computerList) {
     System.out.println(
         "Model: "
             + c.getModel()
             + " | Memory: "
             + memory.format(c.getMemory())
             + " | Speed: "
             + speed.format(c.getSpeed())
             + " | GraphicsCard: "
             + c.getCard()
             + " | Price: "
             + price.format(c.getPrice()));
     System.out.println();
   }
 }
  public void populate(DatabaseSession session) {
    PopulationManager manager = PopulationManager.getDefaultManager();

    Cat cat = Cat.example1();
    session.writeObject(cat);
    manager.registerObject(cat, "catExample1");

    Dog dog = Dog.example1();
    session.writeObject(dog);
    manager.registerObject(dog, "dogExample1");

    cat = Cat.example2();
    session.writeObject(cat);
    manager.registerObject(cat, "catExample2");

    dog = Dog.example2();
    session.writeObject(dog);
    manager.registerObject(dog, "dogExample2");

    cat = Cat.example3();
    session.writeObject(cat);
    manager.registerObject(cat, "catExample3");

    dog = Dog.example3();
    session.writeObject(dog);
    manager.registerObject(dog, "dogExample3");

    Company company = Company.example1();
    session.writeObject(company);
    manager.registerObject(company, "example1");

    manager.registerObject(((Vector) company.getVehicles().getValue()).firstElement(), "example1");

    company = Company.example2();
    session.writeObject(company);
    manager.registerObject(company, "example2");

    company = Company.example3();
    session.writeObject(company);
    manager.registerObject(company, "example3");

    Person person = Person.example1();
    session.writeObject(person);
    manager.registerObject(person, "example1");

    // populate the data for duplicate field testing
    session.writeObject(A_King2.exp1());
    session.writeObject(A_King2.exp2());
    session.writeObject(A_1_King2.exp3());
    session.writeObject(A_2_King2.exp4());
    session.writeObject(A_2_1_King2.exp5());

    UnitOfWork unitOfWork = session.acquireUnitOfWork();
    person = Person.example2();
    unitOfWork.registerObject(person);
    unitOfWork.commit();
    manager.registerObject(person, "example2");
    manager.registerObject(person.bestFriend, "example5");
    manager.registerObject(person.representitive, "example4");

    person = Person.example3();
    session.writeObject(person);
    manager.registerObject(person, "example3");

    Computer computer = Computer.example1();
    session.writeObject(computer);
    manager.registerObject(computer, "example1");

    computer = Computer.example2();
    session.writeObject(computer);
    manager.registerObject(computer, "example2");

    computer = Computer.example3();
    session.writeObject(computer);
    manager.registerObject(computer, "example3");

    computer = Computer.example4();
    session.writeObject(computer);
    manager.registerObject(computer, "example4");

    computer = Computer.example5();
    session.writeObject(computer);
    manager.registerObject(computer, "example5");

    JavaProgrammer JP = JavaProgrammer.example1();
    session.writeObject(JP);
    manager.registerObject(JP, "example1");

    JP = JavaProgrammer.example2();
    session.writeObject(JP);
    manager.registerObject(JP, "example2");

    // Added to test bug 3019934.
    unitOfWork = session.acquireUnitOfWork();
    Alligator alligator = new Alligator();
    alligator.setFavoriteSwamp("Florida");
    alligator.setLatestVictim(JavaProgrammer.steve());
    unitOfWork.registerObject(alligator);
    manager.registerObject(alligator, "example1");
    unitOfWork.commit();

    // Added to test bug 6111278

    unitOfWork = session.acquireUnitOfWork();
    Entomologist bugguy = new Entomologist();
    bugguy.setId((int) System.currentTimeMillis());
    bugguy.setName("Gary");
    bugguy = (Entomologist) unitOfWork.registerObject(bugguy);
    Insect insect = new GrassHopper();
    insect.setIn_numberOfLegs(4);
    insect.setEntomologist(bugguy);
    bugguy.getInsectCollection().add(insect);
    unitOfWork.commit();
  }
Exemple #26
0
 @Override
 public String description() {
   return comp.description() + "and disk";
 }
 protected void perform(Computer computer) {
   computer.getRegisters().getCx().set(computer.getOperandValue(1));
 }
Exemple #28
0
  public static void main(String[] args) {

    Computer facade = new Computer();
    facade.start();
  }
  /**
   * Connects to the given {@link Computer} via SSH and installs Java/Jenkins agent if necessary.
   */
  @Override
  public void launch(SlaveComputer _computer, TaskListener listener) {

    Computer computer = (Computer) _computer;
    PrintStream logger = listener.getLogger();

    Date startDate = new Date();
    logger.println("Start time: " + getUtcDate(startDate));

    final Connection conn;
    Connection cleanupConn = null;
    boolean successful = false;

    try {
      conn = connectToSsh(computer, logger);
      cleanupConn = conn;
      logger.println("Authenticating as " + computer.getRemoteAdmin());
      if (!conn.authenticateWithPublicKey(
          computer.getRemoteAdmin(), computer.getNode().getPrivateKey().toCharArray(), "")) {
        logger.println("Authentication failed");
        throw new Exception("Authentication failed");
      }

      final SCPClient scp = conn.createSCPClient();

      if (!runInitScript(computer, logger, conn, scp)) {
        return;
      }

      if (!installJava(logger, conn)) {
        return;
      }

      logger.println("Copying slave.jar");
      scp.put(Jenkins.getInstance().getJnlpJars("slave.jar").readFully(), "slave.jar", "/tmp");
      String jvmOpts = Util.fixNull(computer.getNode().getJvmOpts());
      String launchString = "java " + jvmOpts + " -jar /tmp/slave.jar";
      logger.println("Launching slave agent: " + launchString);
      final Session sess = conn.openSession();
      sess.execCommand(launchString);
      computer.setChannel(
          sess.getStdout(),
          sess.getStdin(),
          logger,
          new Channel.Listener() {
            @Override
            public void onClosed(Channel channel, IOException cause) {
              sess.close();
              conn.close();
            }
          });

      successful = true;
    } catch (Exception e) {
      LOGGER.log(Level.WARNING, e.getMessage(), e);
      try {
        Jenkins.getInstance().removeNode(computer.getNode());
      } catch (Exception ee) {
        ee.printStackTrace(logger);
      }
      e.printStackTrace(logger);
    } finally {
      Date endDate = new Date();
      logger.println("Done setting up at: " + getUtcDate(endDate));
      logger.println(
          "Done in "
              + TimeUnit2.MILLISECONDS.toSeconds(endDate.getTime() - startDate.getTime())
              + " seconds");
      if (cleanupConn != null && !successful) {
        cleanupConn.close();
      }
    }
  }
 protected String buildUpCommand(Computer computer, String command) {
   if (!computer.getRemoteAdmin().equals("root")) {
     //            command = computer.getRootCommandPrefix() + " " + command;
   }
   return command;
 }