JBoss AS 7: Updated look&feel for CR1

The JBoss 7 console gets a new look&feel with AS 7.1.CR1:

Before



After

iOS design pattern resources

The guys from Cocoanetics have published a great collection of iOS related design pattern resources:

Have a look, be inspired.

JUDCon India, Call for Papers

JUDCon 2012: India, January 24-25 in Bangalore, will be one of the premier technical JBoss developer events in India. JUDCons attract many of the best and brightest to present, and exchange ideas on JBoss technology.

Got something to say? Say it at JUDCon 2012: India.

The JUDCon call for papers is open now through November 26, and session tracks include:

• JBoss AS7 Application Server
  
• Rules, Workflow, SOA and EAI
  
• OpenShift / Cloud
  
• Cool Stuff (that we just can’t leave out)
  

Submit your papers here:

http://www.jboss.org/events/JUDCon/2012/india/cfp

Networked Society "on the brink"

Nielsen: Eyetracking studies

Interesting study about how users read on the web: Eyetracking Study of Web Readers

One Day Talk: Introduction to JBoss AS 7

Here are my slides from this year one day talk in munich:

One daytalk hbraun_oct2011

View more presentations from hbraun

Turning my room into a kanban board

Work needs to be organized. Here's my DIY, pseudo Kanban Board:





(This is actually the first post, where the name of this blog kind of makes sense...)

Managing JBoss7: Virtual Machine metrics

We've added some simple VM views to current beta upstream. It allows you to monitor thread and heap usage of the VM the server uses:




There's room for improvements. Tell us what you think...

JBoss One Day Talk Munich, 13. Oktober

OneDayTalk 2011 - the conference for JBoss and Java Enterprise technologies

As the successor of the successful JBoss OneDayTalk 2010 conference, the JBoss User Group Munich e.V. will organize a full day JBoss conference in Munich again. On 13.10.2011, everything will once again revolve around JBoss technologies and Java frameworks, with the focus on current topics such as Enterprise in the Cloud, Security, Operations, High Availability, Scalability, ESB,Web 2.0, Mobile, Clustering, and BPM / BPEL / BRM content.

As the successor of the successful JBoss OneDayTalk 2010 conference, the JBoss User Group Munich e.V. will organize a full day JBoss conference in Munich again.On 13.10.2011, everything will once again revolve around JBoss technologies and Java frameworks, with the focus on current topics such as Enterprise in the Cloud, Security, Operations, High Availability, Scalability, ESB, Web 2.0, Mobile, Clustering, and BPM / BPEL / BRM.

A large number of globally renowned speakers from Europe and the U.S. will come together on 13.10.2011 in the Konferenzzentrum München (Conference Center Munich) to present their practical knowledge, to report on project experiences and to provide you with the latest developments in software technology around JBoss, Java 6 and Java EE. The broad-based range of topics aimed not only at software developers and architects, but project managers and IT decision makers are also provided by leading JBoss project leads and core developers with valuable information.
The time between the presentations offers you many ways to get information from the exhibitors to have conversations and discussions with speakers and other participants, and not least to maintain your own network.

We are looking forward to see you on the conference - the registration is now open!

Developer notes: How does data binding and model conversions work in the AS 7 console?

The JBoss AS 7 management layer works on a detyped, tree like mode structure to represent subsystem and server configuration options. The big benefit is that management clients don't depend on statically typed model, but instead rely on a fairly small API that's not subject to change. The model itself can easily be converted to and from JSON, which opens the management layer to variety of scripting environments and alternate management implementations.

As many of you know, the management web interface is implemented in GWT. The means we cross compile from Java to Javascript, but all development is done in Java. Many of the default GWT components like tables, trees and lists expect a strongly typed Java model, since this would be logical choice for most GWT implementations. For us, working on the management web interface this means we have to bridge the gap between the detyped model the application server uses and the strongly typed model the GWT components rely on.

In this post I am going to explain some of the building blocks we use within the management interface, to reduce the amount of boilerplate we have to provide converting between the two model representations.


The detyped model

A typical model representation we get from the AS management layer looks like this:

[domain@localhost:9999 /] /subsystem=datasources/data-source=ExampleDS:read-resource
{
    "outcome" => "success",
    "result" => {
        "connection-url" => "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1",
        "driver-name" => "h2",
        "enabled" => true,
        "jndi-name" => "java:jboss/datasources/ExampleDS",
        "jta" => true,
        "password" => "sa",      
        "use-ccm" => true,
        "user-name" => "sa",
    }
}

In this case we are looking at a data source.
In order create and modify datasource, the management client would need to send a detyped representation like the one above and will get a response of the same content type.

GWT entities

Entities in GWT are represented as Java interfaces with getter and setter methods (AutoBean API). The corresponding representation for the data source above, would look like this:

@Address("/subsystem=datasources/data-source={0}")
public interface DataSource {

    @Binding(detypedName = "jndi-name")
    String getJndiName();
    void setJndiName(String name);

    @Binding(detypedName = "user-name")
    String getUsername();
    void setUsername(String user);

    String getPassword();
    void setPassword(String password);

    [...]
}

Coverting between two models

Converting between the two model representation is the job of the EntityAdapter. An EntityAdapter works on the meta data declared on the entity class (@Address & @Binding annotations). The metadata itself is extracted during the compile time phase (deferred binding) .

The current meta data structure is divided into two distinct concepts: Entity addressing and the property binding. The address is required to perform operations on the detyped model ("/subsystem=datasource/data-source=ExampleDS:read-resource"). The property binding is used to get and set values within both models.

Let's take a look at an example:

// Create an EntityAdapter for a specific type
EntityAdapter adapter = new EntityAdapter(DataSource.class, metaData);

// Convert from entity to DMR representation
DataSource datasource = ...;
ModelNode operation = adapter.fromEntity(datasource);

// execute the operation (HTTP request) ...

First of all, we create an EntityAdapter for the DataSource.class type. This adapter allows us to convert an entity instance (DataSource datasource) into a ModelNode (detyped) representation. We can use this model to execute an operation against the AS management layer (HTTP Post).

Let's do it vice versa: Reading a detyped model and convert it into an entity.

// Create an EntityAdapter for a specific type
EntityAdapter adapter = new EntityAdapter(DataSource.class, metaData);

ModelNode detyped = ...; // HTTP response

// Convert form DMR to entity
DataSource datasource = adapter.fromDMR(detyped);

// Work on the entity ....

Addressing of resources

As you can see in the above example, the entity carries an @Address annotation. In order to read from or write the management layer you would need to know how to address a resource properly. For datasources this would be:

/subsystem=datasources/data-source=ExampleDS

There are many cases where we need an address. It makes sense to associate this information with the entity itself and use it as a template for subsequent requests. I.e an address template like "@Address("/subsystem=datasources/data-source={0}")"

AddressBinding address = metaData.getBeanMetaData(DataSource.class).getAddress();
ModelNode operation = address.asSubresource("ExampleDS");

// further specify the operation (OP, RECURSIVE,ETC)
operation.get(OP).set(READ_RESOURCE);

// execute the operation (HTTP request) ...

What's next?

We have seen how two specific problems are solved: Addressing of resources and converting between two model types. In the next part of this series, I am going to explain how the actual data binding (mapping to HTML forms) actually works.

Geoffrey West: The surprising math of cities and corporations

Physicist Geoffrey West has found that simple, mathematical laws govern the properties of cities -- that wealth, crime rate, walking speed and many other aspects of a city can be deduced from a single number: the city's population. In this mind-bending talk from TEDGlobal he shows how it works and how similar laws hold for organisms and corporations.

Visual weight of primary and secondary action buttons

Pretty interesting observation on why the irreversible, permanent action should become the secondary button:

http://uxmovement.com/buttons/the-visual-weight-of-primary-and-secondary-action-buttons/

Heap profiling on chrome

Neat: http://code.google.com/chrome/devtools/docs/heap-profiling.html
It's becoming more important when you move to resource limited devices, such as pads and phones.

JBoss AS 7: Admin Guide, first draft

I did finish the first draft of the AS7 "Admin Guide". It is intended for people who need to setup and configure the JBoss Application Server:

https://docs.jboss.org/author/display/AS7/Admin+Guide


Let me know what you think. There is plenty of room for improvements.Please send any comments and questions to the mailing list:

https://lists.jboss.org/mailman/listinfo/jboss-as7-dev

