22 April 2014

Cycle4Sam 5 - Riding 1000km in 6 days for $100k for Women's and Children's Hospital



I recently participated in a week long charity bike ride called Cycle4Sam, where funds are raised to support the palliative care unit at the Women and Children's Hospital of South Australia.

The ride is conducted on a bi-annual basis in honour of young Sam Roberts, who sadly passed away from a rare genetic disease at the age of 4. His parents, Marty and Michelle and his siblings Lucy and Charlie, created the Sam Roberts Family Fund in order to raise funds and provide help for other families who find themselves in the same situation.

http://www.cycle4sam.com/


As the major fundraising effort, the Cycle4Sam ride sees a group of riders raise funds through sponsors to participate in a ride of 1000km. This years ride started on April 12th from the regional South Australia city of Renmark and finished back in Adelaide on April 18th, covering 1000km over 6 days of riding.




Day 1 was run as a loop of the Riverland region, taking in Loxton, Berry and a number of other lovely little towns on the way back to Renmark.  A small ceremony was held at the start to honour and remember Sam and other little children who are suffering in the same way.





Day 2 was a transit stage, riding from Renmark to a small town along the River Murray called Walker Flat.



Day 3 took in a loop of the iconic Barossa Valley region  through the towns of Sedan, Angaston, Tanunda, Mt Prospect and back to Walker Flat.  This day had some nice climbing with the Sedan Hill and Menglers Hill included as the main climbs of the day on the back of the generally rolling terrain of the region.




Day 4 was another long day, riding from Walker Flat to the southern beach town of Carrackalinga.  A planned stop at the Woodstock winery to meet up with another family who were afflicted in the same way as the Roberts saw the day come to a slightly unscheduled but much welcomed end, with a short'ish bus transit down to the final stay over.


Day 5 was a rest-day, or more accurately a non-riding day for those of us with kids, which had us taking the kids for a lovely bike ride along the beach front from Normanville to Carrackalinga, followed by a King of the Mountain event up the Latvian Climb.  Tough work for little legs but they all did superbly.



Day 6 was a loop around the Fleurieu Peninsula taking in the lovely back road around Parawa down to Victor Harbor, down to Goolwa and back to Port Elliot for lunch.  A summit of the Crows Nest followed, by a ride up the Myponga Reservoir climb, closing by a screaming descent down to Carrackaling and back to Normanville.





Day 7 was the final day and took us back to Adelaide through the McLaren Vale, Mylor, Aldgate Valley, Stirling and down the freeway, where we were escorted by the SA Police through to the grounds of the Women's and Children's Hospital.



As part of the closing celebrations, the Roberts Family presented the Women's and Children's Hospital with a cheque for $100,000 that was raised by the event.



http://wchfgivinghearts.org.au/event/cycle4sam


I was in the company of an outstanding group of people performing an outstanding service for the community and I thank them all for the privilege of letting me share the event with them.





03 April 2014

MaxPermSize Be Gone!

Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=256m; support was removed in 8.0
No further commentary required.

25 March 2014

JSON Parsing is Cake with WebLogic Server 12.1.3



Please note: this blog discusses WebLogic Server 12.1.3
which has not yet been released.

Another feature of WebLogic Server 12.1.3 that I'm sure developers will find useful once it is released is the inclusion of an implementation of JSR-353 Java API for JSON Processing.

JSR 353: JavaTM API for JSON Processing

This new API, working from the foundations provided by earlier implementations such as Jackson, Jettison and Google JSon, provides a standard API for working with JSON from Java. The goals and objectives of the API are described in the specification request as:
 JSON(JavaScript Object Notation) is a lightweight data-interchange format.

Many popular web services use JSON format for invoking and returning the data.

Currently Java applications use different implementation libraries to produce/consume JSON from the web services. Hence, there is a need to standardize a Java API for JSON so that applications that use JSON need not bundle the implementation libraries but use the API. Applications will be smaller in size and portable.

The goal of this specification is to develop such APIs to:
  • Produce and consume JSON text in a streaming fashion(similar to StAX API for XML)
  • Build a Java object model for JSON text using API classes(similar to DOM API for XML)
