Who’s On Phirst

Official blog of Phurnace Software.

Category >> Phurnace Tips

Posted by: Pete Pickerill on

In our quest to better support AIX 5L V5.3 as both a server and client platform for Phurnace Deliver, we recently got a new piece of hardware, an IBM Power 520 Express. I am the one that usually sets up any new hardware, so the job of installing and configuring AIX fell to me. I soon found that AIX is a completely different animal than Linux. The majority of my previous *nix experience has been with Red Hat. Those of you with more Unix or AIX experience than I are probably laughing at my predicament. The more charitable among you (or those of you that also started in bash on Linux) may feel a pang of pity as you remember your first days trying to navigate the Korn shell. Where’s my auto-complete? Why isn’t the up key working? I can’t use the arrows to get to my typo? No wget? No vim? No samba? No sudo? My god…I can’t even SSH or SCP! Thankfully the good folks at IBM have provided a couple of downloadable content packs to ease the transition from Red Hat to AIX: The AIX Toolbox for Linux Applications and The IBM AIX Expansion Pack.

The IBM AIX Expansion Pack features a bunch of optional packages, most of which I didn’t need. I was able to find the following packages that have been very useful: OpenSSH & OpenSSL for AIX; several versions of the Java SDK for AIX (32-bit & 64-bit); Firefox 2.0 for AIX.

But The AIX Toolbox for Linux Applications made me feel like I had clicked together my little ruby Converse clad heels and said “There’s no Desktop like Gnome. There’s no Desktop like Gnome.” It was chock full of useful Linux applications, libraries, and utilities that made my transition to AIX much smoother. You can get a full alphabetical list here. This is where you’ll find things like wget, diffutils, alternative shells (hooray bash!), Gnome, vnc and a ton of other really useful stuff. So if you’re used to Linux and find yourself working in AIX, check out both offerings. It will save you a boat load of time.

In AIX
Comment (0) Read More...


Posted by: Casey Marshall on

At Phurnace I'm leveraging the Eclipse Modeling Framework (EMF) to streamline our development and add some exciting new features. EMF was difficult to get to know at first, if only because the modeling terminology seemed new, strange, and kind of dry. The time invested in learning EMF was well-spent; once I "got EMF", it seemed pure genius.

My initial impression of modeling and model-driven architecture was kind of comical too; I imagined (with great disdain) this self-proclaimed "enterprise architect" in an ivory tower, trying to solve all manner of problems by dragging UML diagrams around. "Of course 'real software development' is never so simple!", I'd think. Like so many other technologies, modeling is heavily diluted with enterprisey buzzwords, and there probably *are* architects in ivory towers somewhere trying to generate all their code from UML tools... but this is only a comical extreme of the modeling spectrum.

For example, consider the popular web framework Django. Django, like so many other of the dynamic-language web frameworks, provides an object-relational mapping library in which you first define... models in your application. These frameworks introspect on your definition of the models to generate parts of your web application automatically for you. "Scaffolding" in Rails, the "admin" interface and newforms in Django all demonstrate a "model-driven architecture".

As far as I'm concerned what EMF does for the Eclipse platform (or elsewhere -- EMF is not limited to the Eclipse platform) is conceptually no different. Just as Django dynamically generates forms and content based on the structure of your models, EMF can generate a UI for interacting with your models and much more. Knowing this simple fact would have helped me at a time I was struggling to learn Eclipse RCP and considering EMF; it was not entirely clear to me at first, as an outsider, what EMF exactly was, what it could do for me, and why I should use it. It would be silly and somewhat inaccurate for EMF documentation to say "EMF: It's kind of like ActiveRecord!", but in a way, that's how I've come to know & relate it.

Of course, EMF can do much more than a typical web framework's model layer. The tooling is highly adaptable to custom development workflow demands; you can customize your generated model code, or avoid code generation altogether. Models can be defined with Java code, XSD, Ecore, or dynamically at runtime. EMF brings a powerful level of introspection to modeling, since the definition of your model (Ecore) is itself a model that can be manipulated in the same way. In this respect, EMF is "turtles all the way down".

