How to use

add

method

in

org.restlet.ext.platform.FirewallConfig

/**
 * Adds a rule that forbids access to the given set of IP addresses.
 * 
 * @param blackList
 *            The list of rejected IP addresses.
 */
public void addIpAddressesBlackList(List<String> blackList) {
  add(new FirewallIpFilteringRule(blackList, false));
}

/**
 * Adds a rule that forbids access to the given set of IP addresses.
 * 
 * @param blackList
 *            The list of rejected IP addresses.
 */
public void addIpAddressesBlackList(List<String> blackList) {
  add(new FirewallIpFilteringRule(blackList, false));
}

/**
 * Adds a rule that restricts access to the given set of IP addresses.
 * 
 * @param whiteList
 *            The list of accepted IP addresses.
 */
public void addIpAddressesWhiteList(List<String> whiteList) {
  add(new FirewallIpFilteringRule(whiteList, true));
}

/**
 * Adds a rule that restricts access to the given set of IP addresses.
 * 
 * @param whiteList
 *            The list of accepted IP addresses.
 */
public void addIpAddressesWhiteList(List<String> whiteList) {
  add(new FirewallIpFilteringRule(whiteList, true));
}

/**
 * Adds a rule that forbids access to the given set of IP addresses.
 * 
 * @param blackList
 *            The list of rejected IP addresses.
 */
public void addIpAddressesBlackList(List<String> blackList) {
  add(new FirewallIpFilteringRule(blackList, false));
}

/**
 * Adds a rule that forbids access to the given set of IP addresses.
 * 
 * @param blackList
 *            The list of rejected IP addresses.
 */
public void addIpAddressesBlackList(List<String> blackList) {
  add(new FirewallIpFilteringRule(blackList, false));
}

/**
 * Adds a rule that restricts access to the given set of IP addresses.
 * 
 * @param whiteList
 *            The list of accepted IP addresses.
 */
public void addIpAddressesWhiteList(List<String> whiteList) {
  add(new FirewallIpFilteringRule(whiteList, true));
}

/**
 * Adds a rule that restricts access to the given set of IP addresses.
 * 
 * @param whiteList
 *            The list of accepted IP addresses.
 */
public void addIpAddressesWhiteList(List<String> whiteList) {
  add(new FirewallIpFilteringRule(whiteList, true));
}

/**
 * Adds a rule that restricts access according to the IP address of the
 * request's client. A unique limit is applied for all IP addresses.
 * 
 * @param limit
 *            The maximum number of accepted concurrent requests.
 */
public void addIpAddressesConcurrencyCounter(int limit) {
  FirewallCounterRule rule = new ConcurrentFirewallCounterRule(
      new IpAddressCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}

/**
 * Adds a rule that restricts access according to the IP address of the
 * request's client. A unique limit is applied for all IP addresses.
 * 
 * @param limit
 *            The maximum number of accepted concurrent requests.
 */
public void addIpAddressesConcurrencyCounter(int limit) {
  FirewallCounterRule rule = new ConcurrentFirewallCounterRule(
      new IpAddressCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}

/**
 * Adds a rule that restricts access according to the IP address of the
 * request's client. A unique limit is applied for all IP addresses.
 * 
 * @param limit
 *            The maximum number of accepted concurrent requests.
 */
public void addIpAddressesConcurrencyCounter(int limit) {
  FirewallCounterRule rule = new ConcurrentFirewallCounterRule(
      new IpAddressCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}

/**
 * Adds a rule that restricts access according to the IP address of the
 * request's client. A unique limit is applied for all IP addresses.
 * 
 * @param limit
 *            The maximum number of accepted concurrent requests.
 */
public void addIpAddressesConcurrencyCounter(int limit) {
  FirewallCounterRule rule = new ConcurrentFirewallCounterRule(
      new IpAddressCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}

/**
 * Adds a rule that limits the number of concurrent requests by request's
 * host domain.
 * 
 * @param limit
 *            The maximum number of requests allowed by host domain at the
 *            same time.
 */
public void addHostDomainConcurrencyCounter(int limit) {
  FirewallCounterRule rule = new ConcurrentFirewallCounterRule(
      new HostDomainCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}

/**
 * Adds a rule that limits the number of concurrent requests by request's
 * host domain.
 * 
 * @param limit
 *            The maximum number of requests allowed by host domain at the
 *            same time.
 */
public void addHostDomainConcurrencyCounter(int limit) {
  FirewallCounterRule rule = new ConcurrentFirewallCounterRule(
      new HostDomainCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}

/**
 * Adds a rule that limits the number of concurrent requests by request's
 * host domain.
 * 
 * @param limit
 *            The maximum number of requests allowed by host domain at the
 *            same time.
 */
public void addHostDomainConcurrencyCounter(int limit) {
  FirewallCounterRule rule = new ConcurrentFirewallCounterRule(
      new HostDomainCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}

/**
 * Adds a rule that limits the number of concurrent requests by request's
 * host domain.
 * 
 * @param limit
 *            The maximum number of requests allowed by host domain at the
 *            same time.
 */
public void addHostDomainConcurrencyCounter(int limit) {
  FirewallCounterRule rule = new ConcurrentFirewallCounterRule(
      new HostDomainCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}

/**
 * Adds a rule that restricts access by period of time according to the IP
 * address of the request's client. A unique limit is applied for all IP
 * addresses.
 * 
 * @param period
 *            The period of time.
 * @param periodUnit
 *            Period time unit associated to the rule.
 * @param limit
 *            The maximum number of accepted requests for a period of time.
 */
public void addIpAddressesPeriodicCounter(int period, TimeUnit periodUnit,
    int limit) {
  FirewallCounterRule rule = new PeriodicFirewallCounterRule(period,
      periodUnit, new IpAddressCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}

/**
 * Adds a rule that restricts access by period of time according to the IP
 * address of the request's client. A unique limit is applied for all IP
 * addresses.
 * 
 * @param period
 *            The period of time.
 * @param periodUnit
 *            Period time unit associated to the rule.
 * @param limit
 *            The maximum number of accepted requests for a period of time.
 */
public void addIpAddressesPeriodicCounter(int period, TimeUnit periodUnit,
    int limit) {
  FirewallCounterRule rule = new PeriodicFirewallCounterRule(period,
      periodUnit, new IpAddressCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}

/**
 * Adds a rule that restricts access by period of time according to the IP
 * address of the request's client. A unique limit is applied for all IP
 * addresses.
 * 
 * @param period
 *            The period of time.
 * @param periodUnit
 *            Period time unit associated to the rule.
 * @param limit
 *            The maximum number of accepted requests for a period of time.
 */
public void addIpAddressesPeriodicCounter(int period, TimeUnit periodUnit,
    int limit) {
  FirewallCounterRule rule = new PeriodicFirewallCounterRule(period,
      periodUnit, new IpAddressCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}

/**
 * Adds a rule that restricts access by period of time according to the IP
 * address of the request's client. A unique limit is applied for all IP
 * addresses.
 * 
 * @param period
 *            The period of time.
 * @param periodUnit
 *            Period time unit associated to the rule.
 * @param limit
 *            The maximum number of accepted requests for a period of time.
 */
public void addIpAddressesPeriodicCounter(int period, TimeUnit periodUnit,
    int limit) {
  FirewallCounterRule rule = new PeriodicFirewallCounterRule(period,
      periodUnit, new IpAddressCountingPolicy());
  rule.addHandler(new BlockingHandler(new UniqueLimitPolicy(limit)));
  add(rule);
}