<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>New and Noteworthy for Eclipse Tools for Cloud Foundry, 1.1.0 (Oxygen)</title>
</head>
<body>
<h1>New and Noteworthy for Eclipse Tools for Cloud Foundry, 1.1.0 (Oxygen)</h1>

<h2>General</h2>

Eclipse Tools for Cloud Foundry (CFT) 1.1.0 features improved manifest file and deployment configuration support. It also contains other enhancements and various bug fixes.

<h2>Improvements</h2>

A couple of general and usability improvements have been introduced in this release:

	<ul>
	<li>
		<b>Support for more properties in manifest.yml</b>
		<p>CFT will now read the following properties from the manifest.yml and set them as part of the push operation when deploying or updating an application:</p> 
		<ul>
			<li>health-check-type</li>
			<li>health-check-http-endpoint</li>
			<li>disk_quota</li>
			<li>timeout</li>
			<li>command</li>
			<li>stack</li>
		</ul>
		<p>Note that &#39;health-check-http-endpoint&#39; is only supported on newer Cloud Foundry and must be used with health check type &#34;http&#34;.</p>
	</li>

	<li>
		<b>Support for &#39;stack&#39; property in manifest.yml</b>
		<p>In addition to reading this property and setting it during deployment of an application, for certain Cloud Foundry servers like Pivotal Web Services and PCF, a user can also specify the stack in the deployment wizard:</p>		
		<p>
			<img width=624 height=481 src="images/stack.png">
		</p>
		<p>If the stack setting is not applicable to a specific branding extension, the adopter can also customize their branding to disable the stack UI via the <i>org.eclipse.cft.server.ui.brandingUI</i> extension point. </p>
	</li>

	<li>
		<b>Support for application names with &#39;.&#39; separation</b>
		<p>CFT now supports application names with &#39;.&#39; separation. Users can now specify dot-separated application names when deploying an application:</p>		
		<p>
			<img width=624 height=478 src="images/dotApplicationName.png">
		</p>
	</li>

	<li>
		<b>Deploy applications without a URL</b>
		<p>All applications, including web applications, can now be deployed to Cloud Foundry without a mapped URL. Although CFT will still suggest a URL in the deployment wizard, users can clear the URL and deploy the application without a URL, similar to the --no-route option in cf CLI push.</p>		
	</li>

	<li>
		<b>Performance improvement on application refresh</b>
		<p>Substantially faster refresh of deployed applications in the Cloud Foundry server: the list of applications in a Cloud Foundry server is now refreshed in parallel, substantially improving refresh time when a Cloud Foundry server first connects, or a user manually clicks the refresh button in the Cloud Foundry editor.</p>		
	</li>

	<li>
		<b>Manifest.yml file detection on deployed application</b>
		<p>Basic support for detecting changes in a manifest.yml and prompting the user to update the changes in Cloud Foundry for deployed applications:</p>
		<ul>
			<li>memory</li>
			<li>disk_quota</li>
			<li>instances</li>
			<li>health-check-type</li>
			<li>health-check-http-endpoint</li>
		</ul>
		<p>A dialogue opens asking the user to confirm whether the update should occur, and will show the difference between the local manifest.yml file and the existing Cloud values:</p>
		<p>
			<img width=624 height=289 src="images/updateManifest.png">
		</p>
		<p>This dialogue will open on detected changes when any of the following operations are performed on an already deployed application:</p>
		<ul>
			<li>Push</li>
			<li>Update and Restart</li>
			<li>Server Publish</li>
			<li>Debug</li>
		</ul>
 		<p>Future versions of CFT may expand this support for other manifest properties as well as top-level properties.</p>
	</li>

	<li><b>Other improvements include:</b>
		<p/>
		<ul>
			<li>Many bug fixes and tool stability improvements</li>
		</ul>
	</li>
	</ul>

</body>
</html>