Tuesday Jul 08, 2008

Ladies and gentlemen, this is Java EE 5!

My Google Alerts pointed me to an old song on Java EE 5 by Roumen.

Enjoy a blogger's geekiness about technology and the lyrics are:

Ladies and gentlemen, this is Java EE 5!

One, two, three, four, five
There's a technology I use day and night
For my application with a web frontend
They told me to use .Net
But I really don´t wanna

So many bugs I fixed last week.
My code is neat and talk is a cheap
I like Glassfish, JSF, persistence API
And as I continue you know they´re gettin´ sweeter

So what can I do I really beg you my Lord
To me codin' it´s just like a sport
All the bad code from the past, let me dump it
Please set in the trumpet

A little bit of injection in my life
A little bit of persistence by my side
A little bit of NetBeans is all I need
A little bit of EJB's what I see
A little bit of standards in the sun
A little bit of XML all night long
A little bit web services here I am
A little bit of code makes me real man

This is Java EE 5!

Jump up and down and move your code around
Shake your head to the sound bury bad code under ground
Move one step left and one step right
One to the front and one to the side
Refactor it once and refactor it twice
If it looks like this you're doin´ it right

A little bit of injection in my life
A little bit of persistence by my side
A little bit of NetBeans is all I need
A little bit of EJB's is what I see
A little bit of standards in the sun
A little bit of XML all night long
A little bit web services here I am
A little bit of code makes me real man

This is Java EE 5!

This is outright hilarious! Roman has moved onto a different role within Sun recently and is missed. But this song truly conveys part of what I do on daily basis. I guess I should record one for GlassFish ;-)

Technorati: javaee5 song glassfish

Sunday Apr 13, 2008

Rails and Java EE integration - Native Rails on GlassFish v3


The last part of this tri-series blog (Part 1, Part 2) will show how a Rails application can be deployed on GlassFish - without the need of Goldspike, Warbler or any other gem or plugin. Yes, that's a native Rails app deployment on GlassFish v3.

GlassFish v3 is next version of GlassFish v2 and the focus is modularization, enablement of non-Java EE containers and modularity - download b09.

Rails powered by GlassFish provides all the details on why GlassFish provides an industry-grade and functionally-rich Application Server.

Now detailed steps:
  1. Using JRuby 1.1 (installed with Rails), create a Rails app "railsee3" as:

    ~/testbed/jruby-1.1/samples/rails >../../bin/jruby -S rails railsee3
          create 
          create  app/controllers
          create  app/helpers
          create  app/models
          . . .
          create  log/production.log
          create  log/development.log
          create  log/test.log
  2. Add Servlet descriptors
    1. Create a new directory "WEB-INF", and a new file "web.xml" in that directory using the following contents:

      <!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd">
      <web-app>
              <servlet>
                      <servlet-name>HelloServlet</servlet-name>
                      <servlet-class>server.HelloServlet</servlet-class>
              </servlet>
              <servlet-mapping>
                      <servlet-name>HelloServlet</servlet-name>
                      <url-pattern>/hello</url-pattern>
              </servlet-mapping>
      </web-app>
    2. Create a new file "sun-web.xml" in "WEB-INF" using the following contents:

      <?xml version="1.0" encoding="UTF-8"?>
      <!DOCTYPE sun-web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Application Server 9.0 Servlet 2.5//EN" "http://www.sun.com/software
      /appserver/dtds/sun-web-app_2_5-0.dtd">
      <sun-web-app error-url="">
        <context-root>/servlet</context-root>
        <class-loader delegate="true"/>
      </sun-web-app>
    3. Create a new directory "WEB-INF/lib".
  3. Create and Copy Servlet
    1. Create a Java library with Servlet code as explained in bullet #5 here.
    2. Copy "HelloServlet.jar" from "dist" directory of NetBeans project to "WEB-INF/lib" directory.
  4. Configure JRuby-on-Rails in GlassFish - Edit "config/asenv.conf" in GlassFish directory and specify JRUBY_HOME as the last line:

    JRUBY_HOME="/Users/arungupta/testbed/jruby-1.1"

  5. Deploy the Rails application as:

  6. ~/testbed/jruby-1.1/samples/rails >~/testbed/glassfish/v3/p2b9/glassfish/bin/asadmin deploy --force=true railsee3
    railsee3 deployed successfully
    Command deploy executed successfully.
  7. The bundled Servlet is now accessible at "http://localhost:8080/servlet/hello". The default browser output looks like:



    And passing a parameter to the URL as "http://localhost:8080/railsee3/hello?name=Arun" shows the output as:


With this, your Java EE Servlet is now bundled with your Rails application deployed on GlassFish v3.

Now, lets add Controller and View to Rails application and invoke this servlet from there to show complete integration with Rails.
  1. Create a new Controller and View as

    ~/testbed/jruby-1.1/samples/rails/railsee3 >../../../bin/jruby script/generate controller home index
    JRuby limited openssl loaded. gem install jruby-openssl for full support.
    http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
          exists  app/controllers/
          exists  app/helpers/
          create  app/views/home
          exists  test/functional/
          create  app/controllers/home_controller.rb
          create  test/functional/home_controller_test.rb
          create  app/helpers/home_helper.rb
          create  app/views/home/index.html.erb
  2. Change the generated controller in "app/controllers/home_controller.rb" to:

    class HomeController < ApplicationController

    include Java

      def index
            url = java.net.URL.new("http://localhost:8080/servlet/hello");
            conn = url.open_connection;
            reader = java.io.BufferedReader.new(java.io.InputStreamReader.new(conn.get_input_stream));
            @servlet_output = "";
            input_line = reader.read_line;
            while input_line != nil
                    @servlet_output << input_line;
                    input_line = reader.read_line;
            end
            reader.close;
      end
    end
  3. Change the generated view in "app/views/home/index.rhtml.erb" to:

    <h1>Home#index</h1>
    <p>Find me in app/views/home/index.html.erb</p>

    <%= @servlet_output %>
  4. Re-deploy the Rails application as shown in bullet # 5 above and "http://localhost:8080/railsee3/home/index" shows the output as shown:

So this blog explained how a Rails application can be deployed on GlassFish v3 without the need of any gems like Warbler or plugin like Goldspike - total native deployment!

In summary, the tri-part blog showed the deployment models for a Rails application on GlassFish. Each model showed how a Java EE 5 Servlet can be co-bundled with Rails application and invoked from Rails view:
Technorati: rubyonrails netbeans glassfish v3 javaee5 servlets jruby ruby warbler

Sunday Apr 06, 2008

Rails and Java EE integration - Warbler instead of Goldspike


Part 1 of this tri-series blog explained how a Java EE Servlet and Rails application can be packaged together as WAR file using Goldspike plugin and deployed on GlassFish v2 UR1. There are few issues with Goldspike as explained here. A better and recommended option is to use Warbler for packaging which provides a minimal, flexible and Ruby-like way to create WAR. Warbler really cleans up the packagingof WAR, for example excluding .svn directories, tests and migrations - really nice. For now, it uses RailsServlet for dispatching but even that is pluggable.

This blog, Part 2, will explain how to generate a WAR file using Warbler. Rails powered by GlassFish provides all the details on why GlassFish provides an industry-grade and functionally-rich Application Server.

Now detailed steps:
  1. In an existing JRuby 1.1 installation (enabled with Rails), install Warbler gem:

    ~/testbed/jruby-1.1 >bin/jruby -S gem install warbler
    JRuby limited openssl loaded. gem install jruby-openssl for full support.
    http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
    Updating metadata for 35 gems from http://gems.rubyforge.org
    ...................................
    complete
    Successfully installed warbler-0.9.4
    1 gem installed
    Installing ri documentation for warbler-0.9.4...
    Installing RDoc documentation for warbler-0.9.4...
  2. Create a Rails app "railsee2" as:

    ~/testbed/jruby-1.1/samples/rails >../../bin/jruby -S rails railsee2
          create 
          create  app/controllers
          create  app/helpers
          create  app/models
          . . .
          create  log/production.log
          create  log/development.log
          create  log/test.log

    In order to keep it simple, this application will not be using any database so uncomment the following line from "config/environment.rb"(by removing "#" from beginning of the line):

    config.frameworks -= [ :active_record, :active_resource, :action_mailer ]
  3. Create a new file "web.xml" in "config" directory and use the following contents:

    <!DOCTYPE web-app PUBLIC
      "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
      "http://java.sun.com/dtd/web-app_2_3.dtd">
    <web-app>
            <servlet>
                    <servlet-name>HelloServlet</servlet-name>
                    <servlet-class>server.HelloServlet</servlet-class>
            </servlet>
            <servlet-mapping>
                    <servlet-name>HelloServlet</servlet-name>
                    <url-pattern>/hello</url-pattern>
            </servlet-mapping>
    </web-app>

    This "web.xml" is used by Warbler when packaging the WAR file.
  4. Create and Copy Servlet
    1. Create a Java library with Servlet code as explained in bullet #4 here.
    2. Copy "HelloServlet.jar" from "dist" directory of NetBeans project to "lib" directory of Rails application.
  5. Create and deploy the WAR
    1. Create a WAR file as:

      ~/testbed/jruby-1.1/samples/rails/railsee2 >~/testbed/jruby-1.1/bin/jruby -S warble
      JRuby limited openssl loaded. gem install jruby-openssl for full support.
      http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
      jar cf railsee2.war -C tmp/war .
    2. Deploy the WAR to GlassFish v2 UR1 as:

      ~/testbed/jruby-1.1/samples/rails/railsee2 >~/testbed/glassfish/v2ur1/glassfish/bin/asadmin deploy railsee2.war
      Command deploy executed successfully.
  6. The bundled Servlet is now accessible at "http://localhost:8080/railsee2/hello". The default browser output looks like:



    And passing a parameter to the URL as "http://localhost:8080/railsee2/hello?name=Arun" shows the output as:


With this, your Java EE Servlet is now bundled with your Rails application deployed on GlassFish v2 UR1.

Now, lets add Controller and View to Rails application and invoke this servlet from there to show complete integration with Rails.
  1. Create a new Controller and View as

    ~/testbed/jruby-1.1/samples/rails/railsee2 >../../../bin/jruby script/generate controller home index
    JRuby limited openssl loaded. gem install jruby-openssl for full support.
    http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
          exists  app/controllers/
          exists  app/helpers/
          create  app/views/home
          exists  test/functional/
          create  app/controllers/home_controller.rb
          create  test/functional/home_controller_test.rb
          create  app/helpers/home_helper.rb
          create  app/views/home/index.html.erb
  2. Change the generated controller in "app/controllers/home_controller.rb" to:

    class HomeController < ApplicationController

    include Java

      def index
            url = java.net.URL.new("http://localhost:8080/railsee2/hello");
            conn = url.open_connection;
            reader = java.io.BufferedReader.new(java.io.InputStreamReader.new(conn.get_input_stream));
            @servlet_output = "";
            input_line = reader.read_line;
            while input_line != nil
                    @servlet_output << input_line;
                    input_line = reader.read_line;
            end
            reader.close;
      end
    end
  3. Change the generated view in "app/views/home/index.rhtml.erb" to:

    <h1>Home#index</h1>
    <p>Find me in app/views/home/index.html.erb</p>

    <%= @servlet_output %>
  4. Re-create the WAR as describd in bullet # 5 above. And now "http://localhost:8080/railsee2/home/index" shows the output as shown:


This blog explained how a Java EE 5 Servlet and Rails application can be packaged Warbler and deployed on GlassFish. Warbler docs provide detail about usage, configuration, web.xml and other details.

The next blog in this tri-series blog will explain how such an application can be deployed on GlassFish v3. And the cool thing there is that you don't need Goldspike, Warbler or any other additional plugins - total native deployment, stay tuned!


Technorati: rubyonrails netbeans glassfish v3 javaee5 servlets jruby ruby warbler

Thursday Apr 03, 2008

Rails and Java EE integration - Servlet co-bundled and invoked from Rails

One of the several advantages of deploying Rails applications on GlassFish is - co-hosting Rails and Java EE applications in the same container. The screencast #web9 shows how Rails applications can be easily deployed on GlassFish.

This blog takes the JRuby-on-Rails (jRoR) and Java EE integration to the next level. It show how a Java EE Servlet can be co-bundled within a jRoR application. And then it shows how such a servlet can be easily invoked from a Rails view. It uses WAR-based mode for deploying jRoR applications on GlassFish.

Here are the detailed steps:
  1. In an existing JRuby 1.1 RC3 installation (enabled with Rails), install the required gems:

    ~/testbed/jruby-1.1RC3 >bin/jruby -S gem install activerecord-jdbc-adapter   
    JRuby limited openssl loaded. gem install jruby-openssl for full support.
    http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
    Successfully installed activerecord-jdbc-adapter-0.8
    1 gem installed
    Installing ri documentation for activerecord-jdbc-adapter-0.8...
    Installing RDoc documentation for activerecord-jdbc-adapter-0.8...
  2. Create a Rails app as:

    ~/testbed/jruby-1.1RC3/samples/rails >../../bin/jruby -S rails railsee1
          create 
          create  app/controllers
          create  app/helpers
          create  app/models
          create  app/views/layouts
          create  config/environments
          create  config/initializers
          create  db
          create  doc
          create  lib
          create  lib/tasks
          create  log
          create  public/images
          create  public/javascripts
          create  public/stylesheets
          create  script/performance
          create  script/process
          create  test/fixtures
          create  test/functional
          create  test/integration
          create  test/mocks/development
          create  test/mocks/test
          create  test/unit
          create  vendor
          create  vendor/plugins
          create  tmp/sessions
          create  tmp/sockets
          create  tmp/cache
          create  tmp/pids
          create  Rakefile
          create  README
          create  app/controllers/application.rb
          create  app/helpers/application_helper.rb
          create  test/test_helper.rb
          create  config/database.yml
          create  config/routes.rb
          create  public/.htaccess
          create  config/initializers/inflections.rb
          create  config/initializers/mime_types.rb
          create  config/boot.rb
          create  config/environment.rb
          create  config/environments/production.rb
          create  config/environments/development.rb
          create  config/environments/test.rb
          create  script/about
          create  script/console
          create  script/destroy
          create  script/generate
          create  script/performance/benchmarker
          create  script/performance/profiler
          create  script/performance/request
          create  script/process/reaper
          create  script/process/spawner
          create  script/process/inspector
          create  script/runner
          create  script/server
          create  script/plugin
          create  public/dispatch.rb
          create  public/dispatch.cgi
          create  public/dispatch.fcgi
          create  public/404.html
          create  public/422.html
          create  public/500.html
          create  public/index.html
          create  public/favicon.ico
          create  public/robots.txt
          create  public/images/rails.png
          create  public/javascripts/prototype.js
          create  public/javascripts/effects.js
          create  public/javascripts/dragdrop.js
          create  public/javascripts/controls.js
          create  public/javascripts/application.js
          create  doc/README_FOR_APP
          create  log/server.log
          create  log/production.log
          create  log/development.log
          create  log/test.log

    In order to keep it simple, this application will not be using any database so uncomment the following line from "config/environment.rb" (remove "#" at  beginning of the line):

    config.frameworks -= [ :active_record, :active_resource, :action_mailer ]
  3. Install Goldspike plugin in the application as:

    ~/testbed/jruby-1.1RC3/samples/rails/railsee1 >../../../bin/jruby script/plugin install svn://rubyforge.org/var/svn/jruby-extras/trunk/rails-integration/plugins/goldspike
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/test
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/test/war_config_test_config.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/test/test_java_library.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/test/test_maven_library.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/test/test_create_war.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/Rakefile
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/init.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/tasks
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/tasks/war.rake
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/lib
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/lib/util.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/lib/war_config.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/lib/run.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/lib/java_library.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/lib/packer.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/lib/create_war.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/install.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/generators
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/generators/goldspike
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/generators/goldspike/goldspike_generator.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/generators/goldspike/templates
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/generators/goldspike/templates/web.xml.erb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/generators/goldspike/templates/war.rb
    A    /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1/vendor/plugins/goldspike/README
    Exported revision 960.
          exists  config
          create  config/war.rb
          create  WEB-INF
          create  WEB-INF/web.xml.erb

    Optionally Warbler may be used for packaging and Goldspike for dispatching.
  4. Create a Java library with Servlet code
    1. Using NetBeans IDE, create a project of type "Java Class Library" and specify the name "HelloServlet".
    2. Right-click on the project, select "New" and "Servlet...". Enter the class name as "HelloServlet" and package as "server" as shown below:

    3. Right-click on the project, select Properties and in "Libraries", "Compile Tab Libraries" add "javaee.jar" from GlassFish v2 UR1 "lib" directory.
    4. Change the "try" block in "processRequest" method to following:

      String name = request.getParameter("name");
      if (name == null || name.equals(""))
          name = "Duke";
                 
      out.println("<h1>Servlet HelloServlet at " + request.getContextPath () + " says Hello " + name + "!</h1>");
    5. Right-click on the project and select "Clean and Build".
  5. Configure Rails app for Servlet
    1. In your Rails application directory, add the following fragments to "WEB-INF/web.xml.erb":

      <servlet>
                      <servlet-name>hello</servlet-name>
                      <servlet-class>server.HelloServlet</servlet-class>
      </servlet>

      <servlet-mapping>
                      <servlet-name>hello</servlet-name>
                      <url-pattern>/hello</url-pattern>
      </servlet-mapping>
    2. Create "WEB-INF/lib" directory and copy "HelloServlet.jar" from the "dist" directory of NetBeans project here.
  6. Create & Deploy the WAR
    1. Create a WAR file as:

      ~/testbed/jruby-1.1RC3/samples/rails/railsee1 >../../../bin/jruby -S rake war:standalone:create
      (in /Users/arungupta/testbed/jruby-1.1RC3/samples/rails/railsee1)
      info: Assembling web application
      info: Packing needed Java libraries ...
      info:   adding Java library jruby-complete-1.1RC3
      info:   adding Java library goldspike-1.6
      info:   adding Java library activation-1.1
      info:   adding Java library commons-pool-1.3
      info:   adding Java library bcprov-jdk14-124
      info: Packing needed Ruby gems ...
      info:   adding Ruby gem rails version 2.0.2
      info:   adding Ruby gem rake version 0.8.1
      info:   adding Ruby gem activesupport version 2.0.2
      info:   adding Ruby gem activerecord version 2.0.2
      info:   adding Ruby gem actionpack version 2.0.2
      info:   adding Ruby gem actionmailer version 2.0.2
      info:   adding Ruby gem activeresource version 2.0.2
      info:   adding Ruby gem activerecord-jdbc-adapter version 0.8
      info: Packing needed files ...
      info: Creating web archive
    2. Deploy the WAR to GlassFish v2 UR1 as:

      ~/testbed/jruby-1.1RC3/samples/rails/railsee1 >~/testbed/glassfish/v2ur1/glassfish/bin/asadmin deploy railsee1.war
      Command deploy executed successfully.
  7. The bundled Servlet is now accessible at "http://localhost:8080/railsee1/hello". The default browser output looks like:



    And passing a parameter to the URL as "http://localhost:8080/railsee1/hello?name=Arun" shows the output as:

  8. With this, your Java EE Servlet is now bundled with your Rails application deployed on GlassFish v2 UR1.

    Now, lets add Controller and View to Rails application and invoke this servlet from there to show complete integration with Rails.
  1. Create a new Controller and View as

    ~/testbed/jruby-1.1RC3/samples/rails/railsee1 >../../../bin/jruby script/generate controller home index
    JRuby limited openssl loaded. gem install jruby-openssl for full support.
    http://wiki.jruby.org/wiki/JRuby_Builtin_OpenSSL
          exists  app/controllers/
          exists  app/helpers/
          create  app/views/home
          exists  test/functional/
          create  app/controllers/home_controller.rb
          create  test/functional/home_controller_test.rb
          create  app/helpers/home_helper.rb
          create  app/views/home/index.html.erb
  2. Change the generated controller in "app/controllers/home_controller.rb" to:

    class HomeController < ApplicationController

    include Java

      def index
            url = java.net.URL.new("http://localhost:8080/railsee1/hello");
            conn = url.open_connection;
            reader = java.io.BufferedReader.new(java.io.InputStreamReader.new(conn.get_input_stream));
            @servlet_output = "";
            input_line = reader.read_line;
            while input_line != nil
                    @servlet_output << input_line;
                    input_line = reader.read_line;
            end
            reader.close;
      end
    end
  3. Change the generated view in "app/views/home/index.rhtml.erb" to:

    <h1>Home#index</h1>
    <p>Find me in app/views/home/index.html.erb</p>

    <%= @servlet_output %>
  4. Re-create & re-deploy the WAR as describd in bullet # 6 above. And now "http://localhost:8080/railsee1/home/index" shows the output as shown:

This shows how a Java EE 5 Servlet can be easily invoked from a Rails application deployed on GlassFish. JRuby-on-Rails and GlassFish allows you to leverage business knowledge that exists in Java EE applications very easily and still providing Rails agility.


Technorati: rubyonrails netbeans glassfish javaee5 servlets jruby ruby goldspike
About

profile image
Arun Gupta is a technology enthusiast, a passionate runner, author, and a community guy who works for Oracle Corp.


Java EE 7 Samples

Stay Connected

Search

Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today