WebLogic Server 12.1.3 includes a module which contains the API/implementation of this relatively lightweight but important API, enabling developers and applications to more easily work with JSON in a portable, standard manner.

 Unlike JAX-RS 2.0 and JPA 2, both of which have pre-existing specification versions that need to be supported by default, there are no additional steps required for applications to use this API with WebLogic Server 12.1.3.  It's simply included as a default module of the server and available for any application to make use of.
The API and implementation is located in this jar file in a WebLogic Server 12.1.3 installation:

$ORACLE_HOME/wlserver/modules/javax.json_1.0.0.0_1-0.jar

In the my previous post, Using the JAX-RS 2.0 Client API with WebLogic Server 12.1.3
I have a short example of using the API to parse an JAX-RS supplied InputStream to marshall a JSON payload into a Java object.

        
        ...
        GeoIp g = new GeoIp();
        JsonParser parser = Json.createParser(entityStream);
        while (parser.hasNext()) {
            switch (parser.next()) {
                case KEY_NAME:
                    String key = parser.getString();
                    parser.next();
                    switch (key) {
                        case "ip":
                            g.setIpAddress(parser.getString());
                            break;
                        case "country_name":
                            g.setCountryName(parser.getString());
                            break;
                        case "latitude":
                            g.setLatitude(parser.getString());
                            break;
                        case "longitude":
                            g.setLongitude(parser.getString());
                            break;
                        case "region_name":
                            g.setRegionName(parser.getString());
                            break;
                        case "city":
                            g.setCity(parser.getString());
                            break;
                        case "zipcode":
                            g.setZipCode(parser.getString());
                            break;
                        default:
                            break;
                    }
                    break;
                default:
                    break;
            }
        }
        ...
The Java EE 7 tutorial has a section showing how to use the new javax.json API which is well worth having a look at if working with JSON is your thing.

http://docs.oracle.com/javaee/7/tutorial/doc/jsonp.htm

Arun Gupta also has a good hands-on lab under development for Java EE 7 that uses the JSON API to read and write JSON into Java objects that represent a movie database.   His examples collaborate with JAX-RS to issue both GET and POST calls to read and update data using JSON payload.

https://github.com/javaee-samples/javaee7-samples

I plan to post a more detailed example of using the API as WebLogic Server 12.1.3 is released.

But for now, the good news is that we are supporting this important new API in our upcoming release of WebLogic Server.

24 March 2014

Using the JAX-RS 2.0 Client API with WebLogic Server 12.1.3



Please note: this blog discusses WebLogic Server 12.1.3
which has not yet been released.

As part of the JAX-RS 2.0 support we are providing with WebLogic Server 12.1.3, one really useful new feature is the new Client API it provides, enabling applications to easily interact with REST services to consume and publish information.

By way of a simple example, I'll build out an application that uses the freegeoip.net REST service to lookup the physical location of a specified IP address or domain name and deploy it to WebLogic Server 12.1.3.

The first step to perform is to make a call to the freegeoip.net REST API and examine the JSON payload that is returned.
$ curl http://freegeoip.net/json/buttso.blogspot.com

{"ip":"173.194.115.75","country_code":"US","country_name":"United States","region_code":"CA","region_name":"California","city":"Mountain View","zipcode":"94043","latitude":37.4192,"longitude":-122.0574,"metro_code":"807","area_code":"650"}

The next step is to build a Java class to represent the JSON payload that is returned. In this case, it's quite simple because the JSON payload that is returned doesn't contain any relationships or complex data structures.
/**
 *
 * @author sbutton
 * {"ip":"173.194.115.75","country_code":"US","country_name":"United States","region_code":"CA","region_name":"California","city":"Mountain View","zipcode":"94043","latitude":37.4192,"longitude":-122.0574,"metro_code":"807","area_code":"650"}            
 */
public class GeoIp implements Serializable {

    private String ipAddress;
    private String countryName;
    private String regionName;
    private String city;
    private String zipCode;
    private String latitude;
    private String longitude;

    public String getIpAddress() {
        return ipAddress;
    }

    public void setIpAddress(String ipAddress) {
        this.ipAddress = ipAddress;
    }    

    ...

}
With the GeoIP class defined, the next step is to consider how to convert the JSON payload into an instance of the GeoIP class. I'll show two ways this can be done.

The first way to do it is to create a class that reads the result of the REST request, parses the JSON payload and constructs a representative instance of the GeoIP class. Within the JAX-RS API, there is an interface MessageBodyReader that can be implemented to convert a Stream into a Java type.

