Computer world

What is Oracle Maximum Availability Architecture?

2008-01-27T17:38:00.000-08:00

Oracle Maximum Availability Architecture (MAA) is Oracle's best practices blueprint based on proven Oracle high availability technologies and recommendations. The goal of MAA is to achieve the optimal high availability architecture at the lowest cost and complexity.

MAA defines HA best practices for a comprehensive set of Oracle products - Oracle Database, Oracle Application Server, Oracle Applications and Grid Control.
MAA considers various business SLAs to make these best practices as widely applicable as possible.
MAA leverages database grid servers with commodity servers and storage grid with resilient low cost storage to provide highly resilient, lower cost infrastructure.
MAA evolves with new Oracle versions and features.
MAA is hardware and OS independent.

MAA Demonstrations

MAA demonstrations quickly illustrate the unique levels of high availability, data protection and enhanced quality of service provided by the Oracle Maximum Availability Architecture.

MAA Best Practice Publications

MAA publications consist of a series of architectural, configuration and operational HA best practice blueprints using Oracle technologies. For example, the following diagram represents an HA architecture involving the Oracle Database and Oracle Application Server.

Example of an HA Configuration using MAA Best Practices

This architecture involves identically configured primary and secondary sites. The primary site contains multiple application servers and a production database using Oracle Real Application Clusters (RAC) to protect from host and instance failures. The secondary site also contains similarly configured application servers, and a physical standby database kept synchronized with the primary database by Oracle Data Guard. Clients are initially routed to the primary site. If a severe outage affects the primary site, Data Guard quickly fails over the production database role to the standby database, after which clients are directed to the new primary database to resume processing. The Active Data Guard Option with Real-Time Query (Oracle Database 11g) enables the physical standby database to be open-read only while apply is active; enhancing primary database performance by offloading overhead from ad-hoc queries and reporting to the synchronized standby database at the secondary site.

The various HA best practice publications are grouped under the following categories:

THE FACTORY PATTERN

2007-12-04T19:22:00.000-08:00

One type of pattern that we see again and again in OO programs is the
Factory pattern or class. A Factory pattern is one that returns an instance of
one of several possible classes depending on the data provided to it. Usually
all of the classes it returns have a common parent class and common methods,
but each of them performs a task differently and is optimized for different
kinds of data.

How a Factory Works

Sample Code
Let's consider a simple case where we could use a Factory class. Suppose we
have an entry form and we want to allow the user to enter his name either as
“firstname lastname” or as “lastname, firstname”. We’ll make the further
simplifying assumption that we will always be able to decide the name order
by whether there is a comma between the last and first name.
3
This is a pretty simple sort of decision to make, and you could make it with a
simple if statement in a single class, but let’s use it here to illustrate how a
factory works and what it can produce. We’ll start by defining a simple base
class that takes a String and splits it (somehow) into two names:

class Namer {
//a simple class to take a string apart into two names
protected String last; //store last name here
protected String first; //store first name here
public String getFirst() {
return first; //return first name
}
public String getLast() {
return last; //return last name
}
}

In this base class we don’t actually do anything, but we do provide
implementations of the getFirst and getLast methods. We’ll store the split
first and last names in the Strings first and last, and, since the derived classes
will need access to these variables, we’ll make them protected.
The Two Derived Classes
Now we can write two very simple derived classes that split the name into
two parts in the constructor. In the FirstFirst class, we assume that everything
before the last space is part of the first name:

class FirstFirst extends Namer { //split first last
public FirstFirst(String s) {
int i = s.lastIndexOf(" "); //find sep space
if (i > 0) {
//left is first name
first = s.substring(0, i).trim();
//right is last name
last =s.substring(i+1).trim();
}
else {
first = “”; // put all in last name
last = s; // if no space
}
}
}

And, in the LastFirst class, we assume that a comma delimits the last name.
In both classes, we also provide error recovery in case the space or comma
does not exist.

class LastFirst extends Namer { //split last, first
public LastFirst(String s) {
int i = s.indexOf(","); //find comma
if (i > 0) {
//left is last name
last = s.substring(0, i).trim();
//right is first name
first = s.substring(i + 1).trim();
}
else {
last = s; // put all in last name
first = ""; // if no comma
}
}
}