In other news, I'm looking forward to the upcoming Galileo release of Eclipse (Eclipse 3.5). I've already had a chance to try a few of the new features (native Cocoa & 64-bit Java support for OS X, improved PDE tooling) and it's looking great. Last week I became a Friend of Eclipse, a great chance to contribute back to a community that's given me so much -- plus I get early access to releases and an exclusive, blazing-fast download mirror.

In Eclipse Modeling FrameworkEclipseDjango
Comment (0) Read More...


Posted by: Robert Reeves on

A few weeks ago, whurley turned me onto Puppet. Puppet is a systems management framework that allows its users to concentrate on WHAT they want to accomplish and not HOW. Moreover, Puppet configurations can be applied over-and-over again without any concern.

Obviously, I'm a huge fan of this approach as this is what Phurnace Deliver does for your Application Servers. By allowing these configurations to be applied to your servers, regardless of state, you are no longer in the business of keeping track of the state of your servers. When in doubt, just run Puppet or Phurnace Deliver with the latest configuration and your server will be "caught up". Moreover, if you have a base image that is kept up-to-date, you can then redeploy your applications and configurations using a combination of Puppet and Phurnace Deliver. This frees you from having to patch your running instance. Simply fire up another copy of your base image, install the software and patches and deploy your Java application with Phurnace Deliver. Then, you can simply use the load balancer to move new sessions to the updated server.

With this approach you get so many benefits:
  • avoid downtime during updates
  • automatic disaster recovery without extra effort and
  • no more image sprawl and associated management hassles.


You can read more about this over at Luke Kanies' blog. He does a great job of describing this approach for handling virtual images or servers in the cloud.

In Puppet
Comment (2) Read More...


Posted by: Larry Warnock on

We had a discussion the other day with a very large bank and learned that they spend a huge amount of time and money on setting up test servers and fail-over servers, yet they have major problems assuring that the configurations match. In fact, they gave us an example of how their customer facing application dropped recently because their main site dropped and the fail over was not configured correctly. BAD. To keep this from happening again, they were planning to throw people at the problem. There is a better way.

It is now clear that Phurnace Deliver can also provide an “Agile Test Infrastructure” for higher test server utilization and dramatically lower costs.

The way it works is that large customers keep many different test environments to be responsive to test scenarios because it takes too long to configure a different environment required for a given test scenario that arises.

At the above mentioned bank, test server utilization is only 10%. To eliminate half of their test servers and the associated “hard dollar” hardware and software costs, Phurnace only needs to drive their utilization to 20%. The way Phurnace accomplishes this is by eliminating lesser used test servers and configuration environments and then by reconfiguring available servers to the required configuration on an as-needed basis.

Bottom line, Phurnace enables an “Agile Test Infrastructure” as well as enabling Agile Development.

In Agile Software Development
Comment (0) Read More...


Posted by: Robert Reeves on

The first time I installed IBM WebSphere XD, I was shocked. Right there, in the IBM Admin Console were the words "JBoss" and "WebLogic". What the heck is going on here?

The reality of Java Enterprise is that pretty much every company has multiple Java Application Server vendors. Typically, that is dictated by vendor solutions.

For example, our buddies at Zilliant (Hi, Chris and David!) make a pricing solution that runs on JBoss. When they go to implement the solution, they also provide the hardware and software. This makes perfect sense for them because they are able create a controlled environment for their application. And, it makes great sense for their customers because the Zilliant support team considers the entire stack part of their solution. That means, if there's a bug in JBoss, the Zilliant team will get a JBoss patch out to the customer.

Another example of a vendor dictated Application Server is some other friends of ours at Vignette (Hi, Brad!). Some Vignette products run on WebLogic. So when a customer purchases them from Vignette, they get WebLogic as part of the solution. And, like Zilliant, Vignette supports the WebLogic Application Server running underneath their products.

Of course, IBM is well aware of this. That's why they have created a mechanism to incorporate all of those disparate Application Servers into one place. XD will help you provide virtualization and health and resource management for applications that might have usage spikes, such as a payroll run on the last day of the month.