http://docs.oracle.com/javaee/6/api/javax/ws/rs/ext/MessageBodyReader.html

Implementing this interface gives you the readFrom(Class type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap httpHeaders, InputStream entityStream) method which supplies an InputStream containing the response to read. The method then parses out the JSON payload and constructs a responding GeoIP instance from it.

Parsing the JSON payload is straightforward with WebLogic Server 12.1.3 since we've included the (JSR-353) Java API for JSON Processing implementation which provides an API for reading and creating JSON objects.
package oracle.demo.wls.jaxrs.client.geoip;

import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import javax.json.Json;
import javax.json.stream.JsonParser;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.MessageBodyReader;
import javax.ws.rs.ext.Provider;

@Provider
@Produces(MediaType.APPLICATION_JSON)
public class GeoIpReader implements MessageBodyReader {

    @Override
    public boolean isReadable(Class type, Type genericType, Annotation[] annotations, MediaType mediaType) {
        return GeoIp.class.isAssignableFrom(type) ;
    }

    @Override
    public GeoIp readFrom(Class type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
        GeoIp g = new GeoIp();
        JsonParser parser = Json.createParser(entityStream);
        while (parser.hasNext()) {
            switch (parser.next()) {
                case KEY_NAME:
                    String key = parser.getString();
                    parser.next();
                    switch (key) {
                        case "ip":
                            g.setIpAddress(parser.getString());
                            break;
                        case "country_name":
                            g.setCountryName(parser.getString());
                            break;
                        case "latitude":
                            g.setLatitude(parser.getString());
                            break;
                        case "longitude":
                            g.setLongitude(parser.getString());
                            break;
                        case "region_name":
                            g.setRegionName(parser.getString());
                            break;
                        case "city":
                            g.setCity(parser.getString());
                            break;
                        case "zipcode":
                            g.setZipCode(parser.getString());
                            break;
                        default:
                            break;
                    }
                    break;
                default:
                    break;
            }
        }
        return g;
    }
}

Once this class is built, it can be registered with the Client so that it can be called when necessary to convert a payload of MessageType.APPLICATION_JSON type into an instance of the GeoIP object, here done in an @PostConstruct method on a JSF Bean
    @PostConstruct
    public void init() {
        client = ClientBuilder.newClient();
        client.register(GeoIpReader.class);
    }


The alternative way to do thi is to use the EcliseLink MOXY JAXB implementation that is provided with WebLogic Server, which can automatically marhsall and unmarshall JSON payloads to and from Java objects. Helpfully, the JAX-RS 2.0 shared-library that WebLogic Server 12.1.3 contains the jersey-media-moxy extension that enables the EclipseLInk MOXY implementation to be simply registered and used by applications when conversion is needed.

To use the JAXB/MOXY approach, the GeoIPReader class can be thrown away. No manual parsing of the payload is required. Instead, the base GeoIP class is annotated with JAXB annotations to denote it as being JAXB enabled and to provide some assistance in the mapping of the class properties to the payload property names.
package oracle.demo.wls.jaxrs.client.geoip;

import java.io.Serializable;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;

/**
 *
 * @author sbutton
 * {"ip":"173.194.115.75","country_code":"US","country_name":"United States","region_code":"CA","region_name":"California","city":"Mountain View","zipcode":"94043","latitude":37.4192,"longitude":-122.0574,"metro_code":"807","area_code":"650"}            
 */

@XmlRootElement
public class GeoIp implements Serializable {
    
    @XmlAttribute(name = "ip")
    private String ipAddress;
    @XmlAttribute(name = "country_name")
    private String countryName;
    @XmlAttribute(name = "region_name")
    private String regionName;
    @XmlAttribute(name = "city")
    private String city;
    @XmlAttribute(name = "zipcode")
    private String zipCode;
    @XmlAttribute(name = "latitude")
    private String latitude;
    @XmlAttribute(name = "longitude")
    private String longitude;

    ...
   
}