JBoss One Day Talk Munich

Liebe JBoss OneDayTalk-Interessierte,

endlich ist es soweit und wir sind seit gestern mit dem Programm der JBoss OneDayTalk 2011 Konferenz online gegangen. Die Konferenz findet dieses Jahr am 13. Oktober 2011 in München statt. Und die Online-Registrierung ist jetzt geöffnet mit einer regulären Teilnahmegebühr von 89, - EUR. Sichern Sie sich jetzt bis zum 30.06.2011 ein Early Bird von 10%.

Es wird diesmal drei Tracks, 18 Vorträge und 20 Speakers geben. Das Programm und bereits bestätigten Talks finden Sie unter http://onedaytalk.org/index.php/program.

Unter den Speakerns sind unter anderem Adam Bien, Gavin King, Stefan Tilkov, Michael Plöd, Jan Wildeboer, Heiko Braun, Heiko Rupp, Werner Eberling, Volker Bergmann und Kris Verlaenen. Alle Speaker finden Sie unter http://onedaytalk.org/index.php/speakers.

Wir freuen uns über Ihre Teilnahme und für weitere Information besuchen Sie unsere Web Seite http://onedaytalk.org.


Viele Grüße vom JBUGM Team
http://www.jbug-munich.org

AS7 Console performance improvements

I did take a look at the components that serve the console files again and removed some really sloppy parts and tweaked the HTTP cache behavior a little bit. With some really interesting results.

This is what the average page loading time looked like, when client did access the console for the first time:



This is what looks like after the improvements:



It get's even better, when a client does access the console subsequently:



How can it be explained?

Well the most notable improvement is probably the replacement of the sloppy IO parts. Hence the drastic page loading times from ~4sec to ~1sec. Furthermore the addition of an HTTP "Expires" header allows the browser to successfully cache the results, which drastically decreases the page loading size from ~750kb ~10kb. All tests have been run on a LAN connection.

Managing JBoss7: Console Beta9 released

We just updated to 1.0.0.Beta9:
===================

- suport for standalone
- i18n
- deployments
- authentication

- datasources
- jms configurations
- messaging
- web subsystem

- server groups
- server configurations

- system properties
- jvm options
- socket bindings


The given functionality has small glitches here and there but most of it has been reported and is being worked on. In terms real tasks, this is still outstanding:

- transaction subsystem
- security
- webservices
- threads
- logging

But we expect this to be ready for 7.0.CR1.

Give it try & let us know what you think.
Tell us what works and what doesn't.

How do I access the console?
==================

http://localhost:9990/console



How do I enable authentication?
====================

Simply create a security realm configuration.
This needs to be done in "domain/configuration/host.xml" for domain mode:

<management>
       <security-realms>
           <security-realm name="ManagementRealm">
               <authentication>
                   <users>
                       <user username="admin">
                           <password>
                               password
                           </password>
                       </user>
                   </users>
               </authentication>
           </security-realm>
       </security-realms>
   </management>
   <management-interfaces>
       <native-interface interface="public" port="9999"/>
       <http-interface interface="public" 
            port="9990" security-realm="ManagementRealm"/>
   </management-interfaces>

Or "standalone/configuration/standalone.xml":

<management>
       <security-realms>
           <security-realm name="ManagementRealm">
               <authentication>
                   <users>
                       <user username="admin">
                           <password>password</password>
                       </user>
                   </users>
               </authentication>
           </security-realm>
       </security-realms>
   </management>

   <management-interfaces>
      <native-interface interface="default" port="9999"/>
      <http-interface interface="default" 
              port="9990" security-realm="ManagementRealm"/>
   </management-interfaces>

How do I switch between standalone and domain administration?
========================================

Just boot AS7 in either one of these modes and reload the console web application.

WebKit Remote Debugging

Interesting, remotely connect the web inspector to a web kit instance:
http://www.webkit.org/blog/1620/webkit-remote-debugging/

Managing JBoss7: Messaging Provider Settings

This should give you an idea how the HornetQ configuration is going to look like:

Messaging Provider




Queues & Topics

Managing JBoss7: Datasource Configurations

We've begun working on datasource configurations within the web management interface. While it still requires some finishing touches, here's how regular and XA datasource configurations look like:

Managing JBoss7: Staging Applications

