Techie Stuffs - Blogs on technology

Coding Interview - Check for Pangram

2016-05-20T17:16:00.001-07:00

A Pangram ("every letter") or holoalphabetic sentence for a given alphabet is a sentence using every letter of the alphabet at least once.

down vote

import java.io.;

import java.util.;

public class Solution {

public static void main(String[] args) {
   Scanner scanner = new Scanner(System.in);
   String input = scanner.nextLine(); 
    System.out.println(isPangram(input) ? "pangram" : "not pangram"); 
}

static boolean isPangram(String input) {
    boolean isPangram = false;

    if(input == null || input.length() < 26) {
        return isPangram;
    }

    input = input.toLowerCase();
    char [] charArray = input.toCharArray();
    Set<Character> charSet = new HashSet<>();
    for(char c : charArray) {
        if(Character.isLetter(c) && (!Character.isWhitespace(c))) {
            charSet.add(c);
        }
    }
    if (charSet.size() == 26) {
        isPangram = true;
    }
    return isPangram;
}

}

Central Authentication Service (CAS) - A quick tutorial

2015-07-28T16:33:00.001-07:00

The Central Authentication Service (CAS) is a single-sign-on / single-sign-off protocol for the web. It permits a user to access multiple applications while providing their credentials (such as userid and password) only once to a central CAS Server application.

Key Terms :-

Service Ticket (ST)
A service ticket is an opaque string that is used by the client as a credential to obtain access to a service. The service ticket is obtained from CAS upon a client’s presentation of credentials and a service identifier to /login

Service ticket properties

Service tickets are only valid for the service identifier that was specified to /login when they were generated. The service identifier SHOULD NOT be part of the service ticket.
Service tickets MUST only be valid for one ticket validation attempt. Whether or not validation was successful, CAS MUST then invalidate the ticket, causing all future validation attempts of that same ticket to fail.
CAS SHOULD expire unvalidated service tickets in a reasonable period of time after they are issued. If a service presents an expired service ticket for validation, CAS MUST respond with a validation failure response.
It is RECOMMENDED that the validation response include a descriptive message explaining why validation failed.
It is RECOMMENDED that the duration a service ticket is valid before it expires be no longer than five minutes. Local security and CAS usage considerations MAY determine the optimal lifespan of unvalidated service tickets.
Service tickets MUST contain adequate secure random data so that a ticket is not guessable.
Service tickets MUST begin with the characters, ST-.
Services MUST be able to accept service tickets of up to 32 characters in length. It is RECOMMENDED that services support service tickets of up to 256 characters in length.

Ticket-granting cookie (TGC)
A ticket-granting cookie is an HTTP cookie[5] set by CAS upon the establishment of a single sign-on session. This cookie maintains login state for the client, and while it is valid, the client can present it to CAS in lieu of primary credentials. Services can opt out of single sign-on through the renew parameter described in Sections 2.1.1, 2.4.1, and 2.5.1.

Cookie is set as CASTGC

ticket-granting cookie properties

A ticket-granting cookie SHALL be set to expire at the end of the client’s browser session if Long-Term support is not active (4.1.1) for the corresponding TGT.
CAS SHALL set the cookie path to be as restrictive as possible. For example, if the CAS server is set up under the path /cas, the cookie path SHALL be set to /cas.
The value of ticket-granting cookies SHALL contain adequate secure random data so that a ticket-granting cookie is not guessable in a reasonable period of time.
The name of ticket-granting cookies SHOULD begin with the characters TGC-.
The value of ticket-granting cookies SHOULD follow the same rules as the ticket-granting ticket. Typically, the value of the ticket-granting cookies MAY contain the ticket-granting ticket itself as the representation of the authenticated single sign-on session.
ticket and ticket-granting cookie character set - In addition to the above requirements, all CAS tickets and the value of the ticket-granting cookie MUST contain only characters from the set {A-Z, a-z, 0-9}, and the hyphen character -.

Ticket-granting ticket (TGT)
A ticket-granting ticket (TGT) is an opaque string that is generated by the CAS server that is issued upon an successful authentication event upon /login. This ticket may be tied to the ticket-granting cookie which represents the state of the single sign-on session, with validity period and acts as the foundation and baseline for issuance of service tickets, proxy-granting tickets, and more.

ticket-granting ticket properties

Ticket-granting tickets MAY be used by services to obtain multiple service tickets. Ticket-granting tickets are not one-time-use tickets and are associated with a validity period and expiration policy.
Ticket-granting tickets MUST expire when the client whose authentication is being managed logs out of CAS.
Ticket-granting tickets MUST contain adequate secure random data so that a ticket is not guessable in a reasonable period of time through brute-force attacks.
Ticket-granting tickets SHOULD begin with the characters TGT-.
It is RECOMMENDED that ticket-granting tickets be encrypted when shared with other external resources in order to minimize security vulnerabilities as they are tied to the ticket-granting cookie and represent the authentication session.

API Calls

Login :

GET : https://yourcompany.com/cas/login?service=test
this will give back the service ticket
the service is optional, but it would recommended to add a service filter.

https://yourcompany.com/cas/login?ticket=ST-31006626-w4NSorG4OvzPuliQCHTDdEpoS5rC0ExiziO-p004

This will logout
https://yourcompany.com/cas/logout?service=test.com
if the service is provided, the application will be redirected to the url provided after the logout

https://yourcompany.com/cas/v1/tickets
POST /cas/v1/tickets HTTP/1.1
Host: yourcompany.com
Accept: application/json
tenantID: 831D8B107020BBEBE0400F0A32207789
Cache-Control: no-cache
Content-Type: application/x-www-form-urlencoded

username=testuser&password=pass1234

This will give the TGT back.

This will make you login everytime, but looks like not supported in our implementation
https://yourcompany.com/cas/login?renew=true

https://yourcompany.com/cas/serviceValidate
checks the validity of a service ticket and returns an XML-fragment response. /serviceValidate MUST also generate and issue proxy-granting tickets when requested.

pgtUrl [OPTIONAL] - the URL of the proxy callback.

This will validate and give back the response as below
https://yourcompany.com/cas/serviceValidate?service=test&ticket=ST-31006626-w4NSorG4OvzPuliQCHTDdEpoS5rC0ExiziO-p004

<cas:serviceResponse xmlns:cas='http://www.yale.edu/tp/cas'>
<cas:authenticationSuccess>
<cas:user>myusername</cas:user>
<cas:emp_id>9031569335</cas:emp_id>
</cas:authenticationSuccess>
</cas:serviceResponse>

The above response is configurable based on the information available in your IDP.

https://yourcompany.com/cas/validate
checks the validity of a service ticket. /validate is part of the CAS 1.0 protocol and thus does not handle proxy authentication.

References:
https://wiki.jasig.org/display/CAS/Home
https://wiki.jasig.org/display/casum/restful+api
https://wiki.jasig.org/display/CASUM/User+Manual
http://jasig.github.io/cas/development/protocol/CAS-Protocol-Specification.html

RabbitMQ - Setting up a local cluster

2015-07-28T16:15:00.000-07:00

1. Make sure the ERLANG and RabbitMQ version is same on all nodes.

2. Copy over the erlang.cookie from one of the node to to all the nodes. The erlang.cookie must be same across all nodes.
In windows you would find under C:\Users\<logged in user> by default. Or check the HOMEPATH environment variable value, it would be under that folder.

Prerequisite for starting the node.

SET HOMEDRIVE, HOMEPATH

e.g. set HOMEDRIVE=C:
set HOMEPATH=\Users\xyzuser

in this case the erlang.cookie would be available under C:\Users\xyzuser

3. Start the Node 1

Command for starting the C:\Program Files (x86)\RabbitMQ Server\rabbitmq_server-3.5.1\sbin>rabbitmq-server.bat

4. Start the Node2

Command for starting the C:\Program Files (x86)\RabbitMQ Server\rabbitmq_server-3.5.1\sbin>rabbitmq-server.bat

5. Adding node2 to the cluster
C:\Program Files (x86)\RabbitMQ Server\rabbitmq_server-3.5.1\sbin>rabbitmqctl.bat stop_app
C:\Program Files (x86)\RabbitMQ Server\rabbitmq_server-3.5.1\sbin>rabbitmqctl.bat join_cluster rabbit@node1
C:\Program Files (x86)\RabbitMQ Server\rabbitmq_server-3.5.1\sbin>rabbitmqctl.bat start_app

JDK 7 Features

2013-02-15T19:10:00.001-07:00

Project Coin

The goal of Project Coin is to determine what set of small language changes should be added to JDK 7. That list is:

Strings in switch
Binary integral literals and underscores in numeric literals
Multi-catch and more precise rethrow
Improved type inference for generic instance creation (diamond)
try-with-resources statement
Simplified varargs method invocation