With the JAXB annotations placed on the GeoIP class to enable it to be automatically marshalled/unmarshalled from JSON, the last step is to register the EclipseLink MOXY implementation with the Client. This is done with the assistance of a small utility method, as shown in the Jersey User Guide Media chapter.
    public static ContextResolver createMoxyJsonResolver() {
        final MoxyJsonConfig moxyJsonConfig = new MoxyJsonConfig();
        moxyJsonConfig.setFormattedOutput(true);

        Map namespacePrefixMapper = new HashMap(1);
        namespacePrefixMapper.put("http://www.w3.org/2001/XMLSchema-instance", "xsi");
        moxyJsonConfig.setNamespacePrefixMapper(namespacePrefixMapper).setNamespaceSeparator(':');

        return moxyJsonConfig.resolver();
    }
This method is then used to register the relevant ContextResolver with the Client to use to handle JSON_conversions, instead of the GeoIPReader class that was used before.<
    @PostConstruct
    public void init() {
        client = ClientBuilder.newClient();
        client.register(createMoxyJsonResolver());
        //client.register(GeoIpReader.class);
    }

With the JSON payload to GeoIP conversion now covered, the JAX-RS Client API can be used to make the call to the freegeoip REST service and process the response.

To make a client call, two classes are used: javax.ws.rs.client.Client and javax.ws.rs.client.WebTarget .

The Jersey User Guide provides a good description of theses two classes and their relationship:

The JAX-RS Client API is a designed to allow fluent programming model. This means, a construction of a Client instance, from which a WebTarget is created, from which a request Invocation is built and invoked can be chained in a single "flow" of invocations ... Once you have a Client instance you can create a WebTarget from it ... A resource in the JAX-RS client API is an instance of the Java class WebTarget and encapsulates an URI. The fixed set of HTTP methods can be invoked based on the WebTarget. The [base] representations are Java types, instances of which, may contain links that new instances of WebTarget may be created from.

In this example application, the Client is opened in an @PostConstruct method and closed in a @PreDestroy method, with the WebTarget being created and its GET method called when the lookup is executed by the user.
@Named
@RequestScoped
public class GeoIpBackingBean {

    private WebTarget target = null;
    private Client client = null;

    ...

    @PostConstruct
    public void init() {
        client = ClientBuilder.newClient();
        //client.register(createMoxyJsonResolver());
        client.register(GeoIpReader.class);
    }

    @PreDestroy
    public void byebye() {
        client.close();
    }

    public void lookupAddress() {
        try {
            target = client.target(String.format(rest_base_url, addressToLookup));
            geoIp = target.request().get(GeoIp.class);
        } catch (Exception e) {
            e.printStackTrace();
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("Error executing REST call: " + e.getMessage()));
        }
    }
 
    ...
}  


Bringing it all together as a JSF based application results in a JSF Bean being created that allows the IP address to be entered and a method that invokes the JAX-RS Client API to call out to the freegeoip.net REST service to retrieve the JSON payload containing the location information. A simple JSF facelet page is used to support the entering of the IP address and the display of the relevant data from the GeoIP object.


    <h:form>
        <h:panelGrid columns="2" style="vertical-align: top;">
        <h:outputLabel value="Address"/>
        <h:inputText value="${geoIpBackingBean.addressToLookup}"/>
        <h:outputLabel value=""/>
        <h:commandButton action="${geoIpBackingBean.lookupAddress()}" value="Lookup" style="margin: 5px;"/>
        </h:panelGrid>
    </h:form>


    <h:panelGrid columns="2">
        <h:outputText value="IP:"/>
        <h:outputText value="${geoIpBackingBean.geoIp.ipAddress}"/>
        <h:outputText value="Country Code:"/>
        <h:outputText value="${geoIpBackingBean.geoIp.countryName}"/>
        <h:outputText value="State:"/>
        <h:outputText value="${geoIpBackingBean.geoIp.regionName}"/>
        <h:outputText value="City"/>
        <h:outputText value="${geoIpBackingBean.geoIp.city}"/>
        <h:outputText value="Zipcode:"/>
        <h:outputText value="${geoIpBackingBean.geoIp.zipCode}"/>
        <h:outputText value="Coords:"/>
        <c:if test="${geoIpBackingBean.geoIp.ipAddress != null}">
            <h:outputText value="${geoIpBackingBean.geoIp.latitude},${geoIpBackingBean.geoIp.longitude}"/>
        </c:if>
      </h:panelGrid>