Your colleagues are all stressed out, because the new build of your b2b app needs to be put on a staging server for your external partner to verify the recent API changes. How to get this setup and running without interfering with the existing production system? It's fairly simple. I'll show you ...

Step1: Create a dedicated server group for your staging servers

Step2: Prepare a staging server-configuration

A custom server-group separates our staging environment from the production servers.

... with a specific port offset

You need to remember this, in order to connect to the server instances later on.

Launch a server instance

So we can connect to it.

Deploy your application

In this case a simple web application.

... to the staging server-group

Domain deployments are always associated with server-groups.

Verify it has been deployed successfully

Grab a coffee and relax

Fairly simple, no?

Managing JBoss 7: UX updates

The current JBoss 7 development stream contains an updated version of the console that will be shipped with Beta3. We've removed the clutter on the left hand side and do now provide a cleaner separation between navigation and functional elements. The LHS is now only used for navigational purposes and the any functional element (i.e. add, delete resources) has been moved to the toolstrips on the right hand side. Along with this change we've turned the stacked navigation sections (used to display only one at a time) into a more tree like structure, that shows all available options at one glance.

In our opinion this make it much easier to find relevant management options within the UI. Let us know what you think. Screenshots attached.

Server Configuration



Data Source Management

JBoss 7 Web Console: 1.0.0.Beta3

Beta3 is the version that will be shipped with JBoss 7.0.0.Beta2 end of this week.

1.0.0.Beta3 Release Notes

Functional scope

Most of the work in this release has been done on the framework level, creating re-usable components that are needed to implement the remaining management use cases:

• Form databinding & validation
• Integration with the domain controller
• General UI framework (MVP)

Functionally this release does focus on the outermost domain management use cases, that act as POC for the building blocks listed above.

• Start/Stop server instances
• Create server groups and server configurations
• Configure server groups and configurations

The standalone server Web UI doesn't contain any reasonable functionality at this point.

The work on management use cases that relate to subsystems has not begun yet. There are merely two examples (Datasource and JMS) that act as a preview and should give you an idea where things are going.

Browser compatibility

This release has been tested on Chrome, Firefox and Safari. Internet Explorer has not been verified yet, but we don't expect it to work properly in releases before IE8.

Feedback

Your feedback is greatly appreciated. Tell us what you think about the current way the content is organized within the UI. Identify the top three things that don't make sense to you or that you couldn't find easily in the console. Send these issues to:

• jboss-as7-dev@lists.jboss.org

In case you run into a bug, don't hesitate and file an issue here: (Don't forget to include your OS/Browser description)

• https://issues.jboss.org/browse/JBAS (JBoss 7, Component "Web Console")

Firefox 4: App Tab

Now that makes sense:

User Interfaces: Perceived and actual affordance

"According to Norman, affordance refers to “the perceived and actual properties of a thing”, primarily the properties that determine how the thing could be operated. Note that perceived affordance is not the same as actual affordance. A facsimile of a chair made of papier-mache has a perceived affordance for sitting, but it doesn’t actually afford sitting: it collapses under your weight. Conversely, a fire hydrant has no perceived affordance for sitting, since it lacks a flat, human-width horizontal surface, but it actually does afford sitting, albeit uncomfortably.

The parts of a user interface should agree in perceived and actual affordances."

(Taken form MIT Courseware)

Nitro on IOS 4.3

Why is Nitro disabled in UIWebView and full screen web apps on IOS 4.3?
Read more about it here

- More on this topic: http://www.theregister.co.uk/2011/03/15/apple_ios_throttles_web_apps_on_home_screen/

Contributing to the JBoss 7 Management Console

You want to contribute to the management web interface for JBoss ? Then this should get you going.

Codebase

Everything is hosted at github, The best way is to create a fork of either one of the codebases listed below and work on that one.

- Authoritative master: https://github.com/jbossas/console
- Most recent: https://github.com/heiko-braun/as7-console

Prerequisites

The console it self is developed using the Google Web Toolkit. You would need to make yourself familiar with the basics before we et going. The GWT SDK will be installed as part of the maven build. No need to fetch it on it's own. If you plan to work with Eclipse, then you should consider the development tools for GWT that are provided by Google. But please don't ask how things are setup correctly in Eclipse. We baseline on maven and that's it.

Things you need to know

Widgets

We build on GWT 2.2 without any dependencies on external widget libraries. However these is a growing number of widgets (org.jboss.as.console.client.widgets) that should be reused. We aim for keeping the overall number of widgets to a minimum.

But if you need anything that doesn't exist, take a look at the SmartGWT showcase, tell us about it and we'll then consider implementing it.

MVP Pattern

But one of the cornerstones is the GWT Platform library, which nicely abstracts the MVP pattern. It act's as a blueprint for the console design. A good introduction can be found here. (This is a "must read")

AutoBeans

Internal model representations are build as AutoBean's. They align well with the default GWT API and have build-in serialization support. A general guideline: Any domain representation that's used within the console needs to be provided as an AutoBean abstraction. This means that beyond the integration layer (backend calls to the AS 7 domain) entities need to be adopted.

This is necessary to provide a baseline for the data binding used across widgets. Take a look at the form abstractions, then you'll know what I mean. The CellList and CellTable API's are another example.

Discussions

We are using the AS7 mailing lists and/or IRC for discussions of technical matters, improvements, proposed patches, etc:

- https://lists.jboss.org/mailman/listinfo/jboss-as7-dev

- irc.freenode.net#jboss-as7

Managing JBoss 7: Screenshots

To add some meat to the discussion, here are some recent screenshots of the current web interface. It does use a very reduced look&feel at this stage, that allows us to focus on the tasks at hand, without getting distracted too much. In the next iteration we'll look into adding some proper styles, with the help of our design friends from jboss.org.

Server Groups

Deployments (associated with server group)

Server Configuration (on a host)



Server Instances (on a host)

Managing JBoss 7: A task oriented approach

It's been several weeks now, since we started working on the management web interface for JBoss 7. Time to outline some of the general ideas and concepts the console is build on. If you are not familiar with domain management approach that has been introduced in 7.0, you should make yourself familiar with it before reading any further.

Conceptually the domain model consists of three different levels, that we tried to reflect within the user interface: Configuration profiles, server groups and host specific settings.



If you think of these levels as being layered atop of each other, then Profiles would be the bottom most configuration level that acts as a blueprint for the layers atop of it. Profiles consist of subsystem specific settings (i.e. JCA, TX, etc) and are referenced by Server Groups.

Server Groups on the other hand specify configuration properties for a set of Servers that run on different Hosts.

A Host is the top most and most detailed level. It runs Server Instances that belong to a particular Server Group.
While there are numerous ways to organize the information accessible through the web interface, we used a few simple questions to guide our decisions:

- "What are the primary tasks?"

- "At what frequency to these task occur?"

- "What's the impact on related configuration elements?"

The primary tasks already seem to be represented by the different levels described above: Changes to and requests of host specific information is something we expect to occur quiet regularly. This does cover use cases like starting server instances and requesting runtime state information (i.e. metrics).

Creation and modification of Server Groups will probably happen less often, except one specific use case, which is application deployment. Deployments are associated with server groups.

The least likely changes are going to happen on the profile level. I.e the modification of a thread pool size is something you probably wont do very often.

The outermost categorization looks as follows:

Now while this coarse grained organization nicely groups the primary tasks and allows you to focus on the goal you want to achieve, it doesn't give you any clues which configuration properties are inherited from lower levels. Some elements can be specified on a lower and be replaced on higher level (i.e. System Properties in profiles and server groups).

This problem has two sides: On the one hand you need to know where an inherited property comes from in order to change it, on the other hand need to know what impact a modification might have on higher levels (Think of a JVM property on the profile level that impacts all server groups).

This problem isn't solved yet. We are still working on visual distinction that allows you to clearly identify the source level of a configuration property and cross reference it accordingly. It might look like this:

Call for participation

There are plenty of other related topics that we can talk about, but that's it for today. If you want to participate, I would suggest you take a look at the following resources and let us know to what degree the suggested categorization makes sense.

- DomainManagementModelDesign

- jboss_7_0 schema

Stay tuned, we keep you posted.

"The future is bright and the present compelling ..."

Dimitiris about the release of JBoss AS 6 and the work on AS 7:
http://jaxenter.com/jboss-as-6-0-0-final.1-34623.html