broker-plugins/connection-limits/src/main/java/org/apache/qpid/server/user/connection/limits/config/FileParser.java - qpid-broker-j - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.qpid.server.user.connection.limits.config;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.io.StreamTokenizer;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Paths;
 import java.util.ArrayDeque;
 import java.util.Iterator;
 import java.util.Locale;
 import java.util.Queue;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import org.apache.qpid.server.configuration.IllegalConfigurationException;

 public class FileParser
 {
     private static final Logger LOGGER = LoggerFactory.getLogger(FileParser.class);

     private static final Character COMMENT = '#';
     private static final Character CONTINUATION = '\\';

     private static final Pattern NUMBER = Pattern.compile("\\s*(\\d+)\\s*");

     private static final String ACCESS_CONTROL = "acl";
     public static final String CONNECTION_LIMIT = "clt";
     private static final String CONFIG = "config";

     public static final String DEFAULT_FREQUENCY_PERIOD = "default_frequency_period";
     public static final String DEFAULT_FREQUENCY_PERIOD_ALTERNATIVE = "defaultfrequencyperiod";
     private static final String LOG_ALL = "log_all";
     private static final String LOG_ALL_ALTERNATIVE = "logall";

     public static final String BLOCK = "BLOCK";

     static final String UNRECOGNISED_INITIAL_TOKEN = "Unrecognised initial token '%s' at line %d";
     static final String NOT_ENOUGH_TOKENS = "Not enough tokens at line %d";
     static final String NUMBER_NOT_ALLOWED = "Number not allowed before '%s' at line %d";
     static final String CANNOT_LOAD_CONFIGURATION = "I/O Error while reading configuration";
     static final String PREMATURE_CONTINUATION = "Premature continuation character at line %d";
     static final String PARSE_TOKEN_FAILED = "Failed to parse token at line %d";
     static final String UNKNOWN_CLT_PROPERTY_MSG = "Unknown connection limit property: %s at line %d";
     static final String PROPERTY_KEY_ONLY_MSG = "Incomplete property (key only) at line %d";
     static final String PROPERTY_NO_EQUALS_MSG = "Incomplete property (no equals) at line %d";
     static final String PROPERTY_NO_VALUE_MSG = "Incomplete property (no value) at line %d";

     public static RuleSetCreator parse(String name)
     {
         return new FileParser().readAndParse(name);
     }

     public RuleSetCreator readAndParse(String name)
     {
         return readAndParse(getReaderFromURLString(name));
     }

     RuleSetCreator readAndParse(Reader reader)
     {
         final RuleSetCreator ruleSetCreator = new RuleSetCreator();

         int line = 0;
         try (final Reader fileReader = new BufferedReader(reader))
         {
             LOGGER.debug("About to load connection limit file");
             final StreamTokenizer tokenizer = new StreamTokenizer(fileReader);
             tokenizer.resetSyntax(); // setup the tokenizer

             tokenizer.commentChar(COMMENT); // single line comments
             tokenizer.eolIsSignificant(true); // return EOL as a token
             tokenizer.ordinaryChar('='); // equals is a token
             tokenizer.ordinaryChar(CONTINUATION); // continuation character (when followed by EOL)
             tokenizer.quoteChar('"'); // double quote
             tokenizer.quoteChar('\''); // single quote
             tokenizer.whitespaceChars('\u0000', '\u0020');
             tokenizer.wordChars('a', 'z'); // unquoted token characters [a-z]
             tokenizer.wordChars('A', 'Z'); // [A-Z]
             tokenizer.wordChars('0', '9'); // [0-9]
             tokenizer.wordChars('_', '_'); // underscore
             tokenizer.wordChars('-', '-'); // dash
             tokenizer.wordChars('.', '.'); // dot
             tokenizer.wordChars('*', '*'); // star
             tokenizer.wordChars('@', '@'); // at
             tokenizer.wordChars(':', ':'); // colon
             tokenizer.wordChars('+', '+'); // plus
             tokenizer.wordChars('/', '/');

             final Queue<String> stack = new ArrayDeque<>();
             int current;
             do
             {
                 current = tokenizer.nextToken();
                 line = tokenizer.lineno() - 1;
                 switch (current)
                 {
                     case StreamTokenizer.TT_EOF:
                     case StreamTokenizer.TT_EOL:
                         processLine(ruleSetCreator, line, stack);
                         break;
                     case StreamTokenizer.TT_WORD:
                         addLast(stack, tokenizer.sval);
                         break;
                     default:
                         parseToken(tokenizer, stack);
                 }
             }
             while (current != StreamTokenizer.TT_EOF);
         }
         catch (IllegalConfigurationException ice)
         {
             throw ice;
         }
         catch (IOException ioe)
         {
             throw new IllegalConfigurationException(CANNOT_LOAD_CONFIGURATION, ioe);
         }
         catch (RuntimeException re)
         {
             throw new IllegalConfigurationException(String.format(PARSE_TOKEN_FAILED, line), re);
         }
         return ruleSetCreator;
     }

     private void processLine(RuleSetCreator ruleSetCreator, int line, Queue<String> stack)
     {
         if (stack.isEmpty())
         {
             return; // blank line
         }
         final String first = stack.poll();
         if (first == null || stack.isEmpty())
         {
             throw new IllegalConfigurationException(String.format(NOT_ENOUGH_TOKENS, line));
         }

         final Matcher matcher = NUMBER.matcher(first);
         if (matcher.matches())
         {
             final String commandType = stack.poll();
             if (ACCESS_CONTROL.equalsIgnoreCase(commandType))
             {
                 parseAccessControl(stack, ruleSetCreator, line);
                 stack.clear();
                 return;
             }
             throw new IllegalConfigurationException(String.format(NUMBER_NOT_ALLOWED, commandType, line));
         }

         if (CONNECTION_LIMIT.equalsIgnoreCase(first))
         {
             parseConnectionLimit(stack, ruleSetCreator, line);
         }
         else if (CONFIG.equalsIgnoreCase(first))
         {
             parseConfig(stack, ruleSetCreator, line);
         }
         else if (ACCESS_CONTROL.equalsIgnoreCase(first))
         {
             parseAccessControl(stack, ruleSetCreator, line);
         }
         else
         {
             throw new IllegalConfigurationException(String.format(UNRECOGNISED_INITIAL_TOKEN, first, line));
         }
         stack.clear();
     }

     private void parseToken(StreamTokenizer tokenizer, Queue<String> stack) throws IOException
     {
         if (tokenizer.ttype == CONTINUATION)
         {
             if (tokenizer.nextToken() != StreamTokenizer.TT_EOL)
             {
                 // invalid location for continuation character (add one to line because we ate the EOL)
                 throw new IllegalConfigurationException(String.format(PREMATURE_CONTINUATION, tokenizer.lineno()));
             }
         }
         else if (tokenizer.ttype == '\'' || tokenizer.ttype == '"')
         {
             addLast(stack, tokenizer.sval);
         }
         else if (!Character.isWhitespace(tokenizer.ttype))
         {
             addLast(stack, Character.toString((char) tokenizer.ttype));
         }
     }

     private void addLast(Queue<String> queue, String value)
     {
         if (value != null)
         {
             queue.add(value);
         }
     }

     private void parseConnectionLimit(Queue<String> args, final RuleSetCreator ruleSetCreator, final int line)
     {
         final String identity = args.poll();
         final RulePredicates predicates = new RulePredicates();

         final Iterator<String> i = args.iterator();
         while (i.hasNext())
         {
             final String key = i.next();
             if (BLOCK.equalsIgnoreCase(key))
             {
                 predicates.setBlockedUser();
             }
             else
             {
                 if (predicates.parse(key, readValue(i, line)) == null)
                 {
                     throw new IllegalConfigurationException(String.format(UNKNOWN_CLT_PROPERTY_MSG, key, line));
                 }
             }
         }
         if (!predicates.isEmpty())
         {
             ruleSetCreator.add(Rule.newInstance(identity, predicates));
         }
     }

     private void parseAccessControl(Queue<String> args, final RuleSetCreator ruleSetCreator, final int line)
     {
         if (args.size() < 4)
         {
             return;
         }
         // poll outcome
         args.poll();
         final String identity = args.poll();
         // poll operation
         args.poll();
         // poll object
         args.poll();

         final RulePredicates predicates = new RulePredicates();
         final Iterator<String> i = args.iterator();
         while (i.hasNext())
         {
             predicates.parse(i.next(), readValue(i, line));
         }
         if (!predicates.isEmpty())
         {
             ruleSetCreator.add(Rule.newInstance(identity, predicates));
         }
     }

     private static void parseConfig(final Queue<String> args, final RuleSetCreator ruleSetCreator, final int line)
     {
         final Iterator<String> i = args.iterator();
         while (i.hasNext())
         {
             final String key = i.next().replace("-", "_").toLowerCase(Locale.ENGLISH);
             final String value = readValue(i, line);

             switch (key)
             {
                 case LOG_ALL:
                 case LOG_ALL_ALTERNATIVE:
                     ruleSetCreator.setLogAllMessages(Boolean.parseBoolean(value));
                     break;
                 case DEFAULT_FREQUENCY_PERIOD:
                 case DEFAULT_FREQUENCY_PERIOD_ALTERNATIVE:
                     ruleSetCreator.setDefaultFrequencyPeriod(Long.parseLong(value));
                     break;
                 default:
             }
         }
     }

     private static String readValue(Iterator<String> i, int line)
     {
         if (!i.hasNext())
         {
             throw new IllegalConfigurationException(String.format(PROPERTY_KEY_ONLY_MSG, line));
         }
         if (!"=".equals(i.next()))
         {
             throw new IllegalConfigurationException(String.format(PROPERTY_NO_EQUALS_MSG, line));
         }
         if (!i.hasNext())
         {
             throw new IllegalConfigurationException(String.format(PROPERTY_NO_VALUE_MSG, line));
         }
         return i.next();
     }

     private Reader getReaderFromURLString(String urlString)
     {
         try
         {
             return new InputStreamReader(new URL(urlString).openStream(), StandardCharsets.UTF_8);
         }
         catch (MalformedURLException e)
         {
             return getReaderFromPath(urlString);
         }
         catch (IOException | RuntimeException e)
         {
             throw createReaderError(urlString, e);
         }
     }

     private Reader getReaderFromPath(String path)
     {
         try
         {
             return new InputStreamReader(Paths.get(path).toUri().toURL().openStream(), StandardCharsets.UTF_8);
         }
         catch (IOException | RuntimeException e)
         {
             throw createReaderError(path, e);
         }
     }

     private static IllegalConfigurationException createReaderError(String urlString, Exception e)
     {
         return new IllegalConfigurationException("Cannot convert " + urlString + " to a readable resource", e);
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.qpid.server.user.connection.limits.config;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.io.Reader;
	import java.io.StreamTokenizer;
	import java.net.MalformedURLException;
	import java.net.URL;
	import java.nio.charset.StandardCharsets;
	import java.nio.file.Paths;
	import java.util.ArrayDeque;
	import java.util.Iterator;
	import java.util.Locale;
	import java.util.Queue;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import org.apache.qpid.server.configuration.IllegalConfigurationException;

	public class FileParser
	{
	private static final Logger LOGGER = LoggerFactory.getLogger(FileParser.class);

	private static final Character COMMENT = '#';
	private static final Character CONTINUATION = '\\';

	private static final Pattern NUMBER = Pattern.compile("\\s(\\d+)\\s");

	private static final String ACCESS_CONTROL = "acl";
	public static final String CONNECTION_LIMIT = "clt";
	private static final String CONFIG = "config";

	public static final String DEFAULT_FREQUENCY_PERIOD = "default_frequency_period";
	public static final String DEFAULT_FREQUENCY_PERIOD_ALTERNATIVE = "defaultfrequencyperiod";
	private static final String LOG_ALL = "log_all";
	private static final String LOG_ALL_ALTERNATIVE = "logall";

	public static final String BLOCK = "BLOCK";

	static final String UNRECOGNISED_INITIAL_TOKEN = "Unrecognised initial token '%s' at line %d";
	static final String NOT_ENOUGH_TOKENS = "Not enough tokens at line %d";
	static final String NUMBER_NOT_ALLOWED = "Number not allowed before '%s' at line %d";
	static final String CANNOT_LOAD_CONFIGURATION = "I/O Error while reading configuration";
	static final String PREMATURE_CONTINUATION = "Premature continuation character at line %d";
	static final String PARSE_TOKEN_FAILED = "Failed to parse token at line %d";
	static final String UNKNOWN_CLT_PROPERTY_MSG = "Unknown connection limit property: %s at line %d";
	static final String PROPERTY_KEY_ONLY_MSG = "Incomplete property (key only) at line %d";
	static final String PROPERTY_NO_EQUALS_MSG = "Incomplete property (no equals) at line %d";
	static final String PROPERTY_NO_VALUE_MSG = "Incomplete property (no value) at line %d";

	public static RuleSetCreator parse(String name)
	{
	return new FileParser().readAndParse(name);
	}

	public RuleSetCreator readAndParse(String name)
	{
	return readAndParse(getReaderFromURLString(name));
	}

	RuleSetCreator readAndParse(Reader reader)
	{
	final RuleSetCreator ruleSetCreator = new RuleSetCreator();

	int line = 0;
	try (final Reader fileReader = new BufferedReader(reader))
	{
	LOGGER.debug("About to load connection limit file");
	final StreamTokenizer tokenizer = new StreamTokenizer(fileReader);
	tokenizer.resetSyntax(); // setup the tokenizer

	tokenizer.commentChar(COMMENT); // single line comments
	tokenizer.eolIsSignificant(true); // return EOL as a token
	tokenizer.ordinaryChar('='); // equals is a token
	tokenizer.ordinaryChar(CONTINUATION); // continuation character (when followed by EOL)
	tokenizer.quoteChar('"'); // double quote
	tokenizer.quoteChar('\''); // single quote
	tokenizer.whitespaceChars('\u0000', '\u0020');
	tokenizer.wordChars('a', 'z'); // unquoted token characters [a-z]
	tokenizer.wordChars('A', 'Z'); // [A-Z]
	tokenizer.wordChars('0', '9'); // [0-9]
	tokenizer.wordChars('_', '_'); // underscore
	tokenizer.wordChars('-', '-'); // dash
	tokenizer.wordChars('.', '.'); // dot
	tokenizer.wordChars('', ''); // star
	tokenizer.wordChars('@', '@'); // at
	tokenizer.wordChars(':', ':'); // colon
	tokenizer.wordChars('+', '+'); // plus
	tokenizer.wordChars('/', '/');

	final Queue<String> stack = new ArrayDeque<>();
	int current;
	do
	{
	current = tokenizer.nextToken();
	line = tokenizer.lineno() - 1;
	switch (current)
	{
	case StreamTokenizer.TT_EOF:
	case StreamTokenizer.TT_EOL:
	processLine(ruleSetCreator, line, stack);
	break;
	case StreamTokenizer.TT_WORD:
	addLast(stack, tokenizer.sval);
	break;
	default:
	parseToken(tokenizer, stack);
	}
	}
	while (current != StreamTokenizer.TT_EOF);
	}
	catch (IllegalConfigurationException ice)
	{
	throw ice;
	}
	catch (IOException ioe)
	{
	throw new IllegalConfigurationException(CANNOT_LOAD_CONFIGURATION, ioe);
	}
	catch (RuntimeException re)
	{
	throw new IllegalConfigurationException(String.format(PARSE_TOKEN_FAILED, line), re);
	}
	return ruleSetCreator;
	}

	private void processLine(RuleSetCreator ruleSetCreator, int line, Queue<String> stack)
	{
	if (stack.isEmpty())
	{
	return; // blank line
	}
	final String first = stack.poll();
	if (first == null \|\| stack.isEmpty())
	{
	throw new IllegalConfigurationException(String.format(NOT_ENOUGH_TOKENS, line));
	}

	final Matcher matcher = NUMBER.matcher(first);
	if (matcher.matches())
	{
	final String commandType = stack.poll();
	if (ACCESS_CONTROL.equalsIgnoreCase(commandType))
	{
	parseAccessControl(stack, ruleSetCreator, line);
	stack.clear();
	return;
	}
	throw new IllegalConfigurationException(String.format(NUMBER_NOT_ALLOWED, commandType, line));
	}

	if (CONNECTION_LIMIT.equalsIgnoreCase(first))
	{
	parseConnectionLimit(stack, ruleSetCreator, line);
	}
	else if (CONFIG.equalsIgnoreCase(first))
	{
	parseConfig(stack, ruleSetCreator, line);
	}
	else if (ACCESS_CONTROL.equalsIgnoreCase(first))
	{
	parseAccessControl(stack, ruleSetCreator, line);
	}
	else
	{
	throw new IllegalConfigurationException(String.format(UNRECOGNISED_INITIAL_TOKEN, first, line));
	}
	stack.clear();
	}

	private void parseToken(StreamTokenizer tokenizer, Queue<String> stack) throws IOException
	{
	if (tokenizer.ttype == CONTINUATION)
	{
	if (tokenizer.nextToken() != StreamTokenizer.TT_EOL)
	{
	// invalid location for continuation character (add one to line because we ate the EOL)
	throw new IllegalConfigurationException(String.format(PREMATURE_CONTINUATION, tokenizer.lineno()));
	}
	}
	else if (tokenizer.ttype == '\'' \|\| tokenizer.ttype == '"')
	{
	addLast(stack, tokenizer.sval);
	}
	else if (!Character.isWhitespace(tokenizer.ttype))
	{
	addLast(stack, Character.toString((char) tokenizer.ttype));
	}
	}

	private void addLast(Queue<String> queue, String value)
	{
	if (value != null)
	{
	queue.add(value);
	}
	}

	private void parseConnectionLimit(Queue<String> args, final RuleSetCreator ruleSetCreator, final int line)
	{
	final String identity = args.poll();
	final RulePredicates predicates = new RulePredicates();

	final Iterator<String> i = args.iterator();
	while (i.hasNext())
	{
	final String key = i.next();
	if (BLOCK.equalsIgnoreCase(key))
	{
	predicates.setBlockedUser();
	}
	else
	{
	if (predicates.parse(key, readValue(i, line)) == null)
	{
	throw new IllegalConfigurationException(String.format(UNKNOWN_CLT_PROPERTY_MSG, key, line));
	}
	}
	}
	if (!predicates.isEmpty())
	{
	ruleSetCreator.add(Rule.newInstance(identity, predicates));
	}
	}

	private void parseAccessControl(Queue<String> args, final RuleSetCreator ruleSetCreator, final int line)
	{
	if (args.size() < 4)
	{
	return;
	}
	// poll outcome
	args.poll();
	final String identity = args.poll();
	// poll operation
	args.poll();
	// poll object
	args.poll();

	final RulePredicates predicates = new RulePredicates();
	final Iterator<String> i = args.iterator();
	while (i.hasNext())
	{
	predicates.parse(i.next(), readValue(i, line));
	}
	if (!predicates.isEmpty())
	{
	ruleSetCreator.add(Rule.newInstance(identity, predicates));
	}
	}

	private static void parseConfig(final Queue<String> args, final RuleSetCreator ruleSetCreator, final int line)
	{
	final Iterator<String> i = args.iterator();
	while (i.hasNext())
	{
	final String key = i.next().replace("-", "_").toLowerCase(Locale.ENGLISH);
	final String value = readValue(i, line);

	switch (key)
	{
	case LOG_ALL:
	case LOG_ALL_ALTERNATIVE:
	ruleSetCreator.setLogAllMessages(Boolean.parseBoolean(value));
	break;
	case DEFAULT_FREQUENCY_PERIOD:
	case DEFAULT_FREQUENCY_PERIOD_ALTERNATIVE:
	ruleSetCreator.setDefaultFrequencyPeriod(Long.parseLong(value));
	break;
	default:
	}
	}
	}

	private static String readValue(Iterator<String> i, int line)
	{
	if (!i.hasNext())
	{
	throw new IllegalConfigurationException(String.format(PROPERTY_KEY_ONLY_MSG, line));
	}
	if (!"=".equals(i.next()))
	{
	throw new IllegalConfigurationException(String.format(PROPERTY_NO_EQUALS_MSG, line));
	}
	if (!i.hasNext())
	{
	throw new IllegalConfigurationException(String.format(PROPERTY_NO_VALUE_MSG, line));
	}
	return i.next();
	}

	private Reader getReaderFromURLString(String urlString)
	{
	try
	{
	return new InputStreamReader(new URL(urlString).openStream(), StandardCharsets.UTF_8);
	}
	catch (MalformedURLException e)
	{
	return getReaderFromPath(urlString);
	}
	catch (IOException \| RuntimeException e)
	{
	throw createReaderError(urlString, e);
	}
	}

	private Reader getReaderFromPath(String path)
	{
	try
	{
	return new InputStreamReader(Paths.get(path).toUri().toURL().openStream(), StandardCharsets.UTF_8);
	}
	catch (IOException \| RuntimeException e)
	{
	throw createReaderError(path, e);
	}
	}

	private static IllegalConfigurationException createReaderError(String urlString, Exception e)
	{
	return new IllegalConfigurationException("Cannot convert " + urlString + " to a readable resource", e);
	}
	}