The last step to perform is to add a weblogic.xml deployment descriptor with a library-ref to the [jsf,2.0] shared-library, which must be deployed as I described earlier in Using JAX-RS 2.0 with WebLogic Server 12.1.3.

The application is now ready to to deploy and run.

21 March 2014

Using JAX-RS 2.0 in WebLogic Server 12.1.3



Please note: this blog discusses WebLogic Server 12.1.3
which has not yet been released.

We've been working on adding some Java API updates to the coming WebLogic Server 12.1.3 release.

One that I think is going to be very popular is JAX-RS 2.0, which includes some useful new capabilities around filtering, interception and a really useful new client API.

 In the WebLogic Server 12.1.3 release we are providing this in the form of an optional shared-library that contains: the JAX-RS 2.0 API, a Jersey 2.x implementation, some common Jersey extensions such as media support and a utility that works to expose the JAX-RS 2.0 API to referencing applications.

To make use of it, developers first deploy the jax-rs-2.0.war shared-library from the $ORACLE_HOME/wlserver/common/deployable-libraries directory to the server (or cluster) then use it in an application by referencing it as a library using a weblogic deployment descriptor.

Using the library-name and specification-version attributes from the JSF library, an example of a weblogic.xml to use it would be (lines:8-11):

<?xml version="1.0" encoding="UTF-8"?>  
<weblogic-web-app>  
    <jsp-descriptor>  
        <keepgenerated>true</keepgenerated>  
        <debug>true</debug>  
    </jsp-descriptor>  
    <context-root>/service-centre</context-root>  
    <library-ref>  
        <library-name>jax-rs</library-name>  
        <specification-version>2.0</specification-version>  
    </library-ref>  
</weblogic-web-app>  

13 September 2013

WebLogic Server - Using OSGi Bundles with Java EE Applications

The WLS 12c (12.1.2) release includes a new feature that enables OSGi bundles to be installed and used by deployed applications.

The full documentation is here:

http://docs.oracle.com/middleware/1212/wls/WLPRG/osgi.htm

In short this feature enables WLS to create an OSGi framework (Apache Felix 4.03) in which OSGi Bundles are installed and accessed by applications.

Applications provide an XML reference element to define the named OSGi framework and Bundle of interest, which is then  published into the JNDI tree from where it can be referenced and used.

An OSGi Bundle can be included as part of the application archive being deployed or it can be provided as part of the server library set.

To provide a simple example, the Apache Felix tutorial Dictionary Service was first implemented and packaged as an OSGi Bundle.

The Bundle manifest looks as follows:
  Manifest-Version: 1.0
  Bnd-LastModified: 1378960044511
  Build-Jdk: 1.7.0_17
  Built-By: sbutton
  Bundle-Activator: tutorial.example2.Activator
  Bundle-ManifestVersion: 2
  Bundle-Name: DictionaryService OSGi Bundle
  Bundle-SymbolicName: tutorial.example2.service.DictionaryService
  Bundle-Version: 1.0.0.SNAPSHOT
  Created-By: Apache Maven Bundle Plugin
  Export-Package: tutorial.example2.service;version="1.0.0.SNAPSHOT"
  Import-Package: org.osgi.framework;version="[1.6,2)"
  Tool: Bnd-1.50.0

The Bundle archive contains only a few classes, the DictionaryService interface and an Activator implementation which provides an inner class implementation of the DictionaryService that is registered when the Bundle is activated.


 
A small web application was then developed to make use of the DictionaryService Bundle using a Servlet.

The Servlet performs the following tasks:
  • Injects the Bundle reference from JNDI using the @Resource annotation
  • Looks up the ServiceReference for the DictionaryService.class to be used 
  • Obtains an instance of the DictionaryService from the ServiceReference
  • Makes calls on the DictionaryService to check whether a word is in the known word list

Inject Bundle reference from its JNDI location:
@WebServlet(name = "TestServlet", urlPatterns = {"/TestServlet", "/test", "/osgi"})
public class TestServlet extends HttpServlet {

    @Resource(lookup = "java:app/osgi/Bundle")
    Bundle bundle;
    ...
}