Lucky for you, Phurnace anticipated the same proliferation of Application Servers across the enterprise long ago. That's why we support them all: WebSphere (SA/ND/XD), WebLogic and JBoss (AS/EAP). So, using Phurnace Deliver and WebSphere XD is a perfect combination. Use XD to manage the resources and use Phurnace Deliver to manage the configuration. All in one place.

In Untagged 
Comment (0) Read More...


Posted by: Shawn Spiars on

Before we get started here are a couple of definitions that may help you understand this example.

  • A wizard is a series of pages that guide a user through a complex task.
  • JFace is a user interface framework that is used to handle many common UI programming tasks.

JFace provides all the user interface components needed to create a wizard for your application. Most of the time when designing a wizard you will know at design time how many pages are required to complete each step of your wizard. But on occasion you will run across a use case where you need to create pages dynamically based upon the user’s input from a previous page. Solving this problem with JFace is a little tricky, so I’ve created an example program demonstrating how to dynamically create wizard pages based upon the input from the first page. Give it a try and let me know what you think.


import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

/**
 * Example program demonstrating how to dynamically add pages to a JFace Wizard.
 *
 * @author Shawn Spiars 
 * 
 */ 
public class DynamicWizardPageExample {

      private static class MyWizard extends Wizard {
            public MyWizard() {
                  super();
                  setForcePreviousAndNextButtons(true);
            }

            public void addPages() {
                  addPage(new StartingWizardPage());
            }

            public boolean performFinish() {
                  return true;
            }

            @Override
            public IWizardPage getNextPage(IWizardPage page) {
                  IWizardPage nextPage = super.getNextPage(page);
                  
                  //TODO - create logic here to skip pages that you
                  //have added to the framework, but no longer wish to display
                  
                  return nextPage;
            }

      };

      private static class StartingWizardPage extends WizardPage {
            private Button firstPageButton;
            private Button secondPageButton;
            private Button thirdPageButton;

            protected StartingWizardPage() {
                  super("startingPage");
                  setTitle("Starting Page");
              setMessage("Select the desired pages and press the Next button.");
            }

            public void createControl(Composite parent) {
                  Composite composite = new Composite(parent, SWT.NONE);
              GridLayout layout = new GridLayout(1, false);
              layout.verticalSpacing = 12;
              composite.setLayout(layout);
              composite.setLayoutData(new GridData(GridData.FILL_BOTH));
              
              firstPageButton = new Button(composite, SWT.CHECK);
              firstPageButton.setText("Page One");
              firstPageButton.addSelectionListener(new SelectionAdapter() {
                        public void widgetSelected(SelectionEvent e) {
                              Wizard wizard = (Wizard) getWizard();
                              wizard.addPage(new MyWizardPage("Page One"));
                              getContainer().updateButtons();
                        }
                  });
              
              secondPageButton = new Button(composite, SWT.CHECK);
              secondPageButton.setText("Page Two");
              secondPageButton.addSelectionListener(new SelectionAdapter() {
                        public void widgetSelected(SelectionEvent e) {

                              Wizard wizard = (Wizard) getWizard();
                              wizard.addPage(new MyWizardPage("Page Two"));
                              getContainer().updateButtons();
                        }
                  });
              
              thirdPageButton = new Button(composite, SWT.CHECK);
              thirdPageButton.setText("Page Three");
              thirdPageButton.addSelectionListener(new SelectionAdapter() {
                        public void widgetSelected(SelectionEvent e) {
                              Wizard wizard = (Wizard) getWizard();
                              wizard.addPage(new MyWizardPage("Page Three"));
                              getContainer().updateButtons();
                        }
                  });
              
              setControl(composite);
            }
            
      }
      
      private static class MyWizardPage extends WizardPage {
            protected MyWizardPage(String pageName) {
                  super(pageName);
                  setTitle(pageName);
            }

            public void createControl(Composite parent) {
                  Composite composite = new Composite(parent, SWT.NONE);
                  setControl(composite);
            }
      }