Building the Factory
Now our Factory class is extremely simple. We just test for the existence of a
comma and then return an instance of one class or the other:

class NameFactory {
//returns an instance of LastFirst or FirstFirst
//depending on whether a comma is found
public Namer getNamer(String entry) {
int i = entry.indexOf(","); //comma determines name
order
if (i>0)
return new LastFirst(entry); //return one class
else
return new FirstFirst(entry); //or the other
}
}

Using the Factory

You type in a name and then click on the Compute button, and the divided
name appears in the text fields below. The crux of this program is the
compute method that fetches the text, obtains an instance of a Namer class
and displays the results.
In our constructor for the program, we initialize an instance of the factory
class with

NameFactory nfactory = new NameFactory();

Then, when we process the button action event, we call the computeName
method, which calls the getNamer factory method and then calls the first and
last name methods of the class instance it returns:

private void computeName() {
//send the text to the factory and get a class back
namer = nfactory.getNamer(entryField.getText());
//compute the first and last names
//using the returned class
txFirstName.setText(namer.getFirst());
txLastName.setText(namer.getLast());
}

And that’s the fundamental principle of Factory patterns. You create an
abstraction which decides which of several possible classes to return and
returns one. Then you call the methods of that class instance without ever
knowing which derived class you are actually using. This approach keeps the
issues of data dependence separated from the classes’ useful methods. You
will find the complete code for Namer.java

Simple MP3 Player for Pocket PC

2007-11-01T11:01:00.000-07:00

When I was asked to create an audio guide based on Pocket PC technology and MP3 sound tracks, I had no clue where to go and how to achieve this. So, I went for a little net-surfing and what I found was a neat library: FMOD Sound System from Firelight Technologies. They propose a more-than-complete set of functions, enabling you to create just about any sound recording/playing application, for desktops and Pocket PCs. You can read more about it here. Download the API and see for yourself! (You're just another WinAmp away...)

For my system, I needed of course, a CE version of their DLL. If you are developing in C++ for CE then it's all right. If you are coding in .NET, then start the troubles.

Without even going into the definitions, one could realize at least the difficulties of communicating from managed code to unmanaged code. Actually it's the opposite way around that gives you headaches. On Pocket PCs, as well as normal desktop apps, it is possible to directly call a DLL function right from the .NET code, using the correct DLLImport attributes, like in this example

Talking back is much harder, especially when it can occur any time, i.e. with event firing. I must admit that I have not succeeded in having the fmodce.dll talk back to my .NET CF app. This is a shame because it would allow the application to get event callbacks from that DLL, thus enabling the application to control the stream even more. A number of good coders on FMOD's forum have posted some hints, but none of them helped me out. The only event I was asking for, in this simple app was the "End of track" event. Well, I finally worked around this problem, which you can read later on.

Download project here

Compact Framework version

Some good CodeProject contributors pointed out that my code wasn't working on Compact Framework 2.0. This behavior has nothing to do with FMOD's library, but that is due to a bug in .NET CF 1.0. In my code, I use a condense of what I could find on the net, to get a pointer to the stream

What you need to know is that, in .NET CF 1.0, the function AddrOfPinnedObject does not return the address of the pinned object, but the address is shifted by 4 bytes, which corresponds to the size of the pointer itself. So to retrieve the correct address, you must point 4 bytes further! Look in the net for the AddrOfPinnedObject function and you'll get plenty of details. This workaround is not necessary in .NET CF 2.0 because the bug has been fixed in this version, so our bug-fix needs to be conditional. One more thing: the bug fix mentioned above is not a good bug-fix in fact, because although .NET CF 2.0 doesn't have this problem anymore, it might be solved as well in later releases of .NET CF 1.x (as Service Packs). Should this happen, the code above wouldn't work anymore. The only good way then, would be to allocate the needed memory yourself, and create your own pointer to that chunk of memory, as shown here (MSDN site) (par. 6.14). So the perfect way - free from version check - would be.