The Bundle provides access to the registered Services, in this case the DictionaryService:
  if (bundle != null) {              
                             
    BundleContext bc = bundle.getBundleContext();
           
    ServiceReference dictionaryServiceRef = 
      bc.getServiceReference(DictionaryService.class);
    DictionaryService dictionaryService = 
      (DictionaryService) bc.getService(dictionaryServiceRef);

    ...

  }
 
The methods on the DictionaryService can then be used:

  out.printf("<div>wordlist: %s </div>", 
             Arrays.toString(dictionaryService.wordlist()));

  out.printf("<div>checkWord(\"%s\"): %s</div>", 
             wordToCheck, dictionaryService.checkWord(wordToCheck));


The Bundle then needs to be defined for the web application to use, which is done using the weblogic deployment descriptor.  In this example, the weblogic.xml file contains the following entry:
  <osgi-framework-reference>
    <name>test</name>
    <application-bundle-symbolic-name>
      tutorial.example2.service.DictionaryService
    </application-bundle-symbolic-name>
  </osgi-framework-reference>

The bundle-symbolic-name is used to specify the bundle to be used.

The name element specifies the name of the OSGi framework that has been configured.  With WebLogic Server 12c (12.1.2) there are several ways to define and configure OSGi frameworks such as the Admin Console, WLST, programmatically with Java or by directly editing the domain config.xml file.

With this small web application, the DictionaryService Bundle was deployed as part of the WAR file itself.  This is performed by placing the JAR file in the WEB-INF/osgi-lib directory, whereupon WLS will detect it and install it.  The DictionaryService Bundle could also be installed by copying it into the $ORACLE_HOME/wlserver/server/osgi-lib directory.

With the WAR file packaged and deployed to WLS,  the console logs show the DictionaryService Bundle being Activated, where System.out.println() calls were inserted into the start and stop Activator methods to view them being called:

*** START Bundle org.apache.felix.framework.BundleContextImpl@21052189
tutorial.example2.service.DictionaryService ***
Finally the TestServlet is accessed, demonstrating the DictionaryService being accessed and used:



29 August 2013

23 August 2013

WebLogic Server 12.1.2 - Zip File Updates

I love the zip file distribution.  It's the flavour of WLS I mostly use.  Unzip, configure, go.  Delete it to remove it, start all over again.  Install it from a Maven goal.  Easy.
Small point to note is that the zip file distribution has been pulled down from OTN for the last couple of days (20 Aug 2013) while we fix a minor problem relating to the launching of the Configuration Wizard in this specific distribution.  Should be back up today or tomorrow (23 Aug 2013).
With the release of WLS 12.1.2 now available and getting some decent download traction, I thought I'd make a few comments about the zip file distribution as it has some minor changes in this version:
  1. It now contains an outer level directory wls12120, in which the zip file contents are stored.  Previously the contents were stored in an outer level directory.
  2. The configure.sh|cmd script now has an option to run in "silent" mode, where the progress of the configuration process is not displayed to the console.

  3. At the end of the configuration process you are now asked if you'd like to create a domain.  If the answer is yes, the relevant details are asked for and a new domain created and started.  This enables you to configure and start up a server from the one simple script.    
 The process of using the zip file distribution is shown below.

[sbutton@mbp] $ unzip ~/Downloads/WLS/1212/PROD/wls1212_dev.zip

Archive:  /Users/sbutton/Downloads/WLS/1212/PROD/wls1212_dev.zip
   creating: wls12120/
   creating: wls12120/coherence/
   creating: wls12120/coherence/bin/
   creating: wls12120/coherence/lib/
   creating: wls12120/coherence/lib/security/
   creating: wls12120/coherence/plugins/
   creating: wls12120/coherence/plugins/maven/
   ...

   ...
  inflating: wls12120/wlserver/common/bin/clonedunpack.cmd 
  inflating: wls12120/wlserver/common/bin/commEnv.cmd 
  inflating: wls12120/wlserver/common/bin/config.cmd 
  inflating: wls12120/wlserver/common/bin/config_builder.cmd 
  inflating: wls12120/wlserver/common/bin/pack.cmd 
  inflating: wls12120/wlserver/common/bin/prepareCustomProvider.cmd 
  inflating: wls12120/wlserver/common/bin/qs_config.cmd 
  inflating: wls12120/wlserver/common/bin/reconfig.cmd 
  inflating: wls12120/wlserver/common/bin/unpack.cmd 
  inflating: wls12120/wlserver/common/bin/wlsifconfig.cmd 
  inflating: wls12120/wlserver/common/bin/wlst.cmd 
  inflating: wls12120/wlserver/common/deployable-libraries/active-cache-1.0.jar.pack 
  inflating: wls12120/wlserver/common/deployable-libraries/jsf-1.2.war 
  inflating: wls12120/wlserver/common/deployable-libraries/jsf-2.0.war 
  ...

  ...
  inflating: wls12120/wlserver/common/bin/wlst.sh 
  inflating: wls12120/wlserver/server/bin/setWLSEnv.sh 
  inflating: wls12120/wlserver/server/bin/startNodeManager.sh 
  inflating: wls12120/wlserver/server/lib/unix/nodemanager.sh 
 

