<!--
/***************************************************************************************************************************
 * 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.
 ***************************************************************************************************************************/
 -->

7.0.1 (Dec 24, 2017)

<p>
	This release is a minor update.
	It includes the following prereq updates:
</p>
<ul class='spaced-list'>
	<li>Apache HttpClient:  4.5.3 to 4.5.4
	<li>Eclipse Jetty:  9.4.6.v20170531 to 9.4.8.v20171121
</ul>

<h5 class='topic w800'>juneau-marshall</h5>
<ul class='spaced-list'>
	<li>New static <c>create()</c> methods for builders on serializers and parsers.
		<br>This simplifies the syntax of creation of serializers and parsers by scratch.
		<p class='bcode w800'>
	<jc>// Old way</jc>
	JsonSerializer s1 = <jk>new</jk> JsonSerializerBuilder().ws().build();
	
	<jc>// New way</jc>
	JsonSerializer s2 = JsonSerializer.<jsm>create</jsm>().ws().build();
		</p>
		<br>The same static create methods have also been added to the following classes:
		<ul>
			<li>{@link oaj.serializer.SerializerGroup#create()}
			<li>{@link oaj.parser.ParserGroup#create()}
			<li>{@link oaj.encoders.EncoderGroup#create()}
			<li>{@link oajrc.RestClient#create()}
			<li><dc>ConfigFile.create()</dc>
		</ul>
	<li>
		The order of the parameters in {@link oaj.serializer.SerializerSession#serialize(Object,Object)}
		has been change to match {@link oaj.serializer.Serializer#serialize(Object,Object)}.	
	<li>
		Fixed some bugs in the XML parser related to whitespace and comments.
</ul>

<h5 class='topic w800'>juneau-svl</h5>
<ul class='spaced-list'>
	<li>New methods on {@link oaj.svl.Var} class to restrict when nested and embedded variables
	are resolved.
		<ul>
			<li>{@link oaj.svl.Var#allowNested()}
			<li>{@link oaj.svl.Var#allowRecurse()}
		</ul>
</ul>

<h5 class='topic w800'>juneau-rest-server</h5>
<ul class='spaced-list'>
	<li>
		New <dc>@RestResource(maxInput)</dc> and 
		{@link oajr.annotation.RestMethod#maxInput() @RestMethod(maxInput)} for alleviating
		potential DoS attacks.
</ul>

<h5 class='topic w800'>juneau-microservice-server</h5>
<ul class='spaced-list'>
	<li>
		New pluggable console commands.
		<br>When you start up the microservice, you'll now see the following:
		<p class='bcode w800'>
	Running class 'RestMicroservice' using config file 'examples.cfg'.
	Server started on port 10000

	List of available commands:
		exit -- Shut down service
		restart -- Restarts service
		help -- Commands help
		echo -- Echo command

	&gt; <span style='color:green'>help help</span>
	NAME
		help -- Commands help
	
	SYNOPSIS
		help [command]
	
	DESCRIPTION
		When called without arguments, prints the descriptions of all available commands.
		Can also be called with one or more arguments to get detailed information on a command.
	
	EXAMPLES
		List all commands:
			&gt; help
		
		List help on the help command:
			&gt; help help
			
	&gt; 
		</p>
		<p>
		Commands are pluggable and extensible through the config file. 
	<p class='bcode w800'>
	<cc>#=======================================================================================================================
	# Console settings
	#=======================================================================================================================</cc>
	<cs>[Console]</cs>
	
	<ck>enabled</ck> = <cv>true</cv>
	
	<cc># List of available console commands.
	# These are classes that implements ConsoleCommand that allow you to submit commands to the microservice via
	# the console.
	# When listed here, the implementations must provide a no-arg constructor.
	# They can also be provided dynamically by overriding the Microservice.createConsoleCommands() method.</cc>
	<ck>commands</ck> = 
		<cv>org.apache.juneau.microservice.console.ExitCommand,
		org.apache.juneau.microservice.console.RestartCommand,
		org.apache.juneau.microservice.console.HelpCommand</cv>
	</p>
		<ul>
			<li>New classes:
				<ul>
					<li>{@link oaj.microservice.console.ConsoleCommand}
					<li>{@link oaj.microservice.console.ExitCommand}
					<li>{@link oaj.microservice.console.RestartCommand}
					<li>{@link oaj.microservice.console.HelpCommand}
				</ul>
			<li>New methods on {@link oaj.microservice.Microservice}
				<ul>
					<li>{@link oaj.microservice.Microservice#startConsole() startConsole()}
					<li><dc>createConsoleCommands()</dc>
					<li>{@link oaj.microservice.Microservice#getConsoleReader() getConsoleReader()}
					<li>{@link oaj.microservice.Microservice#getConsoleWriter() getConsoleWriter()}
				</ul>	
		</ul>
	<li>
		Console input reader and output writer can now be overridden.
	<li>
		Console strings are now internationalized.
</ul>