The previously selected features of collections support and unsigned literals have been deferred and will be reconsidered in JDK 8.

More Links :-
What's new in Java7

Comparison of RabbitMQ, ActiveMQ, and ZeroMQ Message Brokers

2013-01-09T10:04:00.001-07:00

Just got this good comparison from dzone. Added here for my reference :)

RabbitMQ is one of the leading implementation of the AMQP protocol (along with Apache Qpid). Therefore, it implements a broker architecture, meaning that messages are queued on a central node before being sent to clients. This approach makes RabbitMQ very easy to use and deploy, because advanced scenarios like routing, load balancing or persistent message queuing are supported in just a few lines of code. However, it also makes it less scalable and “slower” because the central node adds latency and message envelopes are quite big.

ZeroMQ is a very lightweight messaging system specially designed for high throughput/low latency scenarios like the one you can find in the financial world. Zmq supports many advanced messaging scenarios but contrary to RabbitMQ, you’ll have to implement most of them yourself by combining various pieces of the framework (e.g : sockets and devices). Zmq is very flexible but you’ll have to study the 80 pages or so of the guide (which I recommend reading for anybody writing distributed system, even if you don’t use Zmq) before being able to do anything more complicated that sending messages between 2 peers.

ActiveMQ is in the middle ground. Like Zmq, it can be deployed with both broker and P2P topologies. Like RabbitMQ, it’s easier to implement advanced scenarios but usually at the cost of raw performance. It’s the Swiss army knife of messaging :-).

Finally, all 3 products:
• Have client APIs for the most common languages (C++, Java, .Net, Python, Php, Ruby, …)
• Have strong documentation
• Are actively supported

Useful Tools/Technologies

2012-12-12T22:34:00.001-07:00

These are list of useful technologies, each of them are linked to the source pages.

JSONP : "JSON with padding" is a complement to the base JSON data format. It provides a method to request data from a server in a different domain, something prohibited by typical web browsers because of the same origin policy.

Git : is a distributed revision control and source code management (SCM) system.

Cross-origin resource sharing (CORS) is a mechanism that allows a web page to make XMLHttpRequests to another domain

NAnt is a free and open source software tool for automating software build processes. It is similar to Apache Ant, but targeted at the .NET environment rather than Java. The name NAnt comes from the fact that the tool is Not Ant

Nashorn is a JavaScript engine, developed fully in the programming language Java by Oracle

Da Vinci Machine, also called the Multi Language Virtual Machine is a project aiming to prototype the extension of the Java Virtual Machine to add support for dynamic languages.

Socket accept failed java.net.SocketException: Too many open files

2012-07-12T21:29:00.002-07:00

(JIoEndpoint.java:364) - Socket accept failed java.net.SocketException: Too many open files

We have come across this error recently in production and I am just sharing the issue we faced here.

From the exception message we know that too many files opened by the system than the max limit. There are two possibilities for this

1. The application needs more system resource and needs to be increased.

2. There is some issue with the application itself, which opens files and not closing properly.

The ulimit allow to limit system-wide resource use.

# ulimit -a

core file size (blocks, -c) 0

data seg size (kbytes, -d) unlimited

file size (blocks, -f) unlimited

pending signals (-i) 8191

max locked memory (kbytes, -l) 32

max memory size (kbytes, -m) unlimited

open files (-n) 1024

pipe size (512 bytes, -p) 8

POSIX message queues (bytes, -q) 819200

stack size (kbytes, -s) 8192

cpu time (seconds, -t) unlimited

max user processes (-u) 8191

virtual memory (kbytes, -v) unlimited

file locks (-x) unlimited

For the first case, we would need to increase the no open files limit for the application. We can either make that unlimited or set a higher value. ulimit allows to set limit to the system resources available to process other than ulimit does not limit storage space.

2. In the second case, which was the issue we faced we need trouble shot and found out he issue was with application.

We need to find out which file is opened too many time. There is way to find out the files opened by a process. In out case this was a tomcat application so I got my process id as below

ps -ef | grep java

Let us say I got the process is as 1234

Next move to the below folder using the process id

cd /proc/1234

Then run the below

sudo ls-1 ./fd/

This will list all the open files by that process 1234.

This way we found out that there is one particular file that was opened too many times.

The java code which had issue is as below