[sbutton@mbp]  $ cd wls12120

[sbutton@mbp]  $ ./configure.sh

**************************************************
WebLogic Server 12g (12.1.2.0) Zip Configuration

MW_HOME:   /tmp/wls12120
JAVA_HOME: /Library/Java/JavaVirtualMachines/jdk1.7.0_17.jdk/Contents/Home

Note:      MW_HOME not supplied, default used
**************************************************
...

...
...
...Unpacking done                                           0 to go

Your environment has been set.
Configuring WLS...

BUILD SUCCESSFUL
Total time: 1 second

Do you want to configure a new domain?  [y/n]? Y


<21/08/2013 12:05:41 PM CST> <Info> <Security> <BEA-090905> <Disabling the CryptoJ JCE Provider self-integrity check for better startup performance. To enable this check, specify -Dweblogic.security.allowCryptoJDefaultJCEVerification=true.>
<21/08/2013 12:05:41 PM CST> <Info> <Security> <BEA-090906> <Changing the default Random Number Generator in RSA CryptoJ from ECDRBG to FIPS186PRNG. To disable this change, specify -Dweblogic.security.allowCryptoJDefaultPRNG=true.>
<21/08/2013 12:05:42 PM CST> <Info> <WebLogicServer> <BEA-000377> <Starting WebLogic Server with Java HotSpot(TM) 64-Bit Server VM Version 23.7-b01 from Oracle Corporation.>
<21/08/2013 12:05:42 PM CST> <Info> <Management> <BEA-140013> </private/tmp/wls12120/user_projects/domains/mydomain/config not found>
<21/08/2013 12:05:42 PM CST> <Info> <Security> <BEA-090065> <Getting boot identity from user.>
 

Enter username to boot WebLogic server:weblogic   
Enter password to boot WebLogic server: ********

For confirmation, please re-enter password required to boot WebLogic server: ******** 
<21/08/2013 12:05:49 PM CST> <Info> <Management> <BEA-141254> <Generating new domain directory in /private/tmp/wls12120/user_projects/domains/mydomain.>
<21/08/2013 12:05:57 PM CST> <Info> <Management> <BEA-141255> <Domain generation completed in 8,737 milliseconds.>
<21/08/2013 12:05:57 PM CST> <Info> <Management> <BEA-141107> <Version: WebLogic Server 12.1.2.0.0  Fri Jun 7 15:16:15 PDT 2013 1530982 WLS_12.1.2.0.0_GENERIC_130607.1100>
<21/08/2013 12:05:59 PM CST> <Notice> <WebLogicServer> <BEA-000365> <Server state changed to STARTING.>
<21/08/2013 12:05:59 PM CST> <Info> <WorkManager> <BEA-002900> <Initializing self-tuning thread pool.>
<Aug 21, 2013 12:05:59 PM CST> <Notice> <Log Management> <BEA-170019> <The server log file /private/tmp/wls12120/user_projects/domains/mydomain/servers/myserver/logs/myserver.log is opened. All server side log events will be written to this file.>
<Aug 21, 2013 12:06:02 PM CST> <Notice> <Security> <BEA-090082> <Security initializing using security realm myrealm.>
<Aug 21, 2013 12:06:02 PM CST> <Warning> <Store> <BEA-280109> <Unable to load the native wlfileio library for the persistent file store "_WLS_myserver". The store will use buffered I/O. The store is still operating in a transactionally safe synchronous mode. See store open log messages for the requested and final write policies.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <WebLogicServer> <BEA-000365> <Server state changed to STANDBY.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <WebLogicServer> <BEA-000365> <Server state changed to STARTING.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <Log Management> <BEA-170027> <The server has successfully established a connection with the Domain level Diagnostic Service.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <WebLogicServer> <BEA-000365> <Server state changed to ADMIN.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <WebLogicServer> <BEA-000365> <Server state changed to RESUMING.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <Server> <BEA-002613> <Channel "Default[1]" is now listening on fdfa:13b7:e006:7177:196:ad1b:8c13:ef38:7001 for protocols iiop, t3, ldap, snmp, http.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <Server> <BEA-002613> <Channel "Default" is now listening on 10.187.112.164:7001 for protocols iiop, t3, ldap, snmp, http.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <Server> <BEA-002613> <Channel "Default[3]" is now listening on 127.0.0.1:7001 for protocols iiop, t3, ldap, snmp, http.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <Server> <BEA-002613> <Channel "Default[2]" is now listening on 0:0:0:0:0:0:0:1:7001 for protocols iiop, t3, ldap, snmp, http.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <WebLogicServer> <BEA-000331> <Started the WebLogic Server Administration Server "myserver" for domain "mydomain" running in development mode.>
<Aug 21, 2013 12:06:05 PM CST> <Warning> <Server> <BEA-002611> <The hostname "localhost", maps to multiple IP addresses: 127.0.0.1, 0:0:0:0:0:0:0:1, fe80:0:0:0:0:0:0:1%1.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <WebLogicServer> <BEA-000365> <Server state changed to RUNNING.>
<Aug 21, 2013 12:06:05 PM CST> <Notice> <WebLogicServer> <BEA-000360> <The server started in RUNNING mode.>



 At this point there is now a new domain called "mydomain" running and available on the default WLS port of 7001 protected with the credentials specified during the configuration process.

This process can be used immediately, or it can be stopped using any of the standard process control methods and restarted using the scripts in the generated domain directory, per the following:

Generating new domain directory in /private/tmp/wls12120/user_projects/domains/mydomain

As a final point, the zip file can be installed into a Maven repository using whatever coordinates you wish, then referenced and used with the weblogic-maven-plugin install goal to perform a local installation operation of the server.

Combined with the subsequent execution of the weblogic-maven-plugin create-domain and start-server goals, a fully operational server can be created from Maven in a short matter of time, ready and waiting to accept application deployments.







20 August 2013

WLS 10.3.6 Transaction Logs in Database

Was talking to one of our local partners yesterday who's in the middle of an infrastructure build for FMW using a 3rd party cloud provider.  He mentioned he was looking at how to handle the JTA transaction logs for their HA requirements without being able to rely on shared storage being available.

I mentioned that we'd added support for storing the XA logs in the database in WLS 10.3.6, which should make both his initial setup, replication and recovery processes more straight forward.
 
http://docs.oracle.com/cd/E23943_01/web.1111/e13852/toc.htm#BGGHGHBC

JTA

You can configure a JDBC TLOG store to persist transaction logs to a database, which allows you to leverage replication and HA characteristics of the underlying database, simplify disaster recovery, and improve Transaction Recovery service migration. See "Using a JDBC TLog Store" in Configuring Server Environments for Oracle WebLogic Server.


WebLogic Server 12c (12.1.2) Documentation

The WebLogic Server documentation set has undergone a nice facelift in the 12c (12.1.2) release. 

http://fmwdocs.us.oracle.com/vol/doclibs/middleware/production/E26099_01/wls/index.html

I find the breakdown sections generally quite useful to quickly locate the information I'm looking for, but I still regularly go directly to a specific book as a reference.

The entire book set is available here:

http://fmwdocs.us.oracle.com/vol/doclibs/middleware/production/E26099_01/wls/docs.htm

I also think the provision of the new mobi and epub formats is incredibly useful, allowing you to pull down a set of books onto a mobile device.   I flew to Melbourne yesterday and was able to read over a set of docs on the plane that I'd pulled onto my iPad before I left.

I've been wondering if it'd be possible to provide some sort of library/multi-book selection option to allow multiple book selections to be made at once and have them downloaded as a library that can be pushed to a mobile device?  I've not looked into it, but I think it'd be a nice usability feature.  Does iBooks have any APIs that could support that?  Will need to look int it at some point.