      public static void main(String[] args) {
            Display display = new Display();

            final Shell shell = new Shell(display);
            shell.setLayout(new FillLayout());

            Button b = new Button(shell, SWT.PUSH);
            b.setText("Press here to open wizard");
            b.addSelectionListener(new SelectionAdapter() {
                  public void widgetSelected(SelectionEvent e) {
                        WizardDialog dialog = new WizardDialog(shell, new MyWizard());
                        dialog.open();
                  }
            });

            shell.open();

            while (!shell.isDisposed()) {
                  if (!display.readAndDispatch())
                        display.sleep();
            }

            display.dispose();
      }
}


For more information on JFace, check out these links:

In Untagged 
Comment (0) Read More...


Posted by: Ann Nguyen on

In the world of fast paced development, you are usually tasked to deliver some features in a very short turnaround time. Does this sound familiar to you? Especially if you are in an IT shop, you find yourself more and more like an assembler, you just integrate and connect software together for the final product, and you have to rely on tools of the 21st century.

I was given, or rather volunteered, to pull data from one web application to display on a client’s web application remotely. The web application that provided the necessary data used EJB for all its CRUD operations. Instead of reinventing the wheel, I added more methods to the stateless session bean to expose the data that I needed.

First step, with EJB 2.1:
Axis is the best tool for this that I have found. Axis is packaged as another web module into your application and exposes the EJB methods as a Web Service.

The Axis server-config.wsdd needs to define the Web Service.
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<service name="AdminService" provider="java:MSG">
<parameter name="allowedMethods" value="AdminService"/>
<parameter name="enableRemoteAdmin" value="false"/>
<parameter name="className" value="org.apache.axis.utils.Admin"/>
<namespace>http://xml.apache.org/axis/wsdd/</namespace>
<namespace>http://xml.apache.org/axis/wsdd/</namespace>
</service>
<service name="Version" provider="java:RPC">
<parameter name="allowedMethods" value="getVersion"/>
<parameter name="className" value="org.apache.axis.Version"/>
</service>
<service name="Verify" provider="java:RPC">
<parameter name="allowedMethods" value="getAxisVerification"/>
<parameter name="className" value="com.mycompany.dataserver.model.session.DataEJBService"/>
</service>
<handler name="URLMapper" type="java:org.apache.axis.handlers.http.URLMapper"/>
<transport name="http">
<requestFlow>
<handler type="URLMapper"/>
</requestFlow>
</transport>
<service name="DataByPersonId" provider="java:EJB">
<parameter name="scope" value="application"/>
<parameter name="beanJndiName" value="java:comp/env/DataEJB"/>
<parameter name="homeInterfaceName" value="com.mycompany.dataserver.model.session.DataEJBLocal"/>
<parameter name="remoteInterfaceName" value="com.mycompany.dataserver.model.session.DataEJBLocal"/>
<parameter name="allowedMethods" value="getDataByPersonId,getDataByOrgId,getDataIDsByOrgId"/>
<parameter name="className" value="com.mycompany.dataserver.model.session.DataEJBBean"/>
<beanMapping xmlns:ns="urn:DataByPersonId.session.model.dataserver.mycompany.com" qname="ns:DataWsDTO"
languageSpecificType="java:com.mycompany.dataserver.model.datatransferobject.DataWsDTO"/>
</service>
</deployment>

Since the EJB did not support the remote interface, the web.xml for the Axis servlet needs to define the reference to the session bean.
    <ejb-local-ref>
<ejb-ref-name>DataEJB</ejb-ref-name>
<ejb-ref-type>Session</ejb-ref-type>
<local>com.mycompany.dataserver.model.session.DataEJBLocal</local>
<ejb-link>ListingsEJB</ejb-link>
</ejb-local-ref>

First step, with EJB 3:
Life is much easier with EJB 3. One just has to use some dependency injection keywords.

The DataEJBBean file:

@WebService(endpointInterface="com.mycompany.dataserver.model.session.DataEJBRemote",targetNamespace="...")
@Stateless(name="DataEJB")
@Remote(DataEJBRemote.class)
@TransactionManagement(TransactionManagementType.CONTAINER)
@Resource(name="jdbc/MyCompanyDataServerDS", type=javax.sql.DataSource.class)
@Deployment(contextPath="data-ejb")
public class DataEJBBean implements DataEJBLocal, DataEJBRemote {

@WebMethod(operationName="featuredData")
@TransactionAttribute (TransactionAttributeType.SUPPORTS)
public DataWsDTO[] getDataByPersonId(Integer personId) {
.
.
.
}

@WebMethod(operationName="featuredData")
@TransactionAttribute (TransactionAttributeType.SUPPORTS)
public String getDataIDsByOrgId(Integer orgId) {
.
.
.
}


@WebMethod(operationName="featuredData")
@TransactionAttribute (TransactionAttributeType.SUPPORTS)
public ListingWsDTO[] getDataByOrgId(Integer orgId) {
.
.
.
}

.
.
.

}
The DataEJBRemote file:


@WebService
public interface DataEJBRemote extends Remote {
@WebMethod
public DataWsDTO[] getDataByPersonId(Integer personId) throws java.rmi.RemoteException;

@WebMethod
public String getDataIDsByOrgId(Integer orgId) throws java.rmi.RemoteException;

@WebMethod
public DataWsDTO[] getDataByOrgId(Integer orgId) throws java.rmi.RemoteException;
}


For EJB 3 at this stage of the game, I would support the remote interface, especially for the Web Services features.

We are all familiar with the software life cycle story, the PM for that container release probably only schedules mainstream use cases into these earlier releases. If you like pain, and you do have the time, you can venture out more.

Second Step, obtaining the WSDL for the Web Service:
If you use Axis, you can use the ant task Java2WSDL to obtain the WSDL. You can also invoke the URL of your web service with "?wsdl" at the end to obtain the WSDL.

Third Step, generate the client stubs for the web service consumer:

I used Axis for this and generated the client stubs from the WSDL obtained in the second step. The client stubs will need to be package into the consumer web applications.

If you are like me, we all have to support the different staging steps: development, QA, and production. Each of the machines for these are different for both the server and the consumers and we only want to move the same ear through these steps of staging.

In the ...SoapBindingStub.java file that is generated by Axis, I modified the static method to pull the Web Service namespace from a properties file. The property file for development, QA, and production will need to reflect its environments.

public static String getDataWebServiceNamespace() {
return FileUtils.getDataWebServiceUrl();
}


Everywhere that the Web Service namespace is needed, use this method to obtain it.

Fourth Step, deployment night:
Deployment night is scheduled late in the evening. Most IT shops do this. After all of the work, the frustration, the hair pulling and frantic reading into Open Source documentation like Axis (we all just LOVE Open Source documentation...), it DID NOT work in the production environment.

So you are now troubleshooting late into the night and the whole deployment team is weary and tempers flare easily.

The deployment system admin person did not move the correct property file into the production environment. Well, it is not their fault totally, you did not spell out exactly what files need to move to where clear enough in the manual deployment instructions.

This is why you need to look into Phurnace Deliver, especially the upload file functionality. It will save you so much time - your time, not machine time, from erroneous manual mistakes.

In Untagged 
Comment (0) Read More...


Posted by: Daniel Nelson on

So, as I am sure any reader of this is aware, agile programming methodologies (like Extreme Programming (which for some reason is called XP, not EP)) are all the rage nowadays. Seems like everyone is doing it, from small scrappy ones (ahem) to giant behemoths. Personally, I’m a big fan. Sure, it’s no silver bullet, but it beats the crap out of the age old waterfall projects I worked on back in the day.

Here at Phurnace we try to be agile. We do mostly 4 week iterations, which typically include 1 week of planning and 3 weeks of “doing.” All told, it works pretty well. One thing that we do a bit differently than any other place I work at though is how we approach scheduling – which, shocking, is the subject of this entry. Using this scheduling methodology we have hit the date for 20 of our 23 iterations. Once we were a day early, and twice we were a day late. Personally, I think that’s pretty awesome.

Here’s how we approach scheduling. For those interested, this approach is based in larger part upon work done by Dr. Eliyahu M. Goldratt and his Theory of Constraints (TOC) and Critical Chain Methodology. That, in turn, is also largely based on operations theory and the Central Limit Theorem. We don’t slavishly follow Dr. Goldratt’s methodology, but we borrow heavily from it (so credit where it is due). If you are interested, read Dr. Goldratt’s book The Goal for an intro to the TOC and Critical Chain for more depth on the Critical Chain Method.

