Exemplo n.º 1
0
 @GET
 @Produces(MediaType.APPLICATION_JSON)
 @Path("{nodeName}/status")
 public Response getStatus(@PathParam("nodeName") String nodeName) {
   Response response = null;
   try {
     org.nikhil.webapp.nodeadmin.entity.Node fetchedNode = nodeOperation.getNode(nodeName);
     String status = nodeOperation.getNodeStatus(nodeName, true);
     Object jsonObj = NodeAdminUtils.createObjectFromRawData("status", status, null);
     response =
         NodeAdminUtils.buildStandardRESTHTTPResponse(
             200, "Node " + nodeName + " Status Retrieved Successfully", status, null);
   } catch (Exception e) {
     e.printStackTrace();
     response =
         NodeAdminUtils.buildStandardRESTHTTPResponse(
             500, "Server Error getting the status of the Node " + nodeName, null, null);
   }
   return response;
 }
Exemplo n.º 2
0
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  public Response addNode(Node node) {
    Response response = null;
    try {
      org.nikhil.webapp.nodeadmin.entity.Node newNode = getJPANodeFromJSONNode(node);
      nodeOperation.addNode(newNode);
      response =
          NodeAdminUtils.buildStandardRESTHTTPResponse(
              201, "Node " + node.getName() + " Added Successfully", null, null);

    } catch (Exception e) {
      e.printStackTrace();
      response =
          NodeAdminUtils.buildStandardRESTHTTPResponse(500, "Server Error Adding Node", null, null);
    }
    return response;
  }
Exemplo n.º 3
0
 @GET
 @Produces(MediaType.APPLICATION_JSON)
 @Path("{nodeName}/stop")
 public Response stop(@PathParam("nodeName") String nodeName) {
   Response response = null;
   try {
     nodeOperation.reStartNode(nodeName);
     response =
         NodeAdminUtils.buildStandardRESTHTTPResponse(
             200, "Node " + nodeName + " Stopped Successfully", null, null);
   } catch (Exception e) {
     e.printStackTrace();
     response =
         NodeAdminUtils.buildStandardRESTHTTPResponse(
             500, "Server Error Stopping the Node " + nodeName, null, null);
   }
   return response;
 }
Exemplo n.º 4
0
  @DELETE
  @Produces(MediaType.APPLICATION_JSON)
  @Path("/{nodeName}")
  public Response deleteNode(@PathParam("nodeName") String nodeName) {
    Response response = null;
    try {
      nodeOperation.deleteNode(nodeName);
      response =
          NodeAdminUtils.buildStandardRESTHTTPResponse(
              200, "Node " + nodeName + " Deleted Successfully", null, null);

    } catch (Exception e) {
      e.printStackTrace();
      response =
          NodeAdminUtils.buildStandardRESTHTTPResponse(
              500, "Server Error Deleting Node", null, null);
    }

    return response;
  }
Exemplo n.º 5
0
  @GET
  @Produces(MediaType.APPLICATION_JSON)
  public Response getNodes() {
    Response response = null;

    try {
      List<Node> flattenedNodeList = new ArrayList<>();
      List<org.nikhil.webapp.nodeadmin.entity.Node> list = nodeOperation.listNodes();
      for (org.nikhil.webapp.nodeadmin.entity.Node node : list) {
        flattenedNodeList.add(getNodeJSONFromNodeEntity(node));
      }
      response =
          NodeAdminUtils.buildStandardRESTHTTPResponseForCollection(
              200, "Node List Retrieved Successfully", flattenedNodeList, null);
    } catch (Exception e) {
      e.printStackTrace();
      response =
          NodeAdminUtils.buildStandardRESTHTTPResponse(
              500, "Server Error Retrieving Node List", null, null);
    }
    return response;
  }
Exemplo n.º 6
0
 @GET
 @Produces(MediaType.APPLICATION_JSON)
 @Path("/{nodeName}")
 public Response getANode(@PathParam("nodeName") String nodeName) {
   Response response = null;
   try {
     org.nikhil.webapp.nodeadmin.entity.Node fetchedNode = nodeOperation.getNode(nodeName);
     if (fetchedNode == null) {
       response = NodeAdminUtils.buildStandardRESTHTTPResponse(404, "No Such Node", null, null);
     } else {
       Node flattenedNode = getNodeJSONFromNodeEntity(fetchedNode);
       response =
           NodeAdminUtils.buildStandardRESTHTTPResponse(
               200, "Node Retrieved Successfully", flattenedNode, null);
     }
   } catch (Exception e) {
     e.printStackTrace();
     response =
         NodeAdminUtils.buildStandardRESTHTTPResponse(
             500, "Server Error Retrieving Node " + nodeName, null, null);
   }
   return response;
 }
Exemplo n.º 7
0
  /**
   * Creates or fetches a JPA Node Entity for JSON Node Used for PUT and POST Requests for
   * NodeResource The services and commands are updated from that of the JSON Node
   *
   * @param nodeEntity
   * @return
   */
  public org.nikhil.webapp.nodeadmin.entity.Node getJPANodeFromJSONNode(Node jsonNode) {

    String nodeName = jsonNode.getName();
    org.nikhil.webapp.nodeadmin.entity.Node jpaNode = nodeOperation.getNode(nodeName);
    boolean addingANode = false;
    boolean prevServicesPresent = false;
    boolean prevCmmandsPresent = false;

    if (jpaNode == null) {
      // Create Mode
      jpaNode = new org.nikhil.webapp.nodeadmin.entity.Node();
      jpaNode.setName(nodeName);
      addingANode = true;
    }
    // create / update Mode
    jpaNode.setDescription(jsonNode.getDescription());
    jpaNode.setIpAddress(jsonNode.getIpAddress());
    jpaNode.setMaster(jsonNode.isMaster());
    jpaNode.setUserName(jsonNode.getUserName());
    jpaNode.setPassword(jsonNode.getPassword());
    jpaNode.setShutdownTimer(jsonNode.getShutdownTimer());
    jpaNode.setRestartTimer(jsonNode.getRestartTimer());
    jpaNode.setStatus(jsonNode.getStatus());

    /*		Add or Update the existing NodeService relationships
    	optimizing single fetch for node services
    */
    List<NodeAndService> nodeAssiginedServices = jpaNode.getNodeServices();

    if (jsonNode.getServices().size() > 0) {
      prevServicesPresent = true;
      for (Service jsonService : jsonNode.getServices()) {
        org.nikhil.webapp.nodeadmin.entity.Service jpaService = null;
        org.nikhil.webapp.nodeadmin.entity.NodeAndService jpaNodeAndService = null;
        boolean serviceFoundAlreadyLinked = false;

        if (nodeAssiginedServices.size() > 0) {
          for (org.nikhil.webapp.nodeadmin.entity.NodeAndService fetchedNodeAndService :
              nodeAssiginedServices) {
            if (fetchedNodeAndService
                .getCompositePK()
                .getService()
                .getName()
                .equals(jsonService.getName())) {
              jpaNodeAndService = fetchedNodeAndService;
              serviceFoundAlreadyLinked = true;
              break;
            }
          }
        }
        // Add service relationship for current json service
        if (!serviceFoundAlreadyLinked || nodeAssiginedServices.size() == 0) {
          jpaService = serviceOperation.getService(jsonService.getName());
          jpaNodeAndService = new NodeAndService();
          jpaNodeAndService.setCompositePK(new NodeAndServiceId(jpaNode, jpaService));
          // adding relationship
          jpaNode.getNodeServices().add(jpaNodeAndService);
        }

        // so here we have jpanodeandservice identified either new and added or retrieved from node
        // itself - update it now
        jpaNodeAndService.setAdditionalRunParamsStart(jsonService.getAdditionalRunParamsStart());
        jpaNodeAndService.setAdditionalRunParamsStop(jsonService.getAdditionalRunParamsStop());
        jpaNodeAndService.setStatusWildCardOverride(jsonService.getStatusWildCardOverride());
        jpaNodeAndService.setStatusCommandOverride(jsonService.getStatusCommandOverride());
        jpaNodeAndService.setRundir(jsonService.getRundir());
        jpaNodeAndService.setRunning(jsonService.isRunning());
      }

      /* delete the relationships that are not part of new assignment
       * if adding a node all service relationships are new so no need to delete anything from jpaNode
       */
      if (prevServicesPresent && !addingANode) {
        int index = 0;
        ArrayList<Integer> deleteIndices = new ArrayList<Integer>();
        for (org.nikhil.webapp.nodeadmin.entity.NodeAndService fetchedNodeAndService :
            nodeAssiginedServices) {

          boolean serviceMatched = false;
          for (Service jsonService : jsonNode.getServices()) {
            if (fetchedNodeAndService
                .getCompositePK()
                .getService()
                .getName()
                .equals(jsonService.getName())) {
              serviceMatched = true;
              break;
            }
          }

          if (!serviceMatched) {
            deleteIndices.add(index);
          }
          index++;
        }

        // delete unmatched services
        for (Integer indexToDelete : deleteIndices) {
          nodeAssiginedServices.remove(indexToDelete.intValue());
        }
      }
    }

    List<NodeAndCommand> nodeAssiginedCommands = jpaNode.getNodeCommands();

    if (jsonNode.getCommands().size() > 0) {
      prevCmmandsPresent = true;
      for (Command jsonCommand : jsonNode.getCommands()) {
        org.nikhil.webapp.nodeadmin.entity.Command jpaCommand = null;
        org.nikhil.webapp.nodeadmin.entity.NodeAndCommand jpaNodeAndCommand = null;
        boolean commandFoundAlreadyLinked = false;

        if (nodeAssiginedCommands.size() > 0) {
          for (org.nikhil.webapp.nodeadmin.entity.NodeAndCommand fetchedNodeAndCommand :
              nodeAssiginedCommands) {
            if (fetchedNodeAndCommand
                .getCompositePK()
                .getCommand()
                .getName()
                .equals(jsonCommand.getName())) {
              jpaNodeAndCommand = fetchedNodeAndCommand;
              commandFoundAlreadyLinked = true;
              break;
            }
          }
        }
        // Add command relationship for current json command
        if (!commandFoundAlreadyLinked || nodeAssiginedCommands.size() == 0) {
          jpaCommand = commandOperation.getCommand(jsonCommand.getName());
          jpaNodeAndCommand = new NodeAndCommand();
          jpaNodeAndCommand.setCompositePK(new NodeAndCommandId(jpaNode, jpaCommand));
          // adding relationship
          jpaNode.getNodeCommands().add(jpaNodeAndCommand);
        }

        // so here we have jpanodeandcommand identified either new and added or retrieved from node
        // itself - update it now
        jpaNodeAndCommand.setAdditionalRunParams(jsonCommand.getAdditionalRunParams());
        jpaNodeAndCommand.setAlwaysRunInBackground(jsonCommand.isAlwaysRunInBackground());
        jpaNodeAndCommand.setRundir(jsonCommand.getRundir());
      }

      /* delete the relationships that are not part of new assignment
       * if adding a node all command relationships are new so no need to delete anything from jpaNode
       */
      if (prevCmmandsPresent && !addingANode) {
        int index = 0;
        ArrayList<Integer> deleteIndices = new ArrayList<Integer>();
        for (org.nikhil.webapp.nodeadmin.entity.NodeAndCommand fetchedNodeAndCommand :
            nodeAssiginedCommands) {

          boolean commandMatched = false;
          for (Command jsonCommand : jsonNode.getCommands()) {
            if (fetchedNodeAndCommand
                .getCompositePK()
                .getCommand()
                .getName()
                .equals(jsonCommand.getName())) {
              commandMatched = true;
              break;
            }
          }

          if (!commandMatched) {
            deleteIndices.add(index);
          }
          index++;
        }

        // delete unmatched commands
        for (Integer indexToDelete : deleteIndices) {
          nodeAssiginedCommands.remove(indexToDelete.intValue());
        }
      }
    }

    return jpaNode;
  }