private void loadFile(){

InputStream is = null;

Properties prop = new Properties();

String path = getFilepath();

try {

prop.load( new FileInputStream( path ));

}catch( IOException ioe ){

} finally {

if (is != null) {

try {

is.close();

} catch (IOException e) {

e.printStackTrace();

}

See even though is.close() is called in finally block nothing is assigned to that variable and the new FileInputStream is not closed here. The fix was simple, see below

private void loadFile(){

InputStream is = null;

Properties prop = new Properties();

String path = getFilepath();

try {

is = new FileInputStream( path );

prop.load( is));

}catch( IOException ioe ){

} finally {

if (is != null) {

try {

is.close();

} catch (IOException e) {

e.printStackTrace();

}

Software Design Principles

2012-05-05T23:02:00.001-07:00

Software Design Principles

I was reading another blog and looked good to me. Just for a reference I am copy pasting that here!

Keep It Simple Stupid (KISS)
The main goal here is keep things simple. Avoiding unnecessary complexity will help to keep it clear and easy to understand. Also this principle will help in maintenance; if it is simple then also easy to modify. Usually the simplest solution is the best solution.
Don’t Repeat Yourself (DRY)
This principle states to not repeat things. We can abstract out repeated things and keep it at some common place where everybody can access it. We can also make common (repeating) things as general, so that it is available to all.
Separation of Concerns (SoC)
Separating things into discrete responsibilities increases reusability, maintenance and also testability. Here concerns refer to specific features or behavior of the system.

For example, Object Oriented programming languages such as C++, C# and Java (to name a few) can separate concerns into objects. A Design Pattern like MVC (Model-View-Controller) can separate content from presentation and data processing (model) from content. Service Oriented design can separate concerns into services. Procedural programming languages such as C can separate concerns into procedures. Aspect Oriented programming languages can separate concerns into aspects and objects.
The Pareto Principle
The famous pareto principle states that 80% of effects comes from 20% of causes, i.e. 80% of sales comes from 20% of customers. The principle is named after Italian economist Vilfredo Pareto, who observed in 1906 that 80% of land in Italy is owned by 20% of the population. It can help to resist efforts to correct and optimize designs beyond critical 20%. So 80% focus is on 20% part of the stuff.

In software engineering Pareto principle can be applied to optimization efforts. For example, Microsoftnoted that by fixing the top 20% of the most reported bugs, 80% of the errors and crashes would be eliminated.
The Robustness Principle
The Robustness Principle states that, “Be liberal in what you accept, and be conservative in what you send”. In other words, code that sends commands or data to other parts of the system should conform completely to the specifications, but code that receives input should accept non-conformant input as long as the meaning is clear.

For example, TCP implementation follows the principle.
You Ain’t Gonna Need It (YAGNI)
It is the principle in extreme programming, states that programmers should not add functionality until it is necessary. It tells programmers that always implement things when you actually need them, never when you just foresee that you need them. Even if you are sure that you will need it later on, do not implement it now. The principle is actually emerged from “Extreme Programming” methodologies.
Loose Coupling and High Cohesion
Coupling means links between separate units of a program. In OOPs, if two classes depend closely on many details of each other, we say they are tightly coupled.

Coupling is a measure of the interdependence between types/entities. If every object has a reference to every other object, then there is tight coupling, which is undesirable. Because there’s potentially too much information flow between objects. Loose coupling is desirable. It means that objects work more independently of each other. Loose coupling minimizes the “ripple effect” where changes in one class cause necessity for changes in other classes

Cohesion refers to the number and diversity of tasks that a class is designed for. If a class is responsible for a few related logical tasks, we say it has high cohesion.

Cohesion is a measurement of strengths of the association of variables and methods within a class. High cohesion is desirable because it means the class does one job well. Low cohesion is undesirable because it indicates that there are elements in the class which have little to do with each other. Modules whose elements are strongly and genuinely related to each other are desired. Each method should also be highly cohesive. Most methods have only one function to perform. Don’t add extra instructions into methods that cause it to perform more than one function

Loose Coupling has following advantages:
- We can understand concerned class without reading other classes
- We can change one class without affecting other classes
- Loose Coupling improves maintainability
High Cohesion has following advantages:
- We can easily understand what is the purpose of class or method
- High Cohesion makes it easier to use descriptive names
- We can easily reuse classes or methods
SOLID Principles
- Single Responsibility Principle (SRP)
  The Principle states that every object should have single responsibility, and the responsibility (reason to change) should be entirely encapsulated by the class. So a class or module should have one and only one reason to change.
  
  For example, we have a print report module. There are utmost two reasons to change the module. First is content of report is changed. Second is format of report is changed.
- Open Closed Principle (OCP)
  Software entities (i.e. classes, functions or modules) should be open for extension but closed for modification. Normally we close entities modification for providing backward compatibility (regression testing) and open entities extension for extending existing entities with new functionalities.
  
  For example, we can implement this principle by using Abstract classes, and thus enforcing concrete classes extend abstract classes rather than changing it. Some of the design patterns that supports this principle is template pattern and strategy pattern.
  
  In .NET Framework Microsoft has further supported this principle by providing partial classes/methods and extension methods. You can extend existing code by using these two new features in .NET.
- Liskov’s Substitution Principle (LSP)
  The principle states that derived types must be completely substitutable for their base types. It is just an extension of Open Closed Principle in terms of behavior. Meaning that the derived types must extend without changing behavior of base types, so that derived types is replaceable with base types (No need to change code).
  
  For example, we have method called StoreAddress(Address address) which accepts type “Address” as input parameter and stores it into the data store. Now if we make derived type from the “Address” type named “HomeAddress” then I should be able to call the same method by passing type “HomeAddress” and it stores correctly into the data store.
- Interface Segregation Principle (ISP)
  In nutshell, the principle states that “Clients should not be forced to depend upon interfaces that they don’t use”. When we simplify it states that when interface is too heavy, just break it down to the smaller and more specific interfaces which is client oriented so that clients should only worry about their concerned part.
  
  For example if we have <> interface which has “fly()” method and is implemented by Duck class. Now if we have wooden duck?
- Dependency Inversion Principle (DIP) [also known as Inversion of Control or Hollywood Principle: Don’t call us, we’ll call you or Dependency Injection]
  The Dependency Inversion principle refers to specific form of decoupling where conventional dependency relationship established from high level. The principle states two things.
  1. High-level modules should not depend on low-level modules. Both should depend on abstractions.
  2. Abstractions should not depend upon details. Details should depend upon abstractions.
  The main goal of dependency inversion principle is to decouple high-level components from low-level components in such a manner that reuse of low-level component implementations become possible.
  
  For example Adapter Pattern does the same thing. The high-level class defines its own adapter interface which is the abstraction that the high-level class depends on. The adaptee implementation also depends on the adapter interface abstraction. The high-level has no dependency to the low-level module since it only uses low-level indirectly through the adapter interface by working polymorphic methods to the interface which are implemented by the adaptee and its low-level module.
  
  Courtesy : http://www.dzone.com/links/r/software_design_principles.html
  
  References
  http://www.objectmentor.com/resources/articles/dip.pdf
  http://www.oodesign.com/dependency-inversion-principle.html
  http://www.oodesign.com/design-principles.html
  https://www-01.ibm.com/software/ucd/designconcepts/designbasics.html

WSDL2JAVA tool(Axis)

2012-04-07T09:26:00.000-07:00

WSDL2Java is a command line tool for generating server-side implementation skeletons in addition to client side proxies.

Steps :-
1. Download Axis
2. Run wsdl2java as below

C:\axis2-1.5.1\bin\client>wsdl2java -uri http://somewsdl.wsdl -o client -p com.somepackage.ws.client -d xmlbeans

3.There will be a classes and a build.xml file.

4. Use ant to build the project and generated the jar file

5. Add the jar to the project and use for invoking the webservice

wsdl2java.sh or wsdl2java.bat - Generates java code according to a given WSDL file to handle Web service invocation.

These scripts can be found under the bin directory of the Axis2 distribution.

SYNOPSIS

wsdl2java.sh [OPTION]... -uri <Location of WSDL>

DESCRIPTION

Given a WSDL file, this generates java code to handle Web service invocations.

-o <output Location> : output file location

-a : Generate async style code only. Default is off

-s : Generate sync style code only. Default is off. takes precedence over -a

-p <package name> : set custom package name

-l <language> : valid languages are java and csharp. Default is java

-t : Generate TestCase to test the generated code

-ss : Generate server side code (i.e. skeletons). Default is off

-sd : Generate service descriptor (i.e. services.xml). Default is off. Valid with -ss

-d <databinding> : valid databinding(s) are adb, xmlbeans and jaxme. Default is adb

-g : Generates all the classes. valid only with the -ss (This will generate client and server codes)

-pn <port_name> : name of port in the presence of multiple ports

-sn <service_name> : name of service in the presence of multiple services

-u : unpacks the databinding classes

-r <repository_path> : path of the repository against which code is generated

-ns2p ns1=pkg1,ns2=pkg2 : Specify a custom package name for each namespace specified in the wsdl's schema

-ssi : Generate an interface for the service implementation (Default: off)

-em : Specify an external mapping file

-wv : WSDL Version. Valid Options : 2, 2.0, 1.1

-f : Generate the source output folder without the src directory

-uw : Switch on un-wrapping.

-S <folder name> : Generated source folder name. (Default: src)

-R <folder name> : Generated resources folder name. (Default: resources)

Environment Variables:

Set AXIS2_HOME: C:\axis2-1.5.1

Set JAVA_HOME: C:\Program Files\Java\jdk1.5.0_22

Reference:

http://ws.apache.org/axis/java/ant/axis-wsdl2java.html

MongoDB - A quick tutorial

2012-02-25T19:53:00.003-07:00

MongoDB is a scalable, high-performance, open source, schema-free, document-oriented database and is one of the interesting non-relational databases available today.It is written in C++ and supported by 10gen.
MongoDB and SQL, a comparison.

RDBMS	MongoDB
database	database
table	collection
index	index
row	document
column	document field
primary key	_id
join	embedding or linking

Setting up MongoDB
1. Download the MongoDB from the following location (binary)
MongoDB Downloads
2. Unzip the binary to any location
3. Create a folder C:\data\db - this is the default location mongoDB stores data. And this won't be created automatically. If you would like to use a different location provide the new location using the -dbpath to the mongod.exe command (eg : mongod -dbpath ../ )
4. Start the mongodb using the "mongod.exe" command
eg: C:\mongodb2.0.2\bin\mongod

After the server is started :-
1. MongoDB comes with an interactive shell - mongo (similiar to sqlplus). This is a java script based shell and takes java scripts as input. There are many built in shell functions available.
eg: C:\Tools\mongodb2.0.2\bin\mongo
or TRY the free shell here
2. Admin UI's are also available to browse the MongoDB

Notes :

No need to create a database explicitly. Following command on the shell will automatically create the database eg; for creating the db "mytest" > use mytest
No need to create a collection explicitly. First use of collection name will create a collection.
Documents in the same collection can have different structures (schemaless!)
Input is JSON-style documents, internally stores in BSON format (Binary JSON).
use "_id" as the field name to have the user defined key as the primary key of the document.
If "_id" is not set, MongoDB add a "_id" field to the document with an auto generated value. eg: _id : ObjectId( "47cc67093475061e3d95369d" )
Format of "_id" value is a 4-byte timestamp + 3- byte machine id( hostname) + 2-byte process id + 3 byte counter (an ever incrementing value from a counter or a random value, when the counter is not available)
All the writes are fire and forget.
No joins, no transactions.
Autosharding is the cool feature of MongoDB which is the backbone of easy scale out.
MongoDB has pretty good querying capabilities.

Hands on :-
1. Open a mongo shell using
eg : C:\Tools\mongodb2.0.2\bin\mongo
type the below command on the shell to create and use the "practice" db
> use practice
Sample output from mongo shell
C:\Tools\mongodb2.0.2\bin>mongo
MongoDB shell version: 2.0.2
connecting to: test
> use practice
switched to db practice

2. Inserting data into a collection. Type in the below in the shell.. note "employee" is the collection name and will be created automatically in the first insert
> j={"name" : "TOM", "dob":"12/11/1998"};
> db.employee.insert(j);

3. Accessing data from a collection
> db.employee.find();
the output of the above find will be
{ "_id" : ObjectId("4f499a3f111314dc717421d5"), "name" : "TOM", "dob" : "12/11/1
998" }

4. Deleting data from a colleciton
>db.employee.remove();

5. Adding index. By default _id fields are indexed, "ensureIndex" is used for adding indexes on additional fields. 1- means ascending and -1 means descending. Indexing will help to increase the performance of large collection. But indexing on a live mongoDB is not recommended, because indexing on large collection may take minutes/hours to complete. use background : true option to run the indexing in background.
> db.employee.ensureIndex({"name" : 1});

Cloud Computing Overview

2012-01-28T08:27:00.003-07:00

Over the past few years, Cloud computing technology drawn the attention of IT world and is the changing the focus of enterprises. Like Steve Jobs said “some people think the cloud is just the hard disk in the sky”. Hope the below article will help to get an insight on Cloud Computing for anyone who thinks this is something to do with the sky.

Nist Defenition of cloud

Cloud computing can be defined as a style of computing where IT-related capabilities are provided to consumer as “service” rather than a product using the internet. Cloud stands as a metaphor for internet. Cloud computing gained attention due to the growth of internet technologies, reduced costs of storage and processing, growth technologies of virtualization, SOA (Service Oriented Architecture) and advancement in internet security.

Cloud computing was available for us even before all these buzz. We all are using cloud computing in our day to day activities, maybe without realizing, a classic example will be Gmail and yahoo mail. We use the service provided by Google and Yahoo via Internet where we need not worry about the technology/storage/infrastructure used and is all are taken care by the provider.

Then why is big hype now with cloud computing. Historically companies spend billions of dollars to build the core competencies for IT. By using cloud computing companies can lease these capabilities from others and reduce the cost. The technology was available, but now the future is in developing innovative business models and leverage the advantages cloud computing enables. By using the cloud computing a few new business models can be

On demand IT
Self Service IT
Pay per use

For example, if an organization buys a software product for its business needs, they would need to pay for the license and support. After that they would need to setup and maintain the infrastructure needed to installing and using that product. They also would need to take care of the upgrades of softwares, hardware and also responsible for the scalability. Instead of these if the product owner takes care of all the infrastructure needs for the product and consumer pay per usage, what would help companies to reduce the cost. They also need not worry about the software upgrades, scalability or availability. And the organization can be innovating on their core business competencies.

Top Cloud Service Providers: (note : just a random order)

Advantages :

Reduced cost: Most of the cloud computing is paid incrementally, that helps organizations to reduce cost.
Automated : No need to worry about keeping softwares up to date
Increased storage : Can store more data than their private computers
Scalability : Can increase the number of users without worrying about increasing hardware capacity on demand.
Mobility : The data/services can be accessed from any where using the internet.
High Availability : No need to worry about issues with the servers or software error. The providers will take care of everything.

Disadvantage:

Security
Loss of control
Decreased business flexibility
Integration problems

Cloud computing models

1. SaaS – Software as a service

2. PaaS – Platform as a service

3. IaaS – Infrastructure as a service

Cloud Deployment models

1. Private Cloud : Internal or company owned or dedicated

2. Public Cloud : Services offered to many customers from the same technology stack

3. Hybrid Cloud : Mix the services from both private and public cloud

Production Issues

2011-12-04T21:31:00.001-07:00

Database Connection Maxed

This is one of the common issues I have seen in production systems. Most of the major issues I have seen started with DB connections maxing out.Maxing out( using all the available connections in the connection pool) could be mainly due to two reason.
1. Increase in traffic and the pool size is not large enough.
2. Slowness - Slowness could in the app server, db servers, network, or query itself.

Trouble Shooting :-

1. Verify response times for any slowness. Compare with past date, a few weeks or months.
2. Check the app server's, db servers's for abnormal CPU usage, Memory usage.
3. Check if there any queries slowing down in the db.
4. Check for increase in traffic relating to a recent roll out of a new application or new feature.
5. Compare historic data at least a few weeks or months to figure out the increase in traffic.
6. Check the network checked, firewall issues etc.

Slowness in Response Time

Possible reasons

1. Database issue
2. Query issue - When the data increases the database could alter the plan it used until yesterday and start using a different plan, that could slow down the query today
3. Network issue
4. App server issue.

Troubelshooting :-
1. Try to separate out the layer which is slowing down.
2. Check if a particular database call is slow or all the database calls are slow.
3. Check if all the app servers are slow or only one or two node are slow - It could be possible that due to one or two bad nodes in the server farm we might experience a slowness.
4. Check the CPU usage in all the app servers.
5.Verify the memory usage.
6. Verify the garbage collection (GC logs), for Java applications. Due to pause times from Full GC the system could respond slow.

CPU Spikes

Possible reason :-

1. Application Threads
2. Garbage Collection
3. CPU was running hot and just the load increases or one of the node is bad.

Trouble Shooting :-

1. Take application thread dumps and analyse to see if any dead locks or blocked threads.
2. Analyse the GC logs and see if there any frequent Full GC and check for the pause times.
3. Check the type of Garbage Collection Algorithm used

Out of memory

Possible reasons :
1. Memory Leak
2. Not enough memory for the JVM. Eg: One a 4GB Machine you are running a JVM with min 500MB and 1GB max heap size and a memcached 2.5 GM cache size.(Assumption)

Trouble Shooting

1. Analyse Heap Dump - Always set the JVM parameter to get the heap dump on out of memory.
2. Check the JVM memory parameters.
3. Check the memory allocation
4. Verify the GC logs and analyse memory freed, full gc's etc.

Memcached Stats Explained

2011-12-01T21:43:00.001-07:00

Memcached Stats can be collected using "stats" command in a Linux machine. telnet "localhost"/host name 11211(or the port used) then type stats.

Name              Type     Meaning
----------------------------------
pid               32u      Process id of this server process
uptime            32u      Number of seconds this server has been running
time              32u      current UNIX time according to the server
version           string   Version string of this server
pointer_size      32       Default size of pointers on the host OS
                           (generally 32 or 64)
rusage_user       32u:32u  Accumulated user time for this process 
                           (seconds:microseconds)
rusage_system     32u:32u  Accumulated system time for this process 
                           (seconds:microseconds)
curr_items        32u      Current number of items stored by the server
total_items       32u      Total number of items stored by this server 
                           ever since it started
bytes             64u      Current number of bytes used by this server 
                           to store items
curr_connections  32u      Number of open connections
total_connections 32u      Total number of connections opened since 
                           the server started running
connection_structures 32u  Number of connection structures allocated 
                           by the server
cmd_get           64u      Cumulative number of retrieval requests
cmd_set           64u      Cumulative number of storage requests
get_hits          64u      Number of keys that have been requested and 
                           found present
get_misses        64u      Number of items that have been requested 
                           and not found
evictions         64u      Number of valid items removed from cache                                                                           
                           to free memory for new items                                                                                       
bytes_read        64u      Total number of bytes read by this server 
                           from network
bytes_written     64u      Total number of bytes sent by this server to 
                           network
limit_maxbytes    32u      Number of bytes this server is allowed to
                           use for storage. 
threads           32u      Number of worker threads requested.

Reference : http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt

XML Schema document parsing using XSOM

2011-09-28T10:12:00.001-07:00

XSOM stands for XML Schema Object Model and is a java library used to parse XSD's and retrieve the information inside. To get started down load the xom.jar and add to your classpath or use the below dependency in the POM if you are using Maven.

<dependency>

<groupId>com.sun.xsom</groupId>
<artifactId>xsom</artifactId>
<version>20081112</version>
</dependency>

XML Schema Component Data Model

Sample Code to Parse the XSD

XSOMParser parser = new XSOMParser();
parser.parse(url);
XSSchemaSet schemaSet = parser.getResult();

Sample Code to retrieve the optional elements from an XSD

public static List<String> getOptionalElements(URL url) {

List <String> list = new ArrayList<String>();

XSSchemaSet schemaSet = parseSchema(url);

Iterator <XSElementDecl> itrElements = schemaSet.iterateElementDecls();

while(itrElements.hasNext()) {

XSElementDecl xsElementDecl = (XSElementDecl) itrElements.next();

XSComplexType xsComplexType = xsElementDecl.getType().asComplexType();
if (xsComplexType != null) {
XSContentType xsContentType = xsComplexType.getContentType();
XSParticle particle = xsContentType.asParticle();
getOptionalElements(list, particle);
}
}
return list;
}

private static void getOptionalElements(List <String> list, XSParticle xsParticle) {

if(xsParticle != null){

XSTerm pterm = xsParticle.getTerm();

if(pterm.isElementDecl()) {

if(xsParticle.getMinOccurs() == 0) {
list.add(pterm.getSourceDocument().getTargetNamespace() + ":" + pterm.asElementDecl().getName());
}

System.out.println("Min Occurs : " + xsParticle.getMinOccurs());
System.out.println("Element Type : " + pterm.asElementDecl().getType());
System.out.println("Element Name : " + pterm.asElementDecl().getName());

XSComplexType xsComplexType = (pterm.asElementDecl()).getType().asComplexType();

if (xsComplexType != null && !(pterm.asElementDecl().getType()).toString().contains("Enumeration"))
{

XSContentType xsContentType = xsComplexType.getContentType();

XSParticle xsParticleInside = xsContentType.asParticle();
getOptionalElements(list, xsParticleInside);
}

} else if(pterm.isModelGroup()){

XSModelGroup xsModelGroup2 = pterm.asModelGroup();
XSParticle[] xsParticleArray = xsModelGroup2.getChildren();
for(XSParticle xsParticleTemp : xsParticleArray ){
getOptionalElements(list, xsParticleTemp);
}
}
}
}

Sample code to get the elements with Choice

public static List<String> getChoiceElements(URL url) {

List <String> list = new ArrayList<String>();

XSSchemaSet schemaSet = parseSchema(url);

Iterator <XSElementDecl> itrElements = schemaSet.iterateElementDecls();

while(itrElements.hasNext()) {

XSElementDecl xsElementDecl = (XSElementDecl) itrElements.next();

XSComplexType xsComplexType = xsElementDecl.getType().asComplexType();
if (xsComplexType != null) {
XSContentType xsContentType = xsComplexType.getContentType();
XSParticle particle = xsContentType.asParticle();
getChoiceElements(list, particle);
}
}
return list;
}

private static void getChoiceElements(List <String> list, XSParticle xsParticle) {

if(xsParticle != null){

XSTerm pterm = xsParticle.getTerm();

if(pterm.isModelGroup()){

XSModelGroup xsModelGroup = pterm.asModelGroup();
XSParticle[] particles = xsModelGroup.getChildren();

if(XSModelGroup.CHOICE == xsModelGroup.getCompositor()) {

printXSParticle(particles);

}

for(XSParticle p2: particles ){
getChoiceElements(list, p2);
}

} else if(pterm.isElementDecl()) {

XSComplexType xsComplexType = (pterm.asElementDecl()).getType().asComplexType();
if (xsComplexType != null) {
XSContentType xsContentType = xsComplexType.getContentType();
XSParticle particle = xsContentType.asParticle();
getChoiceElements(list, particle);
}

}
}
}

private static void printXSParticle(XSParticle[] xsParticleArray) {

for(XSParticle xsParticle: xsParticleArray ){
if(xsParticle != null){
XSTerm pterm = xsParticle.getTerm();
if(pterm.isElementDecl()) { //xs:element inside complex type
System.out.println("Min Occurs : " + xsParticle.getMinOccurs());
System.out.println("Element Name : " + pterm.asElementDecl().getType());
System.out.println("Element Name : " + pterm.asElementDecl().getName());
}
}
}
}

References :-

http://xsom.java.net/nonav/javadoc/overview-summary.html
http://xsom.java.net/

SOAP Quick Tutorial

2011-08-04T16:23:00.000-07:00

SOAP (Simple Object Access Protocol)

What is SOAP? SOAP is a simple XML based protocol used to exchange information between applications. SOAP is a communication protocol, W3C recommended and it platform independent.

SOAP Message :

The SOAP message has mainly below parts

1. SOAP Envelope - Root element for the SOAP message.Will have SOAP body
2. SOAP Header - (Optional) - It hold information about how the message should be processed
3. SOAP Body - (Required) The real payload of message will be part of the SOAP Body
4. SOAP Fault - (Optional) - This is used to indicate error and report the error messages.

A Sample Skeleton SOAP Message

<?xml version="1.0" encoding="UTF-8"?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">

<soapenv:Header>
...
</soapenv:Header>

<ssoapenv:Body>
...
<soapenv:Fault>
...
</soapenv:Fault>
</soapenv:Body>

</ssoapenv:Envelope>

Notes :

1. xmlns:soapenv Namespace will always have the same value http://schemas.xmlsoap.org/soap/envelope/

2. mustUnderstand Attribute is added to the child nodes of the SOAP header to indicate whether it is mandatory for the recipient to process the header.Possible value are 1 or 0.

<soapenv:Header>
<child soapenv:mustUnderstand="1">test</child>
</soapenv:Header>

3. actor Attribute

A SOAP Message

PIC 1

A SOAP Message with Attachment

PIC 2

AD vs LDAP vs ADAM

2011-05-11T13:01:00.002-07:00

Most of my projects use Active Directory (AD) for storing and retrieving the user authentication information. We interchangeably uses AD and LDAP etc for the same. This caused confusion for some people around me, so I got this idea of writing this down here.

LDAP :- Light Directory Access Protocol (LDAP) is a protocol for retrieving information from a directory services. It was created around 1980. There is no application called LDAP, it is just a protocol

AD :- Active Directory (AD) is a Microsoft Implementation of Directory service. We need to conform to LDAP to use AD. AD is widely used and only available for windows. It uses Microsoft proprietary notation for some of the features.This is software and a server run for this. :)

There are many other directory service softwares like Open LDAP, Apache Open Directory etc. Wikipedia has list of those servers http://en.wikipedia.org/wiki/List_of_LDAP_software

An example url for AD look like : ldap://ad.mycompany.com

ADAM :- Active Directory Application Mode is a new mode of Active Directory that is designed specifically for directory enabled applications. It uses straight LDAP notation for everything, but is a proxy on top of AD, and so it is slower. ADAM is used mostly for the storage of application specific data.

Being said all the above, arises the question why all these confusion, why can't we store this information in an database. Here is the reason for that.

LDAP Directories vs Relational Databases

LDAP directories are optimized for search and read operations. Object-oriented hierarchal data design. Data objects in the directory represents entities such as users, computers, and shared resources. These data objects can be organized hierarchically in a contained. Uses standardized and extensible schema. Security is applied down to the object and attribute level. Data can be replicated through out the network. So this is best suited user, security and resource management applications.

Databases on the other hand are optimized for write operations and used relational data design. Data is stored in tables of rows and columns. Less level security only to row and column level only.

Subversion revision number and build time with Maven

2011-05-04T00:13:00.000-07:00

I had this requirement to add the latest build revision from Subversion and the build time to the manifest of the war created using Maven.As I am new to Maven like any other developer I googled for a solution.Though google took me to the right plugin to use, getting the build time turned out to be tricky. Most of the places I found answers which didn't solve the issue.So here is a solution for this, add the below snippets to your POM file.

Step - 1 Add the SVN location

<scm>
<connection>scm:svn:http://svn.yourlocation/project/trunk</connection>
<developerConnection>scm:svn:http://svn.yourlocation/project/trunk</developerConnection>
<tag>HEAD</tag>
<url>http://svn.yourlocation/project/trunk</url>
</scm>

Step -2 Include the build number maven plugin. This plugin returns the buildnumber as the property buildNumber and build time as the property timestamp. We can refer this anywhere in the POM as ${buildNumber} or {timestamp}. By default the timestamps will be in milliseconds use the <timestampFormat>{0,date,MM/dd/yyyy hh:mm:ss a}</timestampFormat > to format the timestamp on the format you need.

<plugin>

<groupId>org.codehaus.mojo</groupId>

<artifactId>buildnumber-maven-plugin</artifactId>

<version>1.0</version>

<executions>

<execution>

<phase>validate</phase>

<goals>

<goal>create</goal>

</goals>

</execution>

</executions>

<configuration>

<timestampFormat>{0,date,MM/dd/yyyy hh:mm:ss a}</timestampFormat >

<doCheck>false</doCheck>

<doUpdate>false</doUpdate>

</configuration>

</plugin>

Step -3 Include the build version and build time to the manifest using the war or jar plugins.

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.1</version>
<configuration>
  <archive>
<manifest>
<addDefaultImplementationEntries>true
</addDefaultImplementationEntries>
  </manifest>
<manifestEntries>
<Revision>${buildNumber}</Revision>
<Build-Time>${timestamp}</Build-Time>
</manifestEntries>
</archive>
</configuration>
</plugin>

Having all these three steps will add the SVN revision and the build time to the manifest.

Referece : http://mojo.codehaus.org/buildnumber-maven-plugin/create-mojo.html

AutoCloseable - try with resources block

2011-04-17T12:05:00.001-07:00

Java 7 introduces a new feature to close any resources which is open and missed to close int the code. If a file is opened and we don't really need to worry about closing that any more. The Autocloseable interface referenced in the try block will be closed automatically. Around 533 classes in Java implements the autocloseable interface.

Sample code :

private static void customBufferStreamCopy(File source, File target) {

try (InputStream fis = new FileInputStream(source);

OutputStream fos = new FileOutputStream(target)){

byte[] buf = new byte[8192];

int i;

while ((i = fis.read(buf)) != -1) {

fos.write(buf, 0, i);

}

catch (Exception e) {

e.printStackTrace();

}

Docs : http://download.java.net/jdk7/docs/api/java/lang/AutoCloseable.html

JDBC driver types

2011-04-10T21:54:00.003-07:00

Here are some good notes on the JDBC Drivers, I found some where!

JDBC driver types

A JDBC driver is needed for a Java application to communicate with a database using JDBC. JDBC drivers are categorized into four types. The architecture differences between these categories include how the driver makes a connection to the database and whether the driver is implemented in native or Java code.

Type 1: JDBC-ODBC bridge

The type 1 driver provides JDBC access to most Open Database Connectivity (ODBC) drivers. Type 1 drivers are "JDBC-ODBC bridge" drivers provided by Sun and are meant to support legacy products. The bridge converts JDBC calls into ODBC and passes them to the appropriate ODBC driver for the backend database. The bridge driver needs to be installed and configured on the client side before it can be used. The use of two interfaces (JDBC and ODBC) makes this driver type the least performing. The functionality of this driver is also limited to the underlying ODBC driver, which usually does not support all the features of Java. It is recommended to use this driver for development only and not in a production environment.

Type 2: Native API driver

The type 2 driver converts JDBC to native proprietary database calls. This driver is partially native and partially Java. The JDBC manager, driver and native database libraries are required on the client. Type 2 drivers are faster than type 1 because the extra layer of translation to ODBC is removed.

Oracle Type 2 Driver
Oracle provides a type 2 driver called the JDBC Oracle Call Interface (OCI) driver. It is written in a combination of Java and C and converts JDBC to OCI using JNI calls. These calls are then sent over Oracle Net to the Oracle database server. This driver is Oracle platform-specific because it requires an Oracle client installation.

Type 3: JDBC Network-protocol driver

The type 3 driver uses a database-independent network protocol to communicate with a middle-tier JDBC server. The JDBC server translates these calls into the database-specific API. The driver is database independent and does not require any native binary code on the client. It only needs to pass SQL commands over the network to the server and receive data back. The JDBC server can be implemented in Java or as a native component.

Type 4: Native protocol (100% Java driver)

The type 4 driver translates JDBC calls into the DBMS specific protocol directly. Similar to the type 3 driver, the type 4 drivers do not require any code on the client.

Oracle Type 4 Driver

Oracle provides a type 4 driver called the JDBC thin driver, which is a 100 percent Java, platform-independent. The JDBC thin driver allows a direct connection to the database by providing an implementation of TCP/IP that emulates Oracle Net and TTC (the wire protocol used by OCI) on top of Java sockets.

How to choose a driver for your application
There are some cases where there will be no option about which driver to use. Applications that will be running on many clients, such as an applet, will need to use the JDBC thin driver.

Use the thin driver if you are writing an applet. The OCI driver will not work inside a Web browser because it makes native method calls.

Use the thin driver for applications where you have no control over the client platform.

OCI vs. thin driver:

For applications that will be deployed in a controlled environment where you have the opportunity to install the Oracle client software on every platform, you have a choice between the type 2 OCI driver and type 4 thin driver. There are a few things to keep in mind when choosing between these two drivers. These include: performance, scalability, portability and cost.

Performance

Type 2 drivers are generally faster than type 4 drivers because they are directly executed by the computer's CPU. The type 4 driver's are compiled into byte code and are executed on the Java Virtual Machine, which is then executed by the computer's CPU. The JVM adds an additional layer that affects its performance. Because the OCI driver uses native code libraries, it executes faster than the thin driver.There is a significant performance difference between the two drivers when stored procedures are used. The thin driver can take up to twice as long as the OCI driver to execute a stored procedure. Response time can deteriorate quickly if multiple stored procedures are called.Use the OCI driver if performance is critical to your application or you make heavy use of stored procedures.

Scalability

The type 2 OCI driver has several extensions that can improve the scalability and availability of your applications. These include connection pooling and transparent application failover.

OCI driver connection pooling
Connection pooling is a mechanism to reuse physical connections and minimize expensive operations in the creation and closing of database sessions. Both the thin and OCI drivers support connection pooling, however, the OCI driver has some enhanced features. The OCI driver allows applications to have many logical connections to the database, all using a small set of physical connections. The pooling of the incoming connections to the Oracle database is controlled by the OCI connection pool manager on the middle tier. Many more Oracle sessions can be multiplexed over this pool of fewer shared connections and backend databases.

Transparent Application Failover
Transparent Application Failover (TAF) is another feature of the OCI driver. It allows the driver to automatically reconnect to a database if the database instance to which the connection is made goes down. When this occurs, the active transactions are rolled back and the last committed transaction is restored. The new database connection, though created by a different node, is identical to the original regardless of how the connection was lost.

Use the OCI driver if you want the maximum scalability of the Oracle server or you need the enhanced availability features such as Transparent Application Failover.

Portability and cost
The JDBC OCI driver requires the presence of the OCI libraries, Net8, CORE libraries and other files on each client machine on which it is installed. The time (and therefore cost) of installing, configuring and maintaining the client software needs to be taken into account when using the OCI driver.

Use the thin driver for maximum portability and lower cost.

The following summarizes the types of drivers to use in different situations.

Performance with stored procedures: Type 2
Scalability: Type 3, Type 4
Transparent Application Failover: Type 2
Legacy system with ODBC driver: Type 2
Portability: Type 3, Type 4

Performance

Current Web applications are still very database-centric. From 60 percent to 90 percent of the execution time on a Web application can be spent in accessing the database. To improve performance of these applications, it is very important to tune database access in your applications. The following section outlines the best practices for database access including:

Disabling auto-commit mode
Defining column types
Prefetching rows
Using update batching
Using JDBC connection pooling and caching
Using JDBC statement caching
Avoid using more than one database connection simultaneously

Disabling auto-commit mode

Auto-commit mode indicates to the database whether to issue an automatic commit operation after every SQL operation. Being in auto-commit mode can be expensive in terms of time and processing effort if, for example, you are repeating the same statement with different bind variables.
By default, new connection objects are in auto-commit mode. However, you can disable auto-commit mode with the setAutoCommit() method of the connection object (either java.sql.Conection or oracle.jdbc.OracleConnection).
For better application performance, disable auto-commit mode and use the commit() or rollback() method of the connection object to manually commit or rollback your transaction.

Example: Disabling auto-commit mode

The following example illustrates how to do this. It assumes you have imported the oracle.jdbc.* and java.sql.* interfaces and classes.

//ds is a DataSource object
Connection conn = ds.getConnection();
// It's faster when auto commit is off
conn.setAutoCommit (false);
// Create a Statement
Statement stmt = conn.createStatement ();
...

Defining Column Types

Defining column types improves performance by saving a roundtrip to the DB server. It allows the application code to define the datatype for every column of the expected result set and for VARCHAR, VARCHAR2, CHAR and CHAR2 it specifies the maximum length.

Example: Defining column types
The following example illustrates the use of this feature. It assumes you have imported the oracle.jdbc.* and java.sql.* interfaces and classes.

//ds is a DataSource object
Connection conn = ds.getConnection();
PreparedStatement pstmt = conn.prepareStatement("select empno, ename, hiredate from emp");
//Avoid a roundtrip to the database and describe the columns
((OraclePreparedStatement)pstmt).defineColumnType(1,Types.INTEGER);
//Column #2 is a VARCHAR, we need to specify its max length
((OraclePreparedStatement)pstmt).defineColumnType(2,Types.VARCHAR,12);
((OraclePreparedStatement)pstmt).defineColumnType(3,Types.DATE);
ResultSet rset = pstmt.executeQuery();
while (rset.next())
System.out.println(rset.getInt(1)+","+rset.getString(2)+","+rset.getDate(3));
pstmt.close();
...

Prefetching rows
Row prefetching improves performance by reducing the number of round trips to a database server. For most database-centric applications, row prefetching should be used as much as possible. The recommended prefetch size is 10.

Example: Row prefetching
The following example illustrates the use of row prefetching. It assumes you have imported the oracle.jdbc.* and java.sql.* interfaces and classes.

//ds is a DataSource object
Connection conn = ds.getConnection();
//Set the default row-prefetch setting for this connection
((OracleConnection)conn).setDefaultRowPrefetch(7);
//The following statement gets the default row-prefetch value for
//the connection, that is, 7
Statement stmt = conn.createStatement();
//Subsequent statements look the same, regardless of the row
//prefetch value. Only execution time changes.
ResultSet rset = stmt.executeQuery("SELECT ename FROM emp");
System.out.println( rset.next () );
while( rset.next () )
System.out.println( rset.getString (1) );
//Override the default row-prefetch setting for this statement
( (OracleStatement)stmt ).setRowPrefetch (2);
ResultSet rset = stmt.executeQuery("SELECT ename FROM emp");
System.out.println( rset.next () );
while( rset.next() )
System.out.println( rset.getString (1) );
stmt.close();

Using update batching
Update batching sends a batch of operations to the database in one trip. When using it:

Always disable auto-commit mode with update batching.
Use a batch size of around 10.
Don't mix the standard and Oracle models of update batching.

Example: Oracle update batching
The following example illustrates how you use the Oracle update batching feature. It assumes you have imported the oracle.driver.* interfaces.

//ds is a DataSource object
Connection conn = ds.getConnection();
//Always disable auto-commit when using update batching
conn.setAutoCommit(false);
PreparedStatement ps = conn.prepareStatement("insert into dept values
(?, ?, ?)");
//Change batch size for this statement to 3
((OraclePreparedStatement)ps).setExecuteBatch (3);

//--------#1------------
ps.setInt(1, 23);
ps.setString(2, "Sales");
ps.setString(3, "USA");
ps.executeUpdate(); //JDBC queues this for later execution
//--------#2------------
ps.setInt(1, 24);
ps.setString(2, "Blue Sky");
ps.setString(3, "Montana");
ps.executeUpdate(); //JDBC queues this for later execution

//--------#3------------
ps.setInt(1, 25);
ps.setString(2, "Applications");
ps.setString(3, "India");
ps.executeUpdate(); //The queue size equals the batch value of 3
//JDBC sends the requests to the database

//--------#1------------
ps.setInt(1, 26);
ps.setString(2, "HR");
ps.setString(3, "Mongolia");
ps.executeUpdate(); //JDBC queues this for later execution
((OraclePreparedStatement)ps).sendBatch(); // JDBC sends the

//queued request
conn.commit();
ps.close();
...

Example: Standard update batching
This example uses the standard update batching feature. It assumes you have imported the oracle.driver.* interfaces.

//ds is a DataSource object
Connection conn = ds.getConnection();
//Always disable auto-commit when using update batching
conn.setAutoCommit(false);
Statement s = conn.createStatement();
s.addBatch("insert into dept values ('23','Sales','USA')");
s.addBatch("insert into dept values ('24','Blue Sky','Montana')");
s.addBatch("insert into dept values ('25','Applications','India')");
//Manually execute the batch
s.executeBatch();
s.addBatch("insert into dept values ('26','HR','Mongolia')");
s.executeBatch();
conn.commit();
ps.close();
...

Using JDBC connection pooling and caching

Constant creation and destruction of resource objects can be very expensive in Java. We suggest using a resources pool to share resources that are expensive to create. The JDBC connections are one of the most common resources used in any Web application that requires database access. They are also very expensive to create. We have seen overhead from hundreds of milliseconds to seconds (depending on the load) in establishing a JDBC connection on a mid-size system with 4 CPUs and 2 GB memory.In JDBC 2.0, a connection-pooling API allows physical connections to be reused. A pooled connection represents a physical connection, which can be reused by multiple logical connections. When a JDBC client obtains a connection through a pooled connection, it receives a logical connection. When the client closes the logical connection, the pooled connection does not close the physical connection. It simply frees up resources, clears the state and closes any statement objects associated with the instance before the instance is given to the next client. The physical connection is released only when the pooled connection object is closed directly.
The term pooling is extremely confusing and misleading in this context. It does not mean there is a pool of connections. There is just one physical connection, which can be serially reused. It is still up to the application designer to manage this pooled connection to make sure it is used by only one client at a time.
To address this management challenge, Oracle's extension to JDBC2.0 also includes connection caching, which helps manage a set of pooled connections. It allows each connection cache instance to be associated with a number of pooled connections, all of which represent physical connection to the same database and schema. You can use one of Oracle's JDBC connection caching schemes (dynamic, fixed with no wait or fixed wait) to determine how you want to manage the pooled connections, or you can use the connection caching APIs to implement your own caching mechanisms.

Using JDBC statement caching
Use JDBC statement caching to cache a JDBC PreparedStatement or OracleCallableStatement that is used repeatedly in the application to:

prevent repeated statement parsing and recreation
reduce the overhead of repeated cursor creation

The performance gain will depend on the complexity of the statement and how often the statement has to be executed. Since each physical connection has its own statement cache, the advantage of using statement caching with a pool of physical connections may vary. That is, if you execute a statement in a first connection from a pool of physical connections, it will be cached with that connection. If you later get a different physical connection and want to execute the same statement, then the cache does you no good.Avoid using more than one database connection simultaneously
Using more than one database connection simultaneously in a request can cause a deadlock in the database. This is most common in JSPs. First, a JSP will get a database connection to do some data accessing. But then, before the JSP commits the transaction and releases the connection, it invokes a bean which gets its own connection for its database operations. If these operations are in conflict, they can result in a deadlock.
Furthermore, you cannot easily roll back any related operations if they are done by two separate database connections in case of failure. Unless your transaction spans multiple requests or requires some complex distributed transaction support, you should try to use just one connection at a time to process the request.

Summary
This paper provides an overview of the JDBC driver types, guidelines on how to choose a JDBC driver, and how to improve the performance of database applications. Of the 4 JDBC driver types, Oracle provides a type 2 OCI driver and a type 4 thin driver. Advantages of the type 2 OCI driver include Transparent Application Failover and improved performance when stored procedures are used. The type 4 thin driver should be used for maximum portability and lowest cost. To achieve the best possible performance from the applications and JDBC drivers, several performance-tuning best practices should be followed including: disabling auto-commit mode, defining column types, prefetching rows, using update batching and using JDBC statement caching.

Microsoft Baseline Security Analyzer

2011-04-09T17:05:00.002-07:00

MBSA is pretty good free tool from Microsoft which helps to determine the security state of windows machines. I was just playing around with MBSA 2.0 today and thought would share with you guys...
Download the tool from here http://www.microsoft.com/downloads/en/details.aspx?displaylang=en&FamilyID=02be8aee-a3b6-4d94-b1c9-4b1989e0900c#QuickDetails

Open the command prompt as administrator user and go to C:\Program Files\Microsoft Baseline Security Analyzer 2>

Type in the command mbsacli to scan your computer.It list outs all the issues in your machine.
Also it has a nice GUI.

Endorsed Standards Override Mechanism

2010-12-19T16:07:00.001-07:00

An endorsed standard is a Java API defined through a standard process other than the Java Community Process (JCP). Because endorsed standards are defined outside the JCP, it is anticipated that such standards may be revised between releases of the Java Platform. In order to take advantage of new revisions of endorsed standards developers and software vendors may use the Endorsed Standards Override Mechanism to provide newer versions of an endorsed standard than those included in the Java Platform as released.

Deployment

New Jars are placed under the following folders

<JAVA_HOME>\lib\endorsed

also set Xendored="true"

Aggregation Vs Composition

2010-12-17T16:23:00.000-07:00

Just for people who got the same question in their Java interview.. I got this question from many people during interview.. I don't ask the same to any one in an interview though, I wanted to share this to anyone who is looking for an answer for this........

Aggregation is an association in which one class belong to a collection. This is a part of a whole relationship where a part can exist without a whole.

Eg. A line item is a whole and product is a part. If a line item is deleted the corresponding product need not be deleted.

So Aggregation is a weaker relationship

Composition is a relation in which one class belong to a collection. This is a part of a whole relationship where a part cannot exist without a whole. If whole is deleted then all parts are deleted.

Eg. An order is a whole and line items are part. If an order is deleted then all corresponding line items for that order should be deleted.

So composition has a stronger relationship.

Notes 1 - Object Oriented Programming (OOPL)

2010-12-17T11:18:00.000-07:00

Quick notes on OOPL in Java

OOP- Directly represents real time objects
PIE (Polymorphism, Inheritance, Encapsulation) - are the 3 pillars of OOPL

Polymorphism

It is the capability of an action or method to do different things based on the object that it is acting upon.

Three types of Polymorphism in Java

Overlaoding
Overriding
Dynamic Method Binding

Inheritnace in Java

This is the capability of a class to use the properties and methods of another class while assing its own functionality.

Java uses extends keyword.

Interfaces
Abstract Classes

Encapsulation

It is the ability of an object to be a contained for related properties and methods(function)

POJOS, bean classes.

Java Interview Questions

2010-06-07T19:27:00.001-07:00

Few of questions that can ask from you at Interview...

1. What is the most important feature of Java?

Java is a platform independent language.

2. What do you mean by platform independence?

Platform independence means that we can write and compile the java code in one platform (eg Windows) and can execute the class in any other supported platform eg (Linux,Solaris,etc).

3. What is a JVM?

JVM is Java Virtual Machine which is a run time environment for the compiled java class files.

4. Are JVM's platform independent?

JVM's are not platform independent. JVM's are platform specific run time implementation provided by the vendor.

5. What is the difference between a JDK and a JVM?

JDK is Java Development Kit which is for development purpose and it includes execution environment also. But JVM is purely a run time environment and hence you will not be able to compile your source files using a JVM.

6. What is a pointer and does Java support pointers?

Pointer is a reference handle to a memory location. Improper handling of pointers leads to memory leaks and reliability issues hence Java doesn't support the usage of pointers.

7. What is the base class of all classes?

java.lang.Object

8. Does Java support multiple inheritance?

Java doesn't support multiple inheritance.

9. Is Java a pure object oriented language?

Java uses primitive data types and hence is not a pure object oriented language.

10. Are arrays primitive data types?

In Java, Arrays are objects.

11. What is difference between Path and Classpath?

Path and Classpath are operating system level environment variales. Path is used define where the system can find the executables(.exe) files and classpath is used to specify the location .class files.

12. What are local variables?

Local varaiables are those which are declared within a block of code like methods. Local variables should be initialised before accessing them.

13. What are instance variables?

Instance variables are those which are defined at the class level. Instance variables need not be initialized before using them as they are automatically initialized to their default values.

14. How to define a constant variable in Java?

The variable should be declared as static and final. So only one copy of the variable exists for all instances of the class and the value can't be changed also.
static final int PI = 2.14; is an example for constant.

15. Should a main() method be compulsorily declared in all java classes?

No not required. main() method should be defined only if the source class is a java application.

16. What is the return type of the main() method?

Main() method doesn't return anything hence declared void.

17. Why is the main() method declared static?

main() method is called by the JVM even before the instantiation of the class hence it is declared as static.

18. What is the argument of main() method?

main() method accepts an array of String object as argument.

19. Can a main() method be overloaded?

Yes. You can have any number of main() methods with different method signature and implementation in the class.

20. Can a main() method be declared final?

Yes. Any inheriting class will not be able to have it's own default main() method.

21. Does the order of public and static declaration matter in main() method?

No. It doesn't matter but void should always come before main().

22. Can a source file contain more than one class declaration?

Yes a single source file can contain any number of Class declarations but only one of the class can be declared as public.

23. What is a package?

Package is a collection of related classes and interfaces. package declaration should be first statement in a java class.

24. Which package is imported by default?

java.lang package is imported by default even without a package declaration.

25. Can a class declared as private be accessed outside it's package?

Not possible.

26. Can a class be declared as protected?

A class can't be declared as protected. only methods can be declared as protected.

27. What is the access scope of a protected method?

A protected method can be accessed by the classes within the same package or by the subclasses of the class in any package.

28. What is the purpose of declaring a variable as final?

A final variable's value can't be changed. final variables should be initialized before using them.

29. What is the impact of declaring a method as final?

A method declared as final can't be overridden. A sub-class can't have the same method signature with a different implementation.

30. I don't want my class to be inherited by any other class. What should i do?

You should declared your class as final. But you can't define your class as final, if it is an abstract class. A class declared as final can't be extended by any other class.

31. Can you give few examples of final classes defined in Java API?

java.lang.String, java.lang.Math are final classes.

32. How is final different from finally and finalize()?

final is a modifier which can be applied to a class or a method or a variable. final class can't be inherited, final method can't be overridden and final variable can't be changed.

finally is an exception handling code section which gets executed whether an exception is raised or not by the try block code segment.

finalize() is a method of Object class which will be executed by the JVM just before garbage collecting object to give a final chance for resource releasing activity.

33. Can a class be declared as static?

We can not declare top level class as static, but only inner class can be declared static.

public class Test
{
static class InnerClass
{
public static void InnerMethod()
{ System.out.println("Static Inner Class!"); }
}
public static void main(String args[])
{
Test.InnerClass.InnerMethod();
}
}
//output: Static Inner Class!

34. When will you define a method as static?

When a method needs to be accessed even before the creation of the object of the class then we should declare the method as static.

35. What are the restriction imposed on a static method or a static block of code?

A static method should not refer to instance variables without creating an instance and cannot use "this" operator to refer the instance.

36. I want to print "Hello" even before main() is executed. How will you acheive that?

Print the statement inside a static block of code. Static blocks get executed when the class gets loaded into the memory and even before the creation of an object. Hence it will be executed before the main() method. And it will be executed only once.

37. What is the importance of static variable?

static variables are class level variables where all objects of the class refer to the same variable. If one object changes the value then the change gets reflected in all the objects.

38. Can we declare a static variable inside a method?

Static varaibles are class level variables and they can't be declared inside a method. If declared, the class will not compile.

39. What is an Abstract Class and what is it's purpose?

A Class which doesn't provide complete implementation is defined as an abstract class. Abstract classes enforce abstraction.

40. Can a abstract class be declared final?

Not possible. An abstract class without being inherited is of no use and hence will result in compile time error.

41. What is use of a abstract variable?

Variables can't be declared as abstract. only classes and methods can be declared as abstract.

42. Can you create an object of an abstract class?

Not possible. Abstract classes can't be instantiated.

43. Can a abstract class be defined without any abstract methods?

Yes it's possible. This is basically to avoid instance creation of the class.

44. Class C implements Interface I containing method m1 and m2 declarations. Class C has provided implementation for method m2. Can i create an object of Class C?

No not possible. Class C should provide implementation for all the methods in the Interface I. Since Class C didn't provide implementation for m1 method, it has to be declared as abstract. Abstract classes can't be instantiated.

45. Can a method inside a Interface be declared as final?

No not possible. Doing so will result in compilation error. public and abstract are the only applicable modifiers for method declaration in an interface.

46. Can an Interface implement another Interface?

Intefaces doesn't provide implementation hence a interface cannot implement another interface.

47. Can an Interface extend another Interface?

Yes an Interface can inherit another Interface, for that matter an Interface can extend more than one Interface.

48. Can a Class extend more than one Class?

Not possible. A Class can extend only one class but can implement any number of Interfaces.

49. Why is an Interface be able to extend more than one Interface but a Class can't extend more than one Class?

Basically Java doesn't allow multiple inheritance, so a Class is restricted to extend only one Class. But an Interface is a pure abstraction model and doesn't have inheritance hierarchy like classes(do remember that the base class of all classes is Object). So an Interface is allowed to extend more than one Interface.

50. Can an Interface be final?

Not possible. Doing so so will result in compilation error.

51. Can a class be defined inside an Interface?

Yes it's possible.

52. Can an Interface be defined inside a class?

Yes it's possible.

53. What is a Marker Interface?

An Interface which doesn't have any declaration inside but still enforces a mechanism.

54. Which object oriented Concept is achieved by using overloading and overriding?

Polymorphism.

Credit goes to https://www.facebook.com/pages/JAVA/87650365032

Sorting an XML Document

2010-05-30T20:00:00.018-07:00

Sorting an XML based on a date field.

I came across a need to sort an XML based on the date field.I have my code in Java, I could have done the sorting in the Java code via a collection sort easily.But that was not useful in my case. Also I used castor for marshalling the Java ojects into XML.So couldn't find a better way other than to sort the output XML from Castor.
Below is a skelton of my XML document. In Java code I have a list of Node1 objects and another list of Node2 objects.I need my XML to be sorted in ascending order of the date field, irrespective of Node1 or Node2.(there are other reasons why we have node1 and node 2 seperate)

<root>

<Node1>

</Node1>

<Node1>

</Node1>

<Node1>

</Node1>

<Node1>

</Node1>

<Node2>

</Node2>

<Node2>

</Node2>

<Node2>

</Node2>

<Node2>

</Node2>

</root>

Solution:-
Decided to go with XSLT sorting here, read XSLT will be good in performace as well..Here is how XSL looks like...

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:template match="root">
<xsl:copy>
<xsl:apply-templates>
   
<xsl:sort data-type="number" select="substring(date,7,4)"/>
   
<xsl:sort data-type="number" select="substring(date,1,2)"/>
   
<xsl:sort data-type="number" select="substring(date,4,2)"/>
</xsl:apply-templates>
</xsl:copy>
</xsl:template>
<xsl:template match="*">
<xsl:copy>
<xsl:apply-templates/>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>

Sorting with XSLT was pretty easy.Just use the xsl:sort. But there is no was to sort the dates directly so a little workaround was needed.XSLT used Xpath to travers through the XML and there are many useful built in functions in Xpath.

<xsl:template match="*">
<xsl:copy>
<xsl:apply-templates/>
</xsl:copy>
</xsl:template>

This above part of the XSLT is required to keep the format of the XML.And the Java code to transform goes as below. With couple of lines of code and above xsl file. I got an excellent way of sorting. We can do a lot many pretty cool stuffs with this.

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

public class SimpleTransform
{
   public static void main(String[] args)
   throws TransformerException, TransformerConfigurationException,
   FileNotFoundException, IOException
  {
   Transformer transformer = tFactory.newTransformer(new StreamSource("sort.xsl"));
   transformer.transform(new StreamSource("root.xml"), new StreamResult(new FileOutputStream("out.xml")));

   System.out.println("Done.................");
  }
}

XSLT : http://www.w3schools.com/xsl/