Now that you are suitably impressed by my ability to hyperlink, let’s get into some specifics:

Because we are good and agile, all our planning starts with a customer story. You know the drill – “The customer should be able to something when they something in order to accomplish something else.” Stories for the most part come from products land, but anyone can write one. Well, except sales. We tried that once. Let’s just say boundaries are there for a reason. We use Xplanner to organize our stories.

So, at the beginning of the iteration we sit down and figure out what stories we would like to work. We always choose too many stories, but the temptation to “add just one more” is too much to resist. We also prioritize the stories, and try to build one to three central “themes” of the iteration. But once we have the stories selected we present them to Dev. Dev has a week to estimate and plan how to get those stories done.

The thing about estimating development (coding, testing, etc.) work that’s hard is that for the most part you have never done the task to be scheduled before. I mean, sure, you have developed software before; but, you have never developed this software before. If you had, you wouldn’t need to schedule it, right? It would be done already. So, for the most part software estimates are swags – best guesses. Sure, you can do research to improve the swag, but basically it’s still going to have a lot of uncertainty. And it’s that uncertainty that creates one of the big problems with how software tasks are scheduled.

Let me take you through the process that I am used to in a software shop. It goes kind of like this:

Product Manager: “Hey guys! I am super pumped about this next release! This time we are going to add support for 3 new platforms, and also add 2 new UI elements, and fix those 3 critical bugs we shipped with on the last release. So – how long do you think that will all take?”

Developers (thinking): 10 weeks. (This means they think 7 weeks, and give themselves a 40% “fudge factor.”)

Product Manager: Ok. (This means he is planning for 15 weeks, since projects are never on time.)

What’s going on here? The interesting thing is everyone involved is calculating risk, but no one is actually quantifying it. The only thing they are quantifying is an “expected” date – but there’s no analysis as to the underlying risks.

The good news is there are lots of ways to assess risk in estimates. PERT is a good one – and we are going to use a part of PERT to calculate the risk of each task. But PERT has some limitations that we are going to try to jump over. Realize, what we are doing by calculating risk is actually building a probability distribution of the likely completion times of each task.

In Part Two of this series we will go through the exercise of calculating “risk” in software projects, and give a real world example from Phurnace to see how we do it. In Part Three we will take that example and build a schedule that takes into account both actual completion dates as well as the riskiness of the tasks.

In Untagged 
Comment (0) Read More...


Posted by: Cynthia Sadler on

Installation testing on Windows can be a chore if you don't know what your application under test does to the system. In addition to laying down files in the "Program Files" directory (or a user specified directory), a Windows application will typically put installation files in a temporary directory. It might also install DLLs in the Windows directory, or create or update entries in the registry. Knowing what an application's installation does to your system is especially important when you get to testing the uninstallation. Fortunately for those of us in the software testing profession, there is a handy utility called RegShot.

The first thing we want to do is start with a fresh Windows system that has never had the application installed on it. (This is where Ghost or VMWare is extremely useful in your test lab, by the way.) Install RegShot. I used version 1.8.2. Start RegShot and set your Scan Dir if you want to scan the hard drive in addition to the registry. Now select "1st shot". You will get a context menu with Shot, Shot and Save, and Load. I choose Shot and Save, as this will save a registry hive file that can be loaded at a later time.


When it is finished scanning, you will be prompted to save your hive file. We are done with the first stage.

Now we install our application that we are testing. After installation is complete, select 2nd Shot. When it is finished, save the second shot. Now you can compare the two by selecting compare. You will then be presented with a report that tells you what registry keys and values have been added, modified and deleted. The report will tell you similarly for folders and files if you chose that option.


If you want to test uninstallation, click the Clear button. Then load your second shot with the 1st shot button. Uninstall your application. Then make a third shot with the 2nd shot button, and compare the two.

In Untagged 
Comment (0) Read More...


Posted by: Jessica Gass on

Are You Tired of Having to Troubleshoot One Server at a Time?
Are you making necessary updates in a serial fashion? Phurnace Deliver™ can perform multiple Snapshots and Updates at once. So, you can Snapshot and Update all of your Application Servers at the same time. Let’s hear it for multi-threaded applications!

Need to Troubleshoot Application Server Configuration Problems?
How can Phurnace Deliver™ help troubleshoot my application server configuration problems?

Use Deliver to take baseline Snapshots of your “trouble free” application server configurations. Then when problems occur use Phurnace Deliver's™ “Compare Configurations” feature to quickly view all changes between the baseline Snapshot and the current configuration.

For example, your problem configuration might show parameter values that have been changed or a new application that has been deployed on the server. Once you have determined the problem Phurnace Deliver's™ “Install” feature can quickly apply the necessary changes to your application server.

Enhancing your Virtualization Initiative
The Virtualization trend is being driven by hardware cost savings and the reduction of time spent on setting up and managing applications. With Phurnace Deliver™, we help you take your virtualization to the next level.

With Virtualization today you are required to have a library of server images that you bring up and down depending on the changing demands in your organization. Perhaps during peak times you have more of the transaction processing servers online, but at night it is better to have more servers working on batch jobs. With virtualization you are able to have much higher utilization of your infrastructure, therefore saving you money on the management and time spent on server provisioning.

Phurnace Deliver™ takes those same value propositions and brings them to the application layer. With Phurnace Deliver™ you can dynamically allocate applications to the up and running app servers as well as automate the set up of cluster size, memory allocation, or hundreds of other parameters. Now with Phurnace Deliver™, you can dynamically take applications off of a cluster to free up resources for more important applications and then bring them back online after the peak load time has passed.

A common use case example:
Imagine that Denise is responsible for a medium sized server environment of 100 application server JVMs. On those JVMs are 30 applications, running in a variety of topologies. At peak load times there are 5 applications that are critically important. Denise would like a way to dynamically add server capacity to those applications. Right now Denise could manually add and delete applications from the various clusters, but doing that is very time consuming and error-prone. The environment most likely is complex, with a series of virtual server images with the applications deployed with an array of different configurations -- but with that number of applications and servers, it is too resource intensive to build a server image of every permutation. Denise can’t feasibly take full advantage of the virtualization.

With Phurnace Deliver™ the story is fundamentally different. With Phurnace Deliver™, Denise can decide to add or delete an application from a cluster on the fly and have all of the changes take place in real-time; no server down time and executed in an entirely automated process. This allows her to scale the capacity of her applications up and down depending on the resource demand: making better use of her servers and delivering improved overall performance. Now, that is the true promise of virtualization. Don’t go only half way, extend the benefits of virtualization all the way to the application layer – with Phurnace Deliver™.

Secure Your Phurnace Deliver™ Artifacts
How can I use my source control system to secure my Phurnace Deliver™ artifacts?

 

  • Within the “Deliver Navigator” view right-mouse click on your project and select “Team” and then “Share Project…” from the popup menus.

  • From the “Share Project” wizard select either “SVN” or “CVS” to specify your source control system. Press the NEXT button.

  • Enter the URL and credentials required to connect to your source control system. Press the FINISH button and your project along with all your snapshots and server profiles will be saved and versioned within your source control system.


WebSphere Process Server headaches?
Phurnace Deliver™ can help you manage your WebSphere Process Server too. Just use the Template="defaultProcessServer" attribute for your Server's elements when creating them.  Phurnace Deliver™ can help you manage any application based on WebSphere, including WebSphere Process Server and WebSphere Portal Server.  Check the "About" section in the Admin Console to determine which version of WebSphere you are targeting.

WebLogic Application Versioning
Tired of having to guess what versions of what applications you have installed on WebLogic? Try attaching version numbers and a pointer to the person who made the changes to the "Description" attribute on each object as you deploy them to make sure that you keep you environments in sync.

In WebSphereWebLogicVirtualizationtroubleshootConfiguration
Comment (0) Read More...


<< Start < Prev 1 2 Next > End >>