© ItBuzzPress 2018
1.1. Foreword
WildFly is the latest version of the popular open source JBoss application server. It is exceptionally
lightweight, featuring unparalleled speed and supporting the latest standards, including Java EE 7.
I’m Brian Stansberry, the technical lead for WildFly’s Operations, Administration and Management
(OA&M) functionality, a role I’ve been in since the start of the JBoss AS 7 project. So as you can
imagine this book’s topic is near and dear to my heart. One of the biggest priorities of AS 7, WildFly
and JBoss Enterprise Application Platform 6 has been to improve the application server’s
manageability, and after a lot of dedication, sleepless nights and coffee I feel we’ve come a long
way. I hope after reading this book you’ll agree. The biggest improvement in WildFly 8 over AS 7
besides the new Java EE 7 API compatibility is in the OA&M area with the addition of fine-grained
role based administrative access control, a feature that is a focus of the Security chapter of this
book.
I first heard about the author when he authored "JBoss AS 5 Development" in 2010 and was a JBoss
Community Recognition Award Winner for his application server documentation. For many years
now he has been an active and important part of the JBoss Application Server and WildFly
community, consistently producing high quality documentation covering the application server and
middleware in general.
I was very pleased to hear that Francesco was planning to write a book on WildFly 8. High quality
books like this one are critical to the success of open source software, and Francesco has the
expertise to cover the topic well and a great reputation for doing an excellent job.
I hope you’ll find this WildFly Administration Guide as thorough and well written as I did. WildFly’s
web console and its command line interface (CLI) administration tool are well covered, as are all of
the key areas of application server administration. This book definitely belongs on the bookshelf of
anyone administering WildFly or developing application for it.
Brian Stansberry
1.2. Preface
WildFly is the continuation of the release cycle of the application server community edition, which
was previously known as JBoss AS 7. The last official release of JBoss AS 7 was the 7.1.1.Final,
although a more recent 7.2 version is available as source to be built on Github
(https://github.com/jbossas/jboss-as/archive/7.2.0.Final.tar.gz) source code repository
You might wonder why the application server changed its popular name. Actually, there’s more
than one reason for this change, the first one being to avoid confusion between the commonly
referred community version (JBoss AS) and the Enterprise version supported by Redhat. Besides
this, in the last years lots of new projects grew up in the JBoss.org site which included the "JBoss"
1
brand in it (e.g. JBoss ESB). For this reason, the term “JBoss” was often misused sometimes to mean
the application server sometimes else to mean a brand of products.
The rename applies, however, only for the JBoss Application Server community edition. The
licensed version is still named JBoss Enterprise Application Platform (JBoss EAP). So from now on,
when someone refers to WildFly, we clearly know they are talking about the Community project
and specifically the application server project.
Besides the new brand name, the WildFly application server follows the same path traced by JBoss
AS 7: this means a truly modular and lightweight kernel with advanced management capabilities.
In addition to this, the new application version supports the latest changes in terms of Java EE
technology, offering richer management capabilities, a more advanced security control and some
important updates as well in the Web server tier.
Red Hat, Red Hat Enterprise Linux, JBoss, are trademarks of Red Hat, Inc., registered in the
United States and other countries.
Linux ® is the registered trademark of Linus Torvalds in the United States and other
countries.
JBoss
AS 5 Performance Tuning, Packt Publishing (December
2010)
JBoss
AS 7 Configuration, Deployment, and Administration, Packt Publishing (December 2011)
Infinispan
Data Grid Platform, Packt Publishing (June 2012)
co-authored with Manik Surtani
(Infinispan Project lead)
JBoss
AS 7 Development, Packt Publishing (June 2013)
Enterprise
Application Server CookBook, ItBuzzPress (September
2013)
Practical
Java EE Development on WildFly (June 2014 – Updated on
April 2018 )
2
In March 2018 Francesco published his first sci-fi novel named Chronicles from a Simulated World
which covers in an earthy and rational style the discussion about the Simulation Hypothesis.
Chapter 2, Basic server configuration discusses the core configuration of the application server
both in standalone mode and in domain mode, including detailed steps to setup a suggested domain
configuration topology.
Chapter 3, Server Management with the Web console covers the Web based administration
interface that can be used to manage the application server.
Chapter 4, Server Management with the CLI introduces the reader to the Command Line
Interface which is the recommended management tool.
Chapter 5, Advanced CLI features covers some advanced tasks that can be pursued with the CLI
such as batch scripts, suspending server execution, executing commands in offline mode and more.
Chapter 6, Deploying applications encompasses in detail all available options to deploy Java
Enterprise applications on the application server.
Chapter 8, Configuring Undertow discusses about the new fast and furious Web server
implementation named Undertow
Chapter 9, Configuring EJB Container covers the nuts and bolds of the EJB Container
configuration
Chapter 10, Configuring Logging covers the configuration of log subsystem, including all available
log handlers, and best practices to log to your own requirements
Chapter 11, JMS Configuration is about the nuts and bolts of WildFly’s JMS provider which is now
ActiveMQ Artemis messaging system.
Chapter 12, Application Server classloading is a deep dive into the application server’s modular
3
kernel and how to configure it to load libraries needed by your applications.
Chapter 13, Clustering covers the application server clustering capabilities that serve as an
essential component to provide scalability and high availability to your applications.
Chapter 14, Load Balancing Web Applications discusses the other key concern of clustering, that
is the ability to make several servers participate in the same service and do the same work.
Chapter 15, Securing WildFly with Elytron covers the new Elytron Security subsystem
Chapter 16, Legacy Security covers the foundation of the application server Security framework
using the Legacy Security Framework
Chapter 17, RBAC and other Constraints covers aspects of the application server security, such as
Role Based Access Control which are not specific to the security framework adopted
(Elytron/legacy)
Chapter 18, Using WildFly with Docker features the application server seen from the Docker
perspective, including some basic container tasks and advanced tactics.
Chapter 19, Configuring MicroProfile capabilities introduces the new MicroProfile extensions,
which is an essential feature if you are developing portable services to be executed in container
environments.
This book is especially suited for Java system administrators that are going to manage the new
release of the application server. Developers, and application testers will be as well more
productive after learning this book. Prior knowledge of the earlier version of the application server
is not required, although that could make easier to understand some core concepts contained in
this book.
Please address comments and questions concerning this book to the publisher:
info@itbuzzpress.com. We have created a web page for this book, where we list errata, examples,
and any other information. You can access this page at:
http://www.itbuzzpress.com/news/wildflyadmin-errata.html
For more information about our books, and future projects see our website at:
http://www.itbuzzpress.com
1.5.3. Piracy
The uploading/downloading of copyrighted material without the express written consent of the
content copyright holder is strictly forbidden. Piracy is an illegal act that you may aspire to
reconsider. Besides this, piracy is not a victimless crime! It is financially damaging and personally
hurtful to company employees and their families. Legitimate users suffer as well. We appreciate
your help in protecting the valuable content of this book.
4
1.5.4. Book Version
This book contains lots of script files and commands to be executed on your machine. Much effort
has been put to make the code as much as readable as possible.
The following script snippet (in a blizzard blue) identifies a command to be executed on your
operating system’s shell:
$ ./jboss-cli.sh
As you can see from the prompt, we have assumed that you are executing on a Linux/Unix
machine. At the beginning of the book, we have also provided the equivalent Windows syntax of
some core commands:
C:\Users\jboss\wildfly-14.0.0.Final\bin jboss-cli.bat
To avoid being repetitive, we have however used the Linux shell syntax for the rest of the book.
Within the book, you will find also some gray-filled block of code like the following one:
"outcome" :
"success",
"result" : {}
This piece of code identifies a command to be executed within the application server’s Command
Line Interface (Using the CLI). Therefore, executing this command in the operating system’s shell
will obviously return an error.
5
This book is dedicated is lovingly dedicated to all people that helped me to find my verse in the
powerful play that’s life.
6
2. Getting started with WildFly
WildFly is a Java middleware product also known as application server. The word “application
server” has been coined in relation to Java Enterprise application; you can think of it as it’s a piece
of Java software where your application can be provisioned using the services provided by the
application server. Within this book you will learn how to configure these services, how to govern
them with authorization/authentication policies and how to extend the capabilities of the
application server.
Our journey through the application server will begin with the initial setup of your environment
and some basic administrative tasks. More in detail this chapter will cover the following topics:
• How to create a management user which will be in charge to handle server administration
The first release of WildFly application server introduced several important changes from the
former JBoss AS 7 platform. Changes were equally split into the development area and into the
administration of the server. Here is a break down of the most significant news:
• Java EE 7 API support: The Java Enterprise API v. 7 has been fully integrated into the
application server. Some of the major enhancements included in the application server include:
• Java API for JSON Processing 1.0 (JSON-P): This API elevates the capabilities of JSON based
applications by defining a new API to parse, generate, transform and query JSON documents.
Therefore, you will be able to build a JSON object model (just like you did with DOM for XML
based applications) and consume them in a streaming fashion (as you did with XML using
StAX).
• Batch Application API 1.0: this API has been designed to standardize batch processing for Java
applications. You can think of it as a replacement for your older, bulk, long running procedures
that were managed by shell scripting or dated languages such as COBOL. The new Batch API
provides a rich programming model oriented to batch scripting which allows defining, partition
and forking the execution of jobs.
• Concurrency Utilities for Java EE 1.0: this API is an extension to the Java SE Concurrency
Utility (JSR-166) which aims to provide a simple and standard API for using Concurrency from
Java Enterprise components preserving the container integrity. This API can be used along with
7
asynchronous processing APIs in Servlets or for creating custom executors in advanced use
cases.
• Other API enhancements: besides the additions mentioned so far, there are further
enhancements in existing areas such the JAX-RS 2.0, which now includes a Client API for async
processing, a matching Server side asynchronous HTTP response and the addition of Filter and
Interceptors for proxying REST communications. Another area of improvement is the JMS 2.0
API, which now delivers a JMSContext resource as a wrapper for JMS Connection, Session and
Message Producer objects, and several enhancements such as the simplified ConnectionFactory
injection (which has finally a platform default) or the inclusion of delayed delivery and async
send. Other minor improvements are spread across the entire API (e.g. EJB 3.2, Servlet 3.1, EL
3.0, CDI 1.2 etc.). If you want to learn more details about it please consult the official Java EE 7
tutorial at: http://docs.oracle.com/javaee/7/tutorial/doc/
• Role Based Access Control: before WildFly 8, administrative users were not associated with a
particular role; in other words, once created a Management user then you were entitled to
perform any change to the server configuration like a classic super user. Now you can associate
each Management user with one role and even configure constraints, which allow you to tweak
the behavior of roles.
• New Web Server: WildFly has switched to a different Web Server implementation named
Undertow, which is the embedded Web server providing both blocking and non-blocking API
based on NIO. Besides the API enhancements, the Undertow Web server can provide better
flexibility thanks to its composition based architecture that allows you to build a Web server by
combining small single purpose handlers.
The release 9 of WildFly application server introduced several bug fixes and also some interesting
management enhancements in the platform. Here is the list of the most interesting ones:
• WebSocket 1.0: Before the advent of HTML 5, the traditional request-response model used in
HTTP meant that the client requested resources and the server provided responses. Therefore,
unless you are continuously polling the server, there is no way to way to provide dynamic
changes to your Web pages. The WebSocket protocol addresses these limitations by providing a
full-duplex communication channel between the client and the server without any latency
problem. Combined with other client technologies, such as JavaScript and HTML5, WebSocket
enables web applications to deliver a richer user experience.
• Front-end load balancer support: using an external Web server (like Apache) as load balancer
is now optional. Now you can configure WildFly’s web server (Undertow) to balance requests to
a cluster of WildFly servers through the mod_cluster protocol.
8
• Improved Datasource configuration: the datasource subsystem reflects the changes in the
pool policy introduced by IronJacamar Project 1.2.4 which contains a reworked set of policies
and a connection tracer to detect leaks in the pool.
• Improved Web console: The Web administration console includes a new improved UI layout
and several additional capabilities such as Datasource templates, enhanced subsystem
configuration or improved log viewer.
• CLI Suspend mode: It is now possible to put the application server in suspend mode, to allow
the termination of current sessions before shutting down the server. The suspend mode is
reversible so that is can also return the server in running mode.
• Offline management The Command Line interface allows the management of resources
without a running server.
• HTTP/2 Support: Undertow includes support for the new HTTP/2 standard which reduces
latency by compressing headers and multiplexing many streams over the same TCP connection.
In this application server release a major restructuring began that will continue in the 1x releases.
These changes are both related to some single subsystems (such as the messaging subsystem) but
also to the whole server infrastructure. Expect some further changes in the 11 release of the
application server which will include a re-shaped security subsystem.
• New Messaging subsystem: the new messaging provider embedded in WildFly 10 is Apache
Artemis MQ which is derived from the HornetQ project, recently donated to the Apache
foundation. The new messaging provides retains compatibility with the former HornetQ while
providing several new features.
• Capabilities: Beginning with WildFly 10 the application server’s management layer includes a
mechanism for allowing different parts of the system to integrate with each other in a loosely
coupled manner. This happens thanks to a new component called “Capability”. Typically a
Capability works out by registering a service with the WildFly’s ServiceContainer, and then
dependent capabilities depend on that service. The WildFly Core management layer
orchestrates registration of those services and service dependencies by providing a means to
discover service names. Discussing about Capabilities is beyond the scope of this book.
• Improved ejb subsystem: the ejb pooling configuration has been revamped so that now it
includes multiple self-tuning policies applicable to Stateless EJB and to Message Driven Beans.
An advanced delivery policy (group based) can now be used by Message Driven Beans.
• Migration from legacy subsystems: an automatic CLI-based migration procedure has been
added to help users migrate the former legacy systems (jbossweb, messaging, jacorb) into
WildFly 10.
• Updated Hibernate API: the most relevant change for developers is the introduction of
Hibernate 5 API that includes several additional improvements spanning from performance
optimization (mainly due to bytecode enhancement), the use of generics in Hibernate Native,
and an improved SPI for second level cache providers. This topic, being focused on the
development of applications, is not in the scope of this book.
9
In terms of JDK, WildFly has discontinued support for Java 7. Hence, you need a
Java 8 or newer environment on your machine. If you are porting the former
startup scripts, you have to replace the deprecated JVM parameter named
-XX:MaxPermSize with the new -XX:MaxMetaspaceSize.
The release 11 of WildFly application server introduced several important changes spanning from
the new security infrastructure to simplified client naming lookup. This version includes also
several management enhancements to ease server administration. More in detail, this is a break
down of the latest significant news:
• New Security Infrastructure: a long awaited change is the new Security Provider named
Elytron which will be able to unify the whole security infrastructure in a single subsystem.
Elytron will bring also advanced capabilities such as privilege propagation across multiple
service invocations, pre-request TLS verification, identity switching, pre-request TLS
verification, and rich security policies. Finally it also improves the overall extensibility of the
system with tight integration with other SSO / IDP frameworks such as KeyCloak.
• SSL enhancements: You can switch from the JVM internal implementation of SSL to your own
OpenSSL library available on your system. This library can in turn be used (for versions greater
than 1.0.2) to support HTTP/2
• EJB made easier: several enhancements have been included to simplify the discover of EJB
resources thanks to a new naming library. Also the EJB naming proxies now allow more
advanced strategies such as dynamic discovery or point to point communication from proxies
to EJB.
• RMI over HTTP In order to allow load balancing of EJB request through a standard HTTP
request (which can be leveraged by any load balancer) you can now opt for a pure HTTP
communication for EJBs.
• New Load balancing Profile: If you are planning to use WildFly as front load balancer to a set
of WildFly backend, then you can use one out of the box configuration named standalone-load-
balancer.xml
• Graceful shutdown of the Server: the application server is now able to start in suspend mode
plus a set of improvements are available to handle distributed transactions when a graceful
shutdown has been issued.
• Remote managed deployments: you are now able to update remote managed deployments by
including content items such as html or JSP files without a full application redeployment
• Java EE 8 Profile: the application server includes now a Java EE8 configuration which can be
10
activated at start-up
• New thread pool trategy: A new thread pooling strategy is available. This allows reducing the
number of threads active at any given time, which helps conserve system resources.
• Other Minor enhancements: (MicroProfile REST Client 1.0 is now supported, Java 9
compatibility has been improved and CLI scripts can now take advantage of loops with
variables)
The 13th release of WildFly includes provisioning enhancements for the application server and UI
upgrades along with some core libraries upgrades:
• Galleon project: WildFly can now be internally provisioned using the project Galleon which
allows to provision the desired installation at a specified location, install additional and/or
uninstall existing feature-packs, export the currently provisioned specification to a file with the
purpose to reproduce it on a different machine.
• New Web Console: a new version of the Web management console (HAL) is available which
uses PatternFly as technical stack instead of GWT. The new version of the Web console enhances
the existing features and adds support for many new subsystems and attributes.
• Other enhancements: Infinispan has been updated to version 9.2 and Hibernate to version 5.3.
The 14th release of WildFly includes several enhancements. The most important one is the Java EE8
full compatibility so now all default configuration include the EE8 APIs. Additionally the following
enhancements have been included:
• Agroal Datasource: the application server can now be configured to use a JCA-less connection
pool with increased performance and low memory footprint.
• MicroProfile Capabilities: This version of the application server includes support for some
Eclipse MicroProfile capabilities such as the Configuration MicroProfile which enhances the
application’s configuration capabilities, a MicroProfile for Server Health checking and an API
for accessing an OpenTracing compliant Tracer object within your JAX-RS application.
• Mod-Cluster Multiplicity: Mod-cluster has now been enhanced to support multiple web server
configurations by declaring and referencing multiple mod-cluster configurations within its
subsystem.
11
source implementation of it called OpenJDK http://openjdk.java.net/
Once installed the JDK, you have to set the JAVA_HOME environment variable accordingly.
Windows users: Right click on the My Computer icon on your desktop and select properties. Then
select the Advanced Tab contained in the Environment Variables button. Under System Variable,
click New. Enter the variable name as JAVA_HOME and value the Java install path. Click OK and
Click Apply Changes.
Linux users: Enter in your .profile / .bash_profile script the following (substitute with the actual
JDK installation path):
export JAVA_HOME=/usr/java/jdk-9
Done with JDK installation, let’s move to the application server. WildFly can be downloaded from
http://www.wildfly.org by following the Downloads link in the home page. Once downloaded,
extract the archive to a folder and you are done with the installation.
$ unzip wildfly-14.0.0.Final.zip
Through this book we will refer to JBOSS_HOME as the location where you have
installed WildFly. As you will see later in this chapter, it is not however
mandatory to set this variable on your operating system to run WildFly.
12
As you can see, the WildFly file system is divided into two main parts: the first one, which is
pertinent to a standalone server mode and the other that is dedicated to domain server mode.
Common to both server modes is the modules directory, which is the heart of the application
server.
Following here are some details about the application server folders:
• appclient: contains configuration files, deployment content, and writable areas used by the
application client container run from this installation.
• bin: contains start up scripts, start-up configuration files and various command line utilities like
vault.sh, add-user.sh. Inside the client subfolder, you can find a client jar for use by non-maven
based clients. The other folders (service, init.d) are used respectively to install WildFly as a
Service on Windows and Linux machines.
• standalone: contains configuration files, deployment content, and writable areas (such as logs)
used by the single standalone server run from this installation.
• domain: contains configuration files, deployment content, and writable areas (such as logs)
used by the servers which are part of a domain.
13
2.4. Starting WildFly
The application server ships with two server modes: standalone and domain mode. The difference
between the two modes is not about the capabilities available but is related to the management of
the application server: in particular, the domain mode is used when you run several instances of
WildFly and you want a single point where you can manage servers and their configuration.
In order to start WildFly using the default configuration in "standalone" mode, change the directory
to $JBOSS_HOME/bin and issue:
$ ./standalone.sh
To start the application server using the default configuration in "domain" mode, change directory
to $JBOSS_HOME /bin and execute:
$ ./domain.sh
When starting in standalone mode, you should find in your console something like this, at the end
of start up process:
You can verify that the server is reachable from the network by simply pointing your browser to
the application server’s welcome page, which is reachable by default at the following address:
http://localhost:8080
14
2.4.1. Setting the JBOSS_HOME
Although the application server has been renamed to WildFly, the home directory of it can still be
set through the JBOSS_HOME environment variable. Setting the JBOSS_HOME configuration
variable is not a mandatory step. By defining it in your bootstrap file (or in your user’s profile), you
are specifying the folder where WildFly distribution is located. The impact on your administration
is that you can use the standalone/domain startup script from a different location than the server
distribution. The reverse side of the coin is that this can lead to confusion your server
administrator especially if you have this variable buried in one of the many Linux configuration
files.
Whether you decide or not to set the JBOSS_HOME, here is how Linux users could set the variable
to point to a WildFly installation:
$ export JBOSS_HOME=/opt/wildfly-14.0.0.Final
On the other hand, Windows users can set the JBOSS_HOME as in this example:
set "JBOSS_HOME=/C:/jboss/wildfly-14.0.0.Final"
If you want to set the variable permanently on Windows, you have to go through
your System Settings (In the Control Panel), click the Advanced System Settings
link and add the Environment Variable from there.
15
2.5. Your first task: Create an Administrator
If you want to manage the application server configuration using its management instruments, you
need to create a management user.
In order to create a new user, just execute the add-user.sh/add-user.bat, which is located in the
bin folder of the application server’s home. Here’s a transcript of the creation of a management
user:
$ ./add-user.sh
What type of user do you wish to add?
a) Management User (mgmt-users.properties)
b) Application User (application-users.properties)
(a): a
In the above example, we have created a management user named “wildflyadmin” which belongs
to the ManagementRealm and is not part of any group of users. Also, mind to answer the last
question with “yes” or “y” to indicate that the user will be used to connect to the domain controller
from the host controller. The generated secret value is the Base64-encoded password of the new
created user and we will use it when setting up a Domain of application servers.
In WildFly there is a strict control over your passwords. If you want to loosen or strengthen the
password checks, you can edit the add-user.properties file, which is contained in the bin folder of
your server distribution.
16
2.5.1. Creating an user in non-interactive mode
You can also create users using non-interactive mode. In the following example, we are adding a
management (-m flag) user by issuing:
If you need adding an application user, you need to include as well the -a flag as in the following
example, where we are setting as well a group to which the user belongs:
Bear in mind that creating users in this way exposes your user credentials in the shell history and
maybe process table, if you are using a Linux/Unix machine.
On the other hand, the recommended approach is to use the Command Line Interface (CLI)
interface to issue an immediate shutdown command. The CLI interface can be started from the
$JBOSS_HOME/bin folder of your installation:
$ ./jboss-cli.sh
Windows user will start the CLI using the equivalent batch file:
jboss-cli.bat
[disconnected /] connect
Connected to localhost:9990
Now issue the shutdown command that will stop the application server:
[localhost:9990 /] shutdown
You can optionally include the --restart=true parameter to trigger a server restart:
17
[standalone@localhost:9990/] shutdown --restart=true
Additionally, we will learn a first CLI trick that is executing a command in no-interactive mode. So
here is how to shut down the application server with a single command line:
$ ./jboss-cli.sh -c --command=shutdown
If you are connecting to a remote WildFly instance, then a password will be requested when you
issue the CLI command:
Username: wildflyadmin
Password:
Connected to 192.168.10.1:9990
Once connected, we will issue the shutdown command just like we did from the local host:
[192.168.10.1:9990 /] shutdown
18
15:15:14,738 ERROR [org.jboss.msc.service.fail] (MSC service thread 1-4)
MSC000001: Failed to start service
org.wildfly.undertow.listener.default:
org.jboss.msc.service.StartException in service
org.wildfly.undertow.listener.default: **Address already in use /127.0.0.1:8080
at org.wildfly.extension.undertow.ListenerService.start(ListenerService.java:179)
at
org.jboss.msc.service.ServiceControllerImpl$StartTask.startService(ServiceControllerIm
pl.java:1714)
at
org.jboss.msc.service.ServiceControllerImpl$StartTask.execute(ServiceControllerImpl.ja
va:1693)
at
org.jboss.msc.service.ServiceControllerImpl$ControllerTask.run(ServiceControllerImpl.j
ava:1540)
at
org.jboss.threads.ContextClassLoaderSavingRunnable.run(ContextClassLoaderSavingRunnabl
e.java:35)
at
org.jboss.threads.EnhancedQueueExecutor.safeRun(EnhancedQueueExecutor.java:1985)
at
org.jboss.threads.EnhancedQueueExecutor$ThreadBody.doRunTask(EnhancedQueueExecutor.jav
a:1487)
at
org.jboss.threads.EnhancedQueueExecutor$ThreadBody.run(EnhancedQueueExecutor.java:1378
)
at java.lang.Thread.run(Thread.java:745)
In this case, you should be able to find the service that is locking the ports used by the application
server which are by default the 8080 and the 9990. Most Unix systems have the built-in fuser
command that returns the process which is engaging a port :
On Windows, you can use the netstat command to get network information about the running
processes.
C:>netstat -ao
Other common start up issue may happen if you have manually changed the configuration file, and
corrupted its XML schema. Manually changing the XML configuration file it is discourage, however
you can find the cause (and the line number) by searching through the startup logs:
19