Relative Order blog gets a new home

The "relative importance of order" blog has a new home. I am leaving blogspot and move to custom wordpress installation. You can find the new posts here:

http://hbraun.info/

See you,

Heiko

Running an AS7 domain on virtual network interfaces

This article has been moved (and updated) to the new blog:
http://hbraun.info/2012/04/running-an-as7-domain-on-virtual-network-interfaces/

JBoss AS7: Extended management options for messaging server components

We just finished a bunch of updates that complete the management options of the hornetq server components. With 7.1.2 you'll get important management features that have been missing from the previous releases:

- hornetq transports
- connection factories
- bridges, diverts, etc

Switchyard Console Extensions

The management functionality that ships with Switchyard 0.4 is now integrated with the embedded console:



Now we are one step closer to an integrated, consistent web based tooling approach. Great work and congrats to the switchyard team.

Read more about it here.

PicketLink console extensions

The PicketLink team has begun work on integrating security related management tasks into the AS7 console:

https://community.jboss.org/wiki/PicketLinkConsoleForJBossAS7

AS7 Console 1.2.0.Final released

Accessibility Improvements

In this iteration we've been concentrating on improving general usability and accessibility (508 compliance).

The overall UI has been updated so that most elements are keyboard accessible and the core widgets (trees, tables, etc) can be navigated using the keyboard only. In addition to that, we've added W3C Aria landmarks, properties and state attributes.

Internet Explorer Updates

We've also fixed some nasty CSS bugs in IE8 and IE9 which caused the console to render without stylesheets being applied.

All Issues

Here's the complete list of issues that are included in 1.2.0.Final:

• AS7-4255 Help Panels can not be closed on IE9
• AS7-4233 Interface editor doesn't cancel operation upon click
• AS7-4231 Admin console: unable to remove security module if it has properties defined
• AS7-4227 Fix network interface management problems
• AS7-4164 Aria attributes on CellTables
• AS7-4106 Admin console - management of infinispan caches - unable to change attributes
• AS7-4045 Accessibility improvements: keyboard navigation and main aria attributes core widgets and overall layout
• AS7-3743 Sporadic IE 8&9 failure: stylesheets do not load
• AS7-4234 Timeout when uploading large deployment through the console
• AS7-4250 Failed to modify cache container transport settings
• AS7-4104 Admin console - Missing validation of infinispan resources' JNDI names
• AS7-3930, AS7-1779 Infinispan screens require descriptions

GWT Accessibility: Aria attributes on CellTables

While working on the accessibility issues for the AS7 console, we've realized that the new CellTable implementation misses the aria grid attributes. For the ones of you new to this topic: Aria defines a way to make Web content and Web applications more accessible to people with disabilities. It especially helps with dynamic content and advanced user interface controls developed with Ajax, HTML, JavaScript, and related technologies.

We've already submitted a patch to the core GWT team. If this issue is important to you, please vote for it :

http://code.google.com/p/google-web-toolkit/issues/detail?id=7245

JBoss AS7: Console 1.1.0 released

We've added four additional subsystems, that are manageable through the console now.

New Subsystem Support

- mail
- modcluster
- infinispan
- jgroups

This completes the number of manageable subsystems the full-ha profile offers.



In order to access the new functionality, the server needs to be running the full-ha profile:


./bin/standalone.sh --server-config=standalone-full-ha.xml


Environment Properties

This is a feature that has been requested by the community several times: The possibility to view the environment properties (ENV, -Dfoo=bar, etc) that have been set when the server was started.




Rock on´

JBoss AS7: Web Console 1.0.Final released

After several month of work, we are very happy to announce the first final release of the JBoss AS 7 web management interface. It ships with AS 7.1 and covers the following management use cases:

Subsystem Management

About 80% of the subsystems are currently manageable through the console:

• configadmin
• datasources
• deployment-scanner
• ee
• ejb3
• jacorb
• jca
• jmx
• jpa
• logging
• messaging
• naming
• osgi
• resource-adapters
• sar
• security
• threads
• transactions
• web
• webservices

In the next few weeks we are going to provide the remaining ones: infinispan, mail, groups and mod cluster.

General Use Cases

Besides the subsystem configuration, the current web management interfaces allow you to carry out the following operations:

- Full Domain Management (server groups, server configurations and hosts)

- Manage Deployments (both across domains and standalone servers)

- Configure socket bindings, network interfaces, JVM parameters and system properties

Runtime Status

Version 1.0 also provides you with the ability to quickly check the system health:

- JVM Status (heap, threads, etc)

- Transaction Manager (i.e. commit/rollback ratios)

- Datasource usage (pools sizes, etc)

- Web statistics (i.e. request/error count)

- JMS metrics (topic/queue sizes, etc)

- Persistence Units (cache usage, queries, etc)

Improved Look&Feel

We've put a lot of effort into the overall look&feel and tried to come up with a design that's suitable for the job without getting in your way when you use it on day to day basis:

Contributors

Thanks to all the people that did help make it happen. Some people deserve special mentioning for their continuous support and contributions.

- Stan Silvert

- David Bosschaert

- Pavel Slegr

- Jan Martiska

- James Cobb

What's coming next?

We'll keep improving and extending the web management interface. There are plenty of goodies on the roadmap:

- Additional subsystems (infinispan, mail, jgroups, modcluster)

- Management operation plans (store, load & execute complex management tasks)

- Simplified clustering configuration

- Additional metrics and statistics

Tell us what you think

If things don't work as expected or you think certain functionality is missing, please drop us a note. Your feedback is important to us. The AS7 mailing list would be a good starting point:

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

Stay tuned, Heiko.

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.