public CommandResponse doLISTJOBS(CommandRequest request) {

    CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");
    ReplacerEnvironment env = new ReplacerEnvironment();
    TreeSet<Job> treeSet = new TreeSet<Job>(new JobIndexComparator());
    treeSet.addAll(getJobManager().getAllJobsFromQueue());

    for (Job job : treeSet) {
      env.add("job", job);
      env.add("count", job.getIndex());
      synchronized (job) {
        if (job.isTransferring()) {
          env.add("speed", Bytes.formatBytes(job.getSpeed()));
          env.add("progress", Bytes.formatBytes(job.getProgress()));
          try {
            env.add("total", Bytes.formatBytes(job.getFile().getSize()));
          } catch (FileNotFoundException e) {
            env.add("total", "0");
          }
          env.add("srcslave", job.getSourceSlave().getName());
          env.add("destslave", job.getDestinationSlave().getName());
          response.addComment(
              request.getSession().jprintf(_bundle, env, _keyPrefix + "listjobrunning"));
        } else {
          response.addComment(
              request.getSession().jprintf(_bundle, env, _keyPrefix + "listjobwaiting"));
        }
      }
    }
    env = new ReplacerEnvironment();
    env.add("total", treeSet.size());
    response.addComment(request.getSession().jprintf(_bundle, env, _keyPrefix + "sizeofjobs"));
    return response;
  }
Esempio n. 2
0
 public CommandResponse doSlave(CommandRequest request) throws ImproperUsageException {
   if (!request.hasArgument()) {
     throw new ImproperUsageException();
   }
   boolean showMore = false;
   StringTokenizer arguments = new StringTokenizer(request.getArgument());
   String slaveName = arguments.nextToken();
   if (arguments.hasMoreTokens()) {
     if (arguments.nextToken().equalsIgnoreCase("more")) {
       showMore = true;
     } else {
       throw new ImproperUsageException();
     }
   }
   if (arguments.hasMoreTokens()) {
     throw new ImproperUsageException();
   }
   CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");
   try {
     RemoteSlave rslave =
         GlobalContext.getGlobalContext().getSlaveManager().getRemoteSlave(slaveName);
     response = addSlaveStatus(request, response, showMore, rslave);
   } catch (ObjectNotFoundException e) {
     ReplacerEnvironment env = new ReplacerEnvironment();
     env.add("slavename", slaveName);
     response.addComment(
         request
             .getSession()
             .jprintf(_bundle, _keyPrefix + "slave.notfound", env, request.getUser()));
   }
   return response;
 }
Esempio n. 3
0
  public CommandResponse doSITE_DELSLAVE(CommandRequest request) throws ImproperUsageException {
    Session session = request.getSession();

    CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");
    ReplacerEnvironment env = new ReplacerEnvironment();

    if (!request.hasArgument()) {
      throw new ImproperUsageException();
    }

    String argument = request.getArgument();
    StringTokenizer arguments = new StringTokenizer(argument);

    if (!arguments.hasMoreTokens()) {
      throw new ImproperUsageException();
    }

    String slavename = arguments.nextToken();
    env.add("slavename", slavename);

    try {
      GlobalContext.getGlobalContext().getSlaveManager().getRemoteSlave(slavename);
    } catch (ObjectNotFoundException e) {
      response.addComment(
          session.jprintf(_bundle, _keyPrefix + "delslave.notfound", env, request.getUser()));

      return response;
    }

    GlobalContext.getGlobalContext().getSlaveManager().delSlave(slavename);
    response.addComment(
        session.jprintf(_bundle, _keyPrefix + "delslave.success", env, request.getUser()));

    return response;
  }
Esempio n. 4
0
  public CommandResponse doRemergeque(CommandRequest request) throws ImproperUsageException {
    String slave;
    if (request.hasArgument()) {
      slave = request.getArgument().toLowerCase();
    } else {
      slave = "all";
    }

    ArrayList<String> arr = new ArrayList<String>();

    for (RemoteSlave rslave : GlobalContext.getGlobalContext().getSlaveManager().getSlaves()) {
      if (!rslave.getName().contains(slave) && !slave.equals("all")) {
        continue;
      }

      int size = rslave.doRemergequeue();
      if (!rslave.isOnline()) {
        arr.add(rslave.getName() + " is offline");
      } else if (!rslave.isRemerging()) {
        arr.add(rslave.getName() + " remergeque is complete");
      } else if (size > 0) {
        arr.add(rslave.getName() + " remergeque size is " + size);
      } else {
        arr.add(rslave.getName() + " remergeque size is 0 but remerge is ongoing");
      }
    }
    arr.add("Total commit:" + CommitManager.getCommitManager().getQueueSize());

    CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");
    for (String str : arr) {
      response.addComment(str);
    }

    return response;
  }
Esempio n. 5
0
  /** Lists all slaves used by the master USAGE: SITE SLAVES */
  public CommandResponse doSITE_SLAVES(CommandRequest request) {
    boolean showMore = request.hasArgument() && (request.getArgument().equalsIgnoreCase("more"));

    Collection<RemoteSlave> slaves = GlobalContext.getGlobalContext().getSlaveManager().getSlaves();
    CommandResponse response = new CommandResponse(200, "OK, " + slaves.size() + " slaves listed.");

    int slavesFound = 0;
    String type;
    if (request.hasArgument()) {
      type = request.getArgument().toLowerCase();
    } else {
      type = "r";
    }

    for (RemoteSlave rslave : GlobalContext.getGlobalContext().getSlaveManager().getSlaves()) {
      String name = rslave.getName().toLowerCase();
      if ((!name.contains(type)) && (!type.equals("all"))) continue;
      response = addSlaveStatus(request, response, showMore, rslave);
      slavesFound = slavesFound + 1;
    }

    if (slavesFound == 0) {
      response.addComment(
          request
              .getSession()
              .jprintf(_bundle, _keyPrefix + "slave.none", null, request.getUser()));
    }
    return response;
  }
Esempio n. 6
0
  public CommandResponse doSITE_SLAVESELECT(CommandRequest request) throws ImproperUsageException {

    if (!request.hasArgument()) {
      throw new ImproperUsageException();
    }
    String argument = request.getArgument();
    StringTokenizer arguments = new StringTokenizer(argument);
    if (arguments.hasMoreTokens() == false) {
      throw new ImproperUsageException();
    }
    String type = arguments.nextToken();
    if (arguments.hasMoreTokens() == false) {
      throw new ImproperUsageException();
    }
    String path = arguments.nextToken();
    if (!path.startsWith(VirtualFileSystem.separator)) {
      throw new ImproperUsageException();
    }
    char direction = Transfer.TRANSFER_UNKNOWN;
    if (type.equalsIgnoreCase("up")) {
      direction = Transfer.TRANSFER_RECEIVING_UPLOAD;
    } else if (type.equalsIgnoreCase("down")) {
      direction = Transfer.TRANSFER_SENDING_DOWNLOAD;
    } else {
      throw new ImproperUsageException();
    }
    Collection<RemoteSlave> slaves;
    try {
      slaves = GlobalContext.getGlobalContext().getSlaveManager().getAvailableSlaves();
    } catch (NoAvailableSlaveException e1) {
      return StandardCommandManager.genericResponse("RESPONSE_530_SLAVE_UNAVAILABLE");
    }
    SlaveSelectionManager ssm = null;
    try {
      ssm = (SlaveSelectionManager) GlobalContext.getGlobalContext().getSlaveSelectionManager();
    } catch (ClassCastException e) {
      return new CommandResponse(
          500,
          "You are attempting to test filter.SlaveSelectionManager yet you're using def.SlaveSelectionManager");
    }
    CommandResponse response = new CommandResponse(500, "***End of SlaveSelection output***");
    Collection<Filter> filters = ssm.getFilterChain(type).getFilters();
    ScoreChart sc = new ScoreChart(slaves);
    for (Filter filter : filters) {
      try {
        filter.process(sc, null, null, direction, new FileHandle(path), null);
      } catch (NoAvailableSlaveException e) {
      }
    }
    for (SlaveScore ss : sc.getSlaveScores()) {
      response.addComment(ss.getRSlave().getName() + "=" + ss.getScore());
    }
    return response;
  }
Esempio n. 7
0
 public CommandResponse doDiskfree(CommandRequest request) throws ImproperUsageException {
   if (request.hasArgument()) {
     throw new ImproperUsageException();
   }
   ReplacerEnvironment env = new ReplacerEnvironment();
   SlaveStatus status = GlobalContext.getGlobalContext().getSlaveManager().getAllStatus();
   fillEnvWithSlaveStatus(env, status);
   CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");
   response.addComment(
       request.getSession().jprintf(_bundle, _keyPrefix + "diskfree", env, request.getUser()));
   return response;
 }
 public CommandResponse doREMOVEJOBS(CommandRequest request) {
   TreeSet<Job> treeSet = new TreeSet<Job>(new JobIndexComparator());
   treeSet.addAll(getJobManager().getAllJobsFromQueue());
   CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");
   for (Job job : treeSet) {
     if (!job.isTransferring()) {
       getJobManager().stopJob(job);
     }
   }
   response.addComment("Removing all non transfering jobs");
   return response;
 }
Esempio n. 9
0
  /*
   * Prehook method for SLAVE ADDIP
   * Gets the ip, and preforms checks.
   */
  public CommandRequestInterface doIpSecuritySLAVEPreCheck(CommandRequest request) {
    if (!request.hasArgument()) {
      return request;
    }

    String argument = request.getArgument();
    StringTokenizer arguments = new StringTokenizer(argument);

    if (!arguments.hasMoreTokens()) {
      return request;
    }

    String slavename = arguments.nextToken();

    RemoteSlave rslave = null;
    try {
      rslave = GlobalContext.getGlobalContext().getSlaveManager().getRemoteSlave(slavename);
    } catch (ObjectNotFoundException e) {
      request.setDeniedResponse(new CommandResponse(200, "Slave Not Found: " + slavename));
      request.setAllowed(false);
      return request;
    }

    if (arguments.hasMoreTokens()) {
      String command = arguments.nextToken();
      if (command.equalsIgnoreCase("addmask")) {
        if (arguments.countTokens() != 1) {
          return request;
        }

        HostMask newMask = new HostMask(arguments.nextToken().replace(",", ""));

        String _maskident = newMask.getIdentMask();
        String _maskHostMask = newMask.getHostMask();

        boolean _allowed =
            IpSecurityManager.getIpSecurity()
                .checkIP(_maskident, _maskHostMask, rslave.getMasks().size(), null);
        if ((!_allowed) && (!_maskHostMask.equals("127.0.0.1"))) {
          request.setAllowed(false);
          CommandResponse response =
              StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");
          response.addComment(IpSecurityManager.getIpSecurity().outputConfs(null));
          request.setDeniedResponse(response);
          return request;
        }
      }
    }
    return request;
  }
Esempio n. 10
0
  public CommandResponse doREMOVEJOB(CommandRequest request) throws ImproperUsageException {

    if (!request.hasArgument()) {
      throw new ImproperUsageException();
    }
    class Range {
      long _low, _high;

      Range(long low, long high) {
        if (0 >= low || low > high) {
          throw new IllegalArgumentException("0 < low <= high");
        }
        _low = low;
        _high = high;
      }

      public boolean contains(long val) {
        return _low <= val && val <= _high;
      }
    }

    ArrayList<Range> rangeList = new ArrayList<Range>();
    String rangeString = request.getArgument();
    String[] ranges = rangeString.split(" ");
    for (String range : ranges) {
      if (range.indexOf("-") == -1) {
        long val = Long.parseLong(range);
        rangeList.add(new Range(val, val));
      } else {
        String[] vals = range.split("-");
        rangeList.add(new Range(Long.parseLong(vals[0]), Long.parseLong(vals[1])));
      }
    }
    TreeSet<Job> treeSet = new TreeSet<Job>(new JobIndexComparator());
    treeSet.addAll(getJobManager().getAllJobsFromQueue());
    ReplacerEnvironment env = new ReplacerEnvironment();

    CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");
    for (Job job : treeSet) {
      for (Range range : rangeList) {
        if (range.contains(job.getIndex())) {
          env.add("job", job);
          getJobManager().stopJob(job);
          response.addComment(
              request.getSession().jprintf(_bundle, env, _keyPrefix + "removejob.success"));
        }
      }
    }
    return response;
  }
Esempio n. 11
0
  /*
   * Checks the IP from arguments (Used for ADDUSER/GADDUSER/ADDIP)
   */
  public CommandRequest checkIP(CommandRequest request, int argnum, int ipnum, boolean newuser) {
    if (!request.hasArgument()) {
      return request;
    }

    String[] args = request.getArgument().split(" ");
    if (args.length < argnum) {
      return request;
    }

    try {
      int _numip = args.length - argnum + 1;

      User user = null;

      if (!newuser) {
        user = GlobalContext.getGlobalContext().getUserManager().getUserByName(args[0]);
        _numip = user.getHostMaskCollection().size();
      }

      for (int i = ipnum; i < args.length; i++) {
        HostMask newMask = new HostMask(args[i].replace(",", ""));
        String maskHostMask = newMask.getHostMask();

        boolean _allowed =
            IpSecurityManager.getIpSecurity()
                .checkIP(newMask.getIdentMask(), maskHostMask, _numip, user);
        if ((!_allowed) && (!maskHostMask.equals("127.0.0.1"))) {
          request.setAllowed(false);
          CommandResponse response =
              StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");
          response.addComment(IpSecurityManager.getIpSecurity().outputConfs(user));
          request.setDeniedResponse(response);
          return request;
        }
      }

    } catch (NoSuchUserException ex) {
      request.setAllowed(false);
      request.setDeniedResponse(new CommandResponse(452, "No such user: "******"No Such User Exception - IpSecurityHooks");
      return request;
    } catch (UserFileException ex) {
      request.setAllowed(false);
      request.setDeniedResponse(new CommandResponse(452, "User File Exception: " + args[0]));
      return request;
    }
    return request;
  }
Esempio n. 12
0
  public CommandResponse doSITE_NUKESCLEAN(CommandRequest request) {
    CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");

    if (NukeBeans.getNukeBeans().getAll().isEmpty()) {
      response.addComment("Nukelog empty.");
    }

    ArrayList<String> entriesToRemove = new ArrayList<String>();

    for (NukeData nd : NukeBeans.getNukeBeans().getAll()) {
      // Construct new path with [NUKED]-
      String newPath = VirtualFileSystem.fixPath(nd.getPath());
      String fixedName =
          "[NUKED]-" + newPath.substring(newPath.lastIndexOf(VirtualFileSystem.separator) + 1);
      newPath =
          newPath.substring(0, newPath.lastIndexOf(VirtualFileSystem.separator) + 1) + fixedName;

      try {
        request.getCurrentDirectory().getDirectoryUnchecked(newPath);
        // Still here? .. all ok then, just continue with next item in nukelog
      } catch (FileNotFoundException e) {
        // Dir was deleted/wiped, lets remove it from nukelog.
        // Add path to list so we can delete it after going through entire nukelog
        entriesToRemove.add(nd.getPath());
      } catch (ObjectNotValidException e) {
        return new CommandResponse(550, newPath + " is not a directory");
      }
    }

    if (entriesToRemove.isEmpty()) {
      response.addComment("No entries to delete from nukelog.");
    } else {
      int deleted = 0;
      for (String path : entriesToRemove) {
        try {
          NukeBeans.getNukeBeans().remove(path);
          deleted++;
        } catch (ObjectNotFoundException e) {
          response.addComment("Error removing nukelog entry: " + path);
        }
      }
      response.addComment("Removed " + deleted + " invalid entries from the nukelog.");
    }

    return response;
  }
Esempio n. 13
0
  public CommandResponse doSITE_NUKES(CommandRequest request) {
    CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");

    ReplacerEnvironment env = new ReplacerEnvironment();

    SectionInterface section =
        GlobalContext.getGlobalContext().getSectionManager().getSection(request.getArgument());

    if (request.hasArgument() && section.getName().equalsIgnoreCase("")) {
      return new CommandResponse(501, "Invalid section!");
    }

    if (NukeBeans.getNukeBeans().getAll().isEmpty()) {
      response.addComment(
          request
              .getSession()
              .jprintf(_bundle, _keyPrefix + "nukes.empty", env, request.getUser()));
    }

    for (NukeData nd : NukeBeans.getNukeBeans().getAll()) {
      if (nd.getPath().startsWith(request.getArgument(), 1)) {
        env.add("path", nd.getPath());
        env.add("multiplier", nd.getMultiplier());
        env.add("usersnuked", nd.getNukees().size());
        env.add("size", nd.getSize());
        env.add("reason", nd.getReason());
        env.add("amount", nd.getAmount());
        env.add("nuker", nd.getUser());
        response.addComment(
            request.getSession().jprintf(_bundle, _keyPrefix + "nukes", env, request.getUser()));
      }
    }

    if (response.getComment().isEmpty()) {
      env.add("section", section.getName());
      response.addComment(
          request
              .getSession()
              .jprintf(_bundle, _keyPrefix + "nukes.empty.section", env, request.getUser()));
    }

    return response;
  }
Esempio n. 14
0
  private CommandResponse addSlaveStatus(
      CommandRequest request, CommandResponse response, boolean showMore, RemoteSlave rslave) {
    Session session = request.getSession();
    if (showMore) {
      response.addComment(rslave.moreInfo());
    }

    ReplacerEnvironment env = new ReplacerEnvironment();
    env.add("slavename", rslave.getName());
    try {
      env.add("slaveip", rslave.getPASVIP());
    } catch (SlaveUnavailableException e) {
      env.add("slaveip", "OFFLINE");
    }

    if (rslave.isOnline()) {
      if (!rslave.isAvailable()) {
        response.addComment(
            session.jprintf(_bundle, _keyPrefix + "slave.remerging", env, request.getUser()));
      } else {
        try {
          SlaveStatus status = rslave.getSlaveStatus();
          fillEnvWithSlaveStatus(env, status);
          env.add("status", rslave.isRemerging() ? "REMERGING" : "ONLINE");
          response.addComment(
              session.jprintf(_bundle, _keyPrefix + "slave.online", env, request.getUser()));
        } catch (SlaveUnavailableException e) {
          // should never happen since we tested slave status w/ isOnline and isAvaiable.
          throw new RuntimeException(
              "There's a bug somewhere in the code, the slave was available now it isn't.", e);
        }
      }
    } else {
      response.addComment(
          session.jprintf(_bundle, _keyPrefix + "slave.offline", env, request.getUser()));
    }
    return response;
  }
Esempio n. 15
0
  public CommandResponse doSITE_PRE(CommandRequest request) throws ImproperUsageException {
    if (!request.hasArgument()) {
      throw new ImproperUsageException();
    }

    String[] args = request.getArgument().split(" ");

    if (args.length != 2) {
      return StandardCommandManager.genericResponse("RESPONSE_501_SYNTAX_ERROR");
    }

    SectionInterface section =
        GlobalContext.getGlobalContext().getSectionManager().getSection(args[1]);

    if (section.getName().equals("")) {
      return new CommandResponse(
          500, "Invalid section, see SITE SECTIONS for a list of available sections");
    }

    User user = request.getSession().getUserNull(request.getUser());

    DirectoryHandle preDir;

    String path = VirtualFileSystem.fixPath(args[0]);
    if (!(path.startsWith(VirtualFileSystem.separator))) {
      // Not a full path, let's make it one
      if (request.getCurrentDirectory().isRoot()) {
        path = VirtualFileSystem.separator + path;
      } else {
        path = request.getCurrentDirectory().getPath() + VirtualFileSystem.separator + path;
      }
    }

    try {
      preDir = request.getCurrentDirectory().getDirectory(path, user);
    } catch (FileNotFoundException e) {
      return StandardCommandManager.genericResponse("RESPONSE_550_REQUESTED_ACTION_NOT_TAKEN");
    } catch (ObjectNotValidException e) {
      return StandardCommandManager.genericResponse(
          "RESPONSE_553_REQUESTED_ACTION_NOT_TAKEN_FILE_EXISTS");
    }

    ConfigInterface config = GlobalContext.getConfig();
    if (!config.checkPathPermission("pre", user, preDir)) {
      return StandardCommandManager.genericResponse("RESPONSE_530_ACCESS_DENIED");
    }

    DirectoryHandle toInode =
        new DirectoryHandle(
            section.getCurrentDirectory().getPath()
                + VirtualFileSystem.separator
                + preDir.getName());

    if (toInode.exists()) {
      return new CommandResponse(500, "Directory already exist in target section");
    }

    CommandResponse response =
        new CommandResponse(250, request.getCommand().toUpperCase() + " command successful.");

    // AWARD CREDITS
    HashMap<User, Long> awards = new HashMap<User, Long>();
    preAwardCredits(preDir, awards);

    for (Map.Entry<User, Long> entry : awards.entrySet()) {
      User owner = entry.getKey();
      if (StatsManager.getStatsManager().getCreditCheckRatio(preDir, owner) == 0) {
        Long award = entry.getValue();
        owner.updateCredits(award);
        response.addComment("Awarded " + Bytes.formatBytes(award) + " to " + owner.getName());
      }
    }

    recursiveRemoveOwnership(preDir, System.currentTimeMillis());

    int files = getFiles(preDir);
    long bytes = 0;
    try {
      bytes = preDir.getSize();
    } catch (FileNotFoundException e) {
      logger.warn("FileNotFoundException ", e);
    }

    try {
      preDir.renameToUnchecked(toInode);
    } catch (FileNotFoundException e) {
      logger.warn("FileNotFoundException on renameTo()", e);
      return new CommandResponse(500, "FileNotFound - " + e.getMessage());
    } catch (IOException e) {
      logger.warn("IOException on renameTo()", e);
      return new CommandResponse(500, "IOException - " + e.getMessage());
    }

    preDir = toInode;

    GlobalContext.getEventService()
        .publishAsync(
            new PreEvent(preDir, section, Integer.toString(files), Bytes.formatBytes(bytes)));

    response.setObject(PREDIR, preDir);

    return response;
  }
Esempio n. 16
0
  /**
   * USAGE: <file><priority>[destslave ...]
   *
   * @param conn
   * @return
   * @throws ImproperUsageException
   * @throws ReplyException
   * @throws FileNotFoundException
   */
  public CommandResponse doADDJOB(CommandRequest request) throws ImproperUsageException {

    if (!request.hasArgument()) {
      throw new ImproperUsageException();
    }

    CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");

    StringTokenizer st = new StringTokenizer(request.getArgument());
    User user = request.getSession().getUserNull(request.getUser());
    FileHandle lrf;

    try {
      try {
        lrf = request.getCurrentDirectory().getFile(st.nextToken(), user);
      } catch (ObjectNotValidException e) {
        throw new ImproperUsageException("addjob does not handle directories or links");
      }
    } catch (FileNotFoundException e) {
      return new CommandResponse(500, "File does not exist");
    }

    int priority;

    try {
      priority = Integer.parseInt(st.nextToken());
    } catch (Exception e) {
      throw new ImproperUsageException();
    }

    int timesToMirror;

    try {
      timesToMirror = Integer.parseInt(st.nextToken());
    } catch (NumberFormatException e) {
      throw new ImproperUsageException();
    }

    HashSet<String> destSlaves = new HashSet<String>();

    while (st.hasMoreTokens()) {
      String slaveName = st.nextToken();

      try {
        GlobalContext.getGlobalContext().getSlaveManager().getRemoteSlave(slaveName);
      } catch (ObjectNotFoundException e1) {
        response.addComment(slaveName + "was not found, cannot add to destination slave list");

        continue;
      }

      destSlaves.add(slaveName);
    }

    if (destSlaves.size() == 0) {
      throw new ImproperUsageException();
    }

    Job job = new Job(lrf, destSlaves, priority, timesToMirror);
    getJobManager().addJobToQueue(job);

    ReplacerEnvironment env = new ReplacerEnvironment();
    env.add("job", job);
    response.addComment(request.getSession().jprintf(_bundle, env, _keyPrefix + "addjob.success"));

    return response;
  }
Esempio n. 17
0
  /**
   * USAGE: site unnuke <directory> <message> Unnuke a directory.
   *
   * <p>ex. site unnuke shit NOT CRAP
   *
   * <p>This will unnuke the directory 'shit' with the comment 'NOT CRAP'.
   *
   * <p>NOTE: You can enclose the directory in braces if you have spaces in the name ex. site unnuke
   * {My directory name} justcause
   *
   * <p>You need to configure glftpd to keep nuked files if you want to unnuke. See the section
   * about glftpd.conf.
   *
   * @throws ImproperUsageException
   */
  public CommandResponse doSITE_UNNUKE(CommandRequest request) throws ImproperUsageException {
    if (!request.hasArgument()) {
      throw new ImproperUsageException();
    }

    StringTokenizer st = new StringTokenizer(request.getArgument());

    Session session = request.getSession();

    DirectoryHandle currentDir = request.getCurrentDirectory();
    User user = session.getUserNull(request.getUser());
    String toName = st.nextToken();
    String toDir;
    String nukeName;

    if (!toName.startsWith(VirtualFileSystem.separator)) {
      // Not a full path, let's make it one and append [NUKED]- if needed.
      if (toName.startsWith("[NUKED]-")) {
        nukeName = toName;
        toName = toName.substring(8);
      } else {
        nukeName = "[NUKED]-" + toName;
      }
      if (request.getCurrentDirectory().isRoot()) {
        boolean searchIndex =
            request.getProperties().getProperty("search", "true").equalsIgnoreCase("true");
        if (searchIndex) {
          // Get dirs from index system
          ArrayList<DirectoryHandle> dirsToUnNuke;
          try {
            dirsToUnNuke = NukeUtils.findNukeDirs(currentDir, user, nukeName);
          } catch (FileNotFoundException e) {
            logger.warn(e);
            return new CommandResponse(550, e.getMessage());
          }

          ReplacerEnvironment env = new ReplacerEnvironment();

          if (dirsToUnNuke.isEmpty()) {
            env.add("searchstr", nukeName);
            return new CommandResponse(
                550, session.jprintf(_bundle, _keyPrefix + "unnuke.search.empty", env, user));
          } else if (dirsToUnNuke.size() == 1) {
            toDir = dirsToUnNuke.get(0).getParent().getPath() + VirtualFileSystem.separator;
          } else {
            CommandResponse response = new CommandResponse(200);

            for (DirectoryHandle nukeDir : dirsToUnNuke) {
              try {
                env.add("name", nukeDir.getName());
                env.add("path", nukeDir.getPath());
                env.add("owner", nukeDir.getUsername());
                env.add("group", nukeDir.getGroup());
                env.add("size", Bytes.formatBytes(nukeDir.getSize()));
                response.addComment(
                    session.jprintf(_bundle, _keyPrefix + "unnuke.search.item", env, user));
              } catch (FileNotFoundException e) {
                logger.warn(
                    "Dir deleted after index search?, skip and continue: " + nukeDir.getPath());
              }
            }

            response.addComment(
                session.jprintf(_bundle, _keyPrefix + "unnuke.search.end", env, user));

            // Return matching dirs and let user decide what to unnuke
            return response;
          }
        } else {
          toDir = VirtualFileSystem.separator;
        }
      } else {
        toDir = currentDir.getPath() + VirtualFileSystem.separator;
      }
    } else {
      // Full path to Nuked dir provided, append [NUKED]- if needed.
      toDir = VirtualFileSystem.fixPath(toName);
      toName = toDir.substring(toDir.lastIndexOf(VirtualFileSystem.separator) + 1);
      toDir = toDir.substring(0, toDir.lastIndexOf(VirtualFileSystem.separator) + 1);
      if (toName.startsWith("[NUKED]-")) {
        nukeName = toName;
        toName = toName.substring(8);
      } else {
        nukeName = "[NUKED]-" + toName;
      }
    }

    String reason;

    if (st.hasMoreTokens()) {
      reason = st.nextToken("").trim();
    } else {
      reason = "";
    }

    DirectoryHandle nukeDir;

    try {
      nukeDir = currentDir.getDirectory(toDir + nukeName, user);
    } catch (FileNotFoundException e) {
      // Maybe dir was deleted/wiped, lets remove it from nukelog.
      try {
        NukeBeans.getNukeBeans().remove(toDir + toName);
      } catch (ObjectNotFoundException ex) {
        return new CommandResponse(
            500, toDir + nukeName + " doesnt exist and no nukelog for this path was found.");
      }
      return new CommandResponse(
          200, toDir + nukeName + " doesnt exist, removed nuke from nukelog.");
    } catch (ObjectNotValidException e) {
      return new CommandResponse(550, toDir + nukeName + " is not a directory");
    }

    NukeData nd;
    try {
      nd = NukeUtils.unnuke(nukeDir, reason);
    } catch (NukeException e) {
      return new CommandResponse(500, "Unnuke failed: " + e.getMessage());
    }

    CommandResponse response = new CommandResponse(200, "Unnuke succeeded");

    NukeEvent nukeEvent = new NukeEvent(session.getUserNull(request.getUser()), "UNNUKE", nd);
    GlobalContext.getEventService().publishAsync(nukeEvent);

    ReplacerEnvironment env = new ReplacerEnvironment();

    String section = GlobalContext.getGlobalContext().getSectionManager().lookup(nukeDir).getName();
    env.add("section", section);
    env.add("dir", nukeDir.getName());
    env.add("path", nukeDir.getPath());
    env.add("relpath", nukeDir.getPath().replaceAll("/" + section + "/", ""));
    env.add("multiplier", nd.getMultiplier());
    env.add("nukedamount", Bytes.formatBytes(nd.getAmount()));
    env.add("reason", reason);
    env.add("size", Bytes.formatBytes(nd.getSize()));

    if (session instanceof BaseFtpConnection) {
      response.addComment(session.jprintf(_bundle, _keyPrefix + "unnuke", env, user));
      for (NukedUser nukeeObj : NukeBeans.getNukeeList(nd)) {
        ReplacerEnvironment nukeeenv = new ReplacerEnvironment();
        User nukee;
        try {
          nukee =
              GlobalContext.getGlobalContext()
                  .getUserManager()
                  .getUserByName(nukeeObj.getUsername());
        } catch (NoSuchUserException e1) {
          // Unable to get user, does not exist.. skip announce for this user
          continue;
        } catch (UserFileException e1) {
          // Error in user file.. skip announce for this user
          continue;
        }

        long debt =
            NukeUtils.calculateNukedAmount(
                nukeeObj.getAmount(),
                nukee.getKeyedMap().getObjectFloat(UserManagement.RATIO),
                nd.getMultiplier());
        nukeeenv.add("nukedamount", Bytes.formatBytes(debt));
        response.addComment(
            session.jprintf(_bundle, _keyPrefix + "unnuke.nukees", nukeeenv, nukee));
      }
    }

    return response;
  }
Esempio n. 18
0
  /**
   * USAGE: site nuke <directory> <multiplier> <message> Nuke a directory
   *
   * <p>ex. site nuke shit 2 CRAP
   *
   * <p>This will nuke the directory 'shit' and remove x2 credits with the comment 'CRAP'.
   *
   * <p>NOTE: You can enclose the directory in braces if you have spaces in the name ex. site NUKE
   * {My directory name} 1 because_i_dont_like_it
   *
   * <p>Q) What does the multiplier in 'site nuke' do? A) Multiplier is a penalty measure. If it is
   * 0, the user doesn't lose any credits for the stuff being nuked. If it is 1, user only loses the
   * amount of credits he gained by uploading the files (which is calculated by multiplying total
   * size of file by his/her ratio). If multiplier is more than 1, the user loses the credits he/she
   * gained by uploading, PLUS some extra credits. The formula is this: size * ratio + size *
   * (multiplier - 1). This way, multiplier of 2 causes user to lose size * ratio + size * 1, so the
   * additional penalty in this case is the size of nuked files. If the multiplier is 3, user loses
   * size * ratio + size * 2, etc.
   *
   * @throws ImproperUsageException
   */
  public CommandResponse doSITE_NUKE(CommandRequest request) throws ImproperUsageException {
    if (!request.hasArgument()) {
      throw new ImproperUsageException();
    }

    StringTokenizer st = new StringTokenizer(request.getArgument());

    if (!st.hasMoreTokens()) {
      throw new ImproperUsageException();
    }

    Session session = request.getSession();

    int multiplier;

    DirectoryHandle currentDir = request.getCurrentDirectory();
    String nukeDirName = st.nextToken();

    User requestUser = session.getUserNull(request.getUser());

    String nukeDirPath = VirtualFileSystem.fixPath(nukeDirName);

    if (!(nukeDirPath.startsWith(VirtualFileSystem.separator))) {
      // Not a full path, let's make it one
      if (request.getCurrentDirectory().isRoot()) {
        boolean searchIndex =
            request.getProperties().getProperty("search", "true").equalsIgnoreCase("true");
        if (searchIndex) {
          // Get dirs from index system
          ArrayList<DirectoryHandle> dirsToNuke;
          try {
            dirsToNuke = NukeUtils.findNukeDirs(currentDir, requestUser, nukeDirPath);
          } catch (FileNotFoundException e) {
            logger.warn(e);
            return new CommandResponse(550, e.getMessage());
          }

          ReplacerEnvironment env = new ReplacerEnvironment();

          if (dirsToNuke.isEmpty()) {
            env.add("searchstr", nukeDirPath);
            return new CommandResponse(
                550, session.jprintf(_bundle, _keyPrefix + "nuke.search.empty", env, requestUser));
          } else if (dirsToNuke.size() == 1) {
            nukeDirPath = dirsToNuke.get(0).getPath();
          } else {
            CommandResponse response = new CommandResponse(200);

            for (DirectoryHandle nukeDir : dirsToNuke) {
              try {
                env.add("name", nukeDir.getName());
                env.add("path", nukeDir.getPath());
                env.add("owner", nukeDir.getUsername());
                env.add("group", nukeDir.getGroup());
                env.add("size", Bytes.formatBytes(nukeDir.getSize()));
                response.addComment(
                    session.jprintf(_bundle, _keyPrefix + "nuke.search.item", env, requestUser));
              } catch (FileNotFoundException e) {
                logger.warn(
                    "Dir deleted after index search?, skip and continue: " + nukeDir.getPath());
              }
            }

            response.addComment(
                session.jprintf(_bundle, _keyPrefix + "nuke.search.end", env, requestUser));

            // Return matching dirs and let user decide what to nuke
            return response;
          }
        } else {
          nukeDirPath = VirtualFileSystem.separator + nukeDirPath;
        }
      } else {
        nukeDirPath =
            request.getCurrentDirectory().getPath() + VirtualFileSystem.separator + nukeDirPath;
      }
    }

    DirectoryHandle nukeDir;

    try {
      nukeDir = request.getCurrentDirectory().getDirectory(nukeDirPath, requestUser);
    } catch (FileNotFoundException e) {
      return StandardCommandManager.genericResponse("RESPONSE_550_REQUESTED_ACTION_NOT_TAKEN");
    } catch (ObjectNotValidException e) {
      return new CommandResponse(550, nukeDirPath + " is not a directory");
    }

    nukeDirName = nukeDir.getName();

    if (!st.hasMoreTokens()) {
      throw new ImproperUsageException();
    }

    try {
      multiplier = Integer.parseInt(st.nextToken());
    } catch (NumberFormatException ex) {
      logger.warn(ex, ex);
      return new CommandResponse(501, "Invalid multiplier: " + ex.getMessage());
    }

    String reason = "";

    if (st.hasMoreTokens()) {
      reason = st.nextToken("").trim();
    }

    NukeData nd;
    try {
      nd = NukeUtils.nuke(nukeDir, multiplier, reason, requestUser);
    } catch (NukeException e) {
      return new CommandResponse(500, "Nuke failed: " + e.getMessage());
    }

    CommandResponse response = new CommandResponse(200, "Nuke succeeded");

    GlobalContext.getEventService().publishAsync(new NukeEvent(requestUser, "NUKE", nd));

    ReplacerEnvironment env = new ReplacerEnvironment();

    String section = GlobalContext.getGlobalContext().getSectionManager().lookup(nukeDir).getName();
    env.add("section", section);
    env.add("dir", nukeDirName);
    env.add("path", nukeDirPath);
    env.add("relpath", nukeDirPath.replaceAll("/.*?" + section + "/", ""));
    env.add("multiplier", multiplier);
    env.add("nukedamount", Bytes.formatBytes(nd.getAmount()));
    env.add("reason", reason);
    env.add("size", Bytes.formatBytes(nd.getSize()));

    if (session instanceof BaseFtpConnection) {
      response.addComment(session.jprintf(_bundle, _keyPrefix + "nuke", env, requestUser));
      for (NukedUser nukeeObj : NukeBeans.getNukeeList(nd)) {
        ReplacerEnvironment nukeeenv = new ReplacerEnvironment();
        User nukee;
        try {
          nukee =
              GlobalContext.getGlobalContext()
                  .getUserManager()
                  .getUserByName(nukeeObj.getUsername());
        } catch (NoSuchUserException e1) {
          // Unable to get user, does not exist.. skip announce for this user
          continue;
        } catch (UserFileException e1) {
          // Error in user file.. skip announce for this user
          continue;
        }

        long debt =
            NukeUtils.calculateNukedAmount(
                nukeeObj.getAmount(),
                nukee.getKeyedMap().getObjectFloat(UserManagement.RATIO),
                multiplier);
        nukeeenv.add("nukedamount", Bytes.formatBytes(debt));
        response.addComment(session.jprintf(_bundle, _keyPrefix + "nuke.nukees", nukeeenv, nukee));
      }
    }

    return response;
  }
Esempio n. 19
0
  /**
   * Usage: site slave slavename [set,addmask,delmask]
   *
   * @throws ImproperUsageException
   */
  public CommandResponse doSITE_SLAVE(CommandRequest request) throws ImproperUsageException {
    Session session = request.getSession();

    CommandResponse response = StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");
    ReplacerEnvironment env = new ReplacerEnvironment();

    if (!request.hasArgument()) {
      throw new ImproperUsageException();
    }

    String argument = request.getArgument();
    StringTokenizer arguments = new StringTokenizer(argument);

    if (!arguments.hasMoreTokens()) {
      throw new ImproperUsageException();
    }

    String slavename = arguments.nextToken();
    env.add("slavename", slavename);

    RemoteSlave rslave = null;

    try {
      rslave = GlobalContext.getGlobalContext().getSlaveManager().getRemoteSlave(slavename);
    } catch (ObjectNotFoundException e) {
      response.addComment(
          session.jprintf(_bundle, _keyPrefix + "slave.notfound", env, request.getUser()));

      return response;
    }

    if (!arguments.hasMoreTokens()) {
      if (!rslave.getMasks().isEmpty()) {
        env.add("masks", rslave.getMasks());
        response.addComment(
            session.jprintf(_bundle, _keyPrefix + "slave.masks", env, request.getUser()));
      }

      response.addComment(
          session.jprintf(_bundle, _keyPrefix + "slave.data.header", request.getUser()));

      Map<Object, Object> props = rslave.getProperties();

      for (Entry<Object, Object> entry : props.entrySet()) {
        env.add("key", entry.getKey());
        env.add("value", entry.getValue());
        response.addComment(
            session.jprintf(_bundle, _keyPrefix + "slave.data", env, request.getUser()));
      }

      return response;
    }

    String command = arguments.nextToken();

    if (command.equalsIgnoreCase("set")) {
      if (arguments.countTokens() != 2) {
        throw new ImproperUsageException();
      }

      String key = arguments.nextToken();
      String value = arguments.nextToken();
      rslave.setProperty(key, value);
      env.add("key", key);
      env.add("value", value);
      response.addComment(
          session.jprintf(_bundle, _keyPrefix + "slave.set.success", env, request.getUser()));

      return response;
    } else if (command.equalsIgnoreCase("unset")) {
      if (arguments.countTokens() != 1) {
        throw new ImproperUsageException();
      }

      String key = arguments.nextToken();
      env.add("key", key);
      String value;
      try {
        value = rslave.removeProperty(key);
      } catch (KeyNotFoundException e) {
        response.addComment(
            session.jprintf(_bundle, _keyPrefix + "slave.unset.failure", env, request.getUser()));
        return response;
      }
      env.add("value", value);
      response.addComment(
          session.jprintf(_bundle, _keyPrefix + "slave.unset.success", env, request.getUser()));
      return response;
    } else if (command.equalsIgnoreCase("addmask")) {
      if (arguments.countTokens() != 1) {
        throw new ImproperUsageException();
      }

      String mask = arguments.nextToken();
      env.add("mask", mask);
      try {
        rslave.addMask(mask);
        response.addComment(
            session.jprintf(_bundle, _keyPrefix + "slave.addmask.success", env, request.getUser()));
        return response;
      } catch (DuplicateElementException e) {
        response =
            new CommandResponse(
                501,
                session.jprintf(
                    _bundle, _keyPrefix + "slave.addmask.dupe", env, request.getUser()));
        return response;
      }
    } else if (command.equalsIgnoreCase("delmask")) {
      if (arguments.countTokens() != 1) {
        throw new ImproperUsageException();
      }

      String mask = arguments.nextToken();
      env.add("mask", mask);

      if (rslave.removeMask(mask)) {
        return new CommandResponse(
            200,
            session.jprintf(_bundle, _keyPrefix + "slave.delmask.success", env, request.getUser()));
      }
      return new CommandResponse(
          501,
          session.jprintf(_bundle, _keyPrefix + "slave.delmask.failed", env, request.getUser()));
    } else if (command.equalsIgnoreCase("shutdown")) {
      rslave.shutdown();
      return StandardCommandManager.genericResponse("RESPONSE_200_COMMAND_OK");
    }
    throw new ImproperUsageException();
  }