Free websphere software for linux

Bugzero is a web-based bug tracking, defect tracking, issue tracking, and change management system used in a distributed team environment to track software bugs, hardware defects, test cases, or any other issues. Bugzero can also be used equally well as a helpdesk customer support, trouble ticketing, or email management system to collect and manage customer feedbacks, incidents, requests, and issues.
Bugzero provides a cost-effective enterprise-grade solution to increase team work efficiency. It is easy to use, but still flexible and adaptive, and can be configured to fit to your organizations unique business process and workflow. Bugzero empowers you and puts you in full control, and allows you to accomplish your tasks in the best way possible.
Main features:
- Open standards technology, web-based, lightweight, feature-rich, robust, fast, reliable, and a high level of usability
- No client software, no firewall issues, and accessible from anywhere on the internet through HTTP or SMTP
- Support both web interface and email interface (particularly for customer support), for internal and external users
- Single system with one code base, minimal system requirements and maintenance, easy install (server side only)
- Operating system independent, based on Java and J2EE, truely run anywhere and everywhere
- Cross database systems, based on standard SQL 92, fully open, scalable, and modular database schema
- More than just bug tracking, works equally well as a help desk customer support system
- Support custom fields of data types including datetime, number, URL, and link ID. Fields can be added or removed anytime.
- Configurable page layout, company logo, and look and feel
- Support multiple projects, configurable access control, and self registration
- Configurable advanced group and field level access control model (security)
- Completely configurable and customizable workflow (defect tracking lifecycle)
- Configurable automatic and manual bug-assignment
- File attachment (can attach multiple files and any kinds of files at once)
- Email notification and cc mail (per project, template based)
- Configurable email notification triggers or listeners (per project, per user)
- CVS and Perforce source version control integration through email
- Metrics reports, advanced search, and re-usable stored queries
- Comprehensive readable bug-audit trail (change history)
- Quick sorting and CSV file export supporting Asian languages in Unicode
- Public projects and self registration for open source projects
- Support internationalization with Unicode (UTF-8)
- Support LDAP/Active Directory user authentcation (available as add-on)
- Custom email reminder and escalation (available as add-on)
- Easy to use web-based system administration (no learning curve)
- Exceptional remote trouble shooting and debugging capabilities
Version restrictions:
- Hardware: PC, Mac, Sun, or IBM Servers, more
- OS: Windows, Unix, Linux, or Mac OS, more
- Server Database: Oracle, DB2, SQL Server, Sybase, MySQL, PosgreSQL, or Access, more
- Server Software: JDK1.3+ and a Java application server such as Tomcat, WebLogic, WebSphere, more
- Client Software: MSIE, Mozilla, FireFox, Opera, or Netscape, more
Enhancements:
- The two issues when upgrading using Sybase, an error in "DROP PRIMARY KEY", and the need to set "ddl in tran" to true for the tempdb have been fixed.
- A JSP compile error in help.jsp with IBM WAS was fixed.
- Email parsing for field name was improved. The users drop-down fields are now filtered if the login user is in a controlled user group, and only users in the same group are listed.

SimpleJTA implements a standalone JTA compliant Transaction Manager. SimpleJTA project is primarily designed to be used when a J2EE server is not available, for example, in Servlet applications, or standalone Java programs.
SimpleJTA is being developed and tested with Oracle 9i and Apache Derby database management systems. It is fairly easy to add support for other database systems that support the XA interface.
Main features:
- SimpleJTA does not require a J2EE or Servlet container. It provides an implementation of UserTransaction interface so that an application using SimpleJTA can easily switch to another JTA implementation.
- SimpleJTA implements a transaction log to enable recovery after system crashes.
- Distributed transaction propagation between multiple application servers is not supported. There is no support for JTS.
- SimpleJTA implements the UserTransaction, Transaction and TransactionManager interfaces. The Transaction and TransactionManager interfaces have not been tested extensively.
- SimpleJTA provides its own JDBC datasources for Oracle and Derby. It is easy to add support for other database systems.
- SimpleJTA JDBC datasources and UserTransaction implementation can be registered to JNDI, but this has not been tested yet.
- There is experimental support for two JMS providers - Websphere MQ and Oracle AQ.
- SimpleJTA can be used within a Spring Framework managed application.
Enhancements:
- Added spring-dao to the list of dependencies in pom.xml.
- Added TransactionManager interface to SimpleUserTransaction.
- Added SpringTransactionManager bean definition to testConfig.xml.
- Fixed problems reported by FindBugs (4 defects remaining).
- Added very basic test case for ActiveMQ.
- Fixed incorrect classname in ActiveMQJMSConnectionFactoryAdaptor.

OpenXava project is a framework to develop easily business applications with XML and Java.
OpenXava Eclipse Plugin provides a database reverse engineering utility for the OpenXava framework.
Its virtue resides in the fact that the heart of our applications is XML instead of Java.
Main features:
- Has been used during years to develop real applications.
- High productivity for developing business applications.
- Short learning curve and easy to use.
- Flexible enough to create sophisticated applications.
- Its possible to insert your own functionality in every place.
- Based in the concept of business component.
- Adapted to work with legacy database schemas.
- Generate a full J2EE application: including User Interface and model classes (with POJOs or EJBs)
- Supports WebSphere 6.0, 5.1 and 5.0, JBoss 4.0.x and 3.2.x using native EJB CMP2 EntityBeans.
- Supports any application server (Tomcat, JBoss, WebSphere, etc) using POJOs + Hibernate.
- Supports JSR-168: All OpenXava modules are standard portlets too.
- EJB3 JPA complete support: But still BETA until 2.1
- Its tested with the portals: JetSpeed 2, WebSphere Portal and Liferay.
- Easy integration of reports made with JasperReports.
- Some little support for aspects.
- Licensed under LGPL.
- The developer can use English or Spanish.
- All labels and messages are in English, Spanish, German, Indonesian, French and Catalan, with more coming.
Enhancements:
- This is the first version, and it includes support for connecting to a database to retrieve metadata from Eclipse, full customization for generated code, and support for advanced mapping features.

JProfiler is an award-winning all-in-one Java profiler. JProfilers intuitive GUI helps you find performance bottlenecks, pin down memory leaks and resolve threading issues.
Even though JProfiler has a powerful feature set, its a Java profiler that is extremely easy to use! JProfilers user interface provides a unified view on the profiled application and puts all the information you need right at your fingertips with its intuitive hierarchy of views.
Configure your application for profiling
When starting up JProfiler, the start center is brought up. Here you can manage and start your profiling sessions. To configure your application for profiling, change to the "New session" tab and click on the New session button. Enter the required information into the session config dialog as described below and select Ok to start profiling. Thats all it takes. Note the Help button which appears on all of JProfilers dialogs displays a context sensitive explanation of all features.
While the configuration dialog displays numerous options that you will not want to miss after becoming familiar with JProfiler, entering the basic pieces of information is really very simple:
1. Enter a name for your session.
2. Enter the name of your main class.
3. Enter your class path.
4. Press Ok.
Before profiling is actually started, the profiling settings dialog is displayed where you can select the focus for your profiling run. Although profiling produces an overhead when running your application, you can minimize it by choosing a setting for which JProfiler only records information that is interesting for you.
If you want to fine-tune your profiling settings, the [Edit] button brings up a dialog with all available configuration options for profiling.
Observe classes and allocations
To find out what is going on the heap in terms of objects and classes, turn to the classes monitor. It gives you continuous updates and lets you set marks to observe changes over time. To see references, allocations and object data for your selection, you can take a snapshot by clicking on the camera in JProfilers toolbar.
If you want to know where your objects are allocated, you can go to the allocation monitor. Here, you can inspect the call tree and find out what method calls have caused the allocation of a selected class or package. Just like in the allocation monitor, you can display this data for live and garbage collected objects.
An cumulated overview on which methods are responsible for allocations is given by the allocation hot spots view. Each hot spot can be expanded and the backtraces that lead to the invocation of the hot spot are displayed. You can also mark the current values and view the differences in allocations over time.
Find memory leaks
JProfilers heap walker works like a browser: it displays a current set of objects that can be changed by adding selection steps with the [Use selected] button. You can inspect the current object set in the four views of the heap walker.
In the classes view, you can select one or several classes and add a selection step. The new object set will contain only the selected instances. This is often the first thing you want to do after taking a snapshot. You can perform this step automatically by invoking the heap walker from the classes monitor.
The allocations view of the heap walker shows the allocation tree and the allocation hot spot list of the current object set. You can add a selection step for one or multiple allocation spots or hot spots. The new object set will then be restricted to the selected instances only.
When youre looking for the cause of a memory leak, the reference view is the most important view in JProfiler. Here, you can find out why an object has not been garbage collected. Use the "Show path to GC root" function to show where the JVM hangs on to the selected instance.
Not only is the heap walker your first stop for finding memory leaks, it also makes for an excellent debugging facility. In the data view, you can inspect instances, arrays and classes in the current object set and navigate along references. There are many situations where the usual debugging approach will fail and JProfiler will help you find out.
Zoom in on performance bottlenecks
Controlling your applications performance may be driven by quality of service constraints or by general quality assurance, JProfilers CPU views lend themselves naturally to both approaches.
To record CPU data, you switch to the CPU section and click on the recording button in JProfilers tool bar. The first view in the CPU section shows the invocation tree, cumulated for all threads. To find performance related problem spots, just follow the big percentages when opening the tree nodes. Also, the absolute times and the number of invocations that are displayed for each node can help you in getting a feeling for the situation. Once you become familiar with JProfiler, you may want to customize this view to best fit your personal preferences.
The invocation tree is a top-down view on the method calls of your application. This viewpoint is most useful when you experience an actual performance bottleneck in your application. If you want to improve overall performance, a bottom-up view may be more applicable.
This kind of view - called hot spots view - shows the methods where most of the time is spent. By opening these nodes you get backtraces which show the various invocation paths together with the percentages of their contributions. Note that by default, method calls within Java core classes are not shown separately - each of your library calls is treated as opaque. You can change this behavior by deactivating the corresponding filter sets.
The method graph combines both viewpoints. Incoming and outgoing method calls are presented in the same way. For a number of situations, the method graph can give you more insight than the invocation tree and the hot spots view. The best strategy is to use the invocation and hot spots views first and switch to the method graph for detailed analysis.
Solve thread-related problems
Threads can be exceptionally difficult to debug, especially if you dont have sufficient information on the actual sequence and status of the threads in your application. JProfilers thread views provide you with exactly this knowledge.
The thread history view shows a continuous update of the lifelines of all threads on the horizontal axis. The names of the threads are displayed on the vertical axis in the order of their creation. Each color signifies a different thread status. Orange means that the thread was sleeping, green stands for a runnable thread while red is displayed if the thread was waiting for a monitor. You can zoom in and out to your desired detail level or have the time axis fit your windows size automatically.
If youre more interested in whats happening right now, the thread monitor view is the right place to look at. Here, you can sort threads, filter with respect to thread status and view additional information on each thread.
Should you ever have a deadlock in your application, the deadlock detection graph will help you analyze the involved threads and the locking situation. Simple deadlocks like the one shown could be worked out by hand from the other views, but for complicated deadlock involving a greater number of threads this view is indispensable.
Reducing general monitor contention and debugging locking sequences requires a detailed view of the current monitor usage and a history of all monitor-related events. JProfiler has both. Below you see the monitor usage history which shows a blocking event together with the stack trace of the waiting thread.
Keep an eye on your JVM
Monitoring cumulative parameters of the virtual machine can be a highly fruitful activity, even if everything seems to be all right. Measuring and observing parameters like heap size, object count, loaded classes and thread numbers can point to dangerous trends and problematic behavior to look out for. In its VM telemetry view section, JProfiler features various telemetry controls which provide you with the information you need to stay one step ahead.
The number of objects on the heap, split in arrays and non-arrays. This is your first stop if you are suspecting a memory leak. All objects with live references are included, as well as those which are unreferenced but the garbage collector hasnt had a chance to collect yet.
The garbage collector activity which displays freed and moved objects. If your application is thrashing the heap excessively, this will show up here. Moving large numbers of objects places a high burden on the virtual machine and can lead to temporary freezes. Mostly this occurs when the virtual machine is enlarging the heap.
The number of threads in the virtual machine, split in active and inactive threads. This is useful if you create a large number of threads and need information on changes in their total number and how many of them actually run.
Enhancements:
- New futures:
- rewritten eclipse 3.x integration
- rewritten IDEA 4.x integration
- IDE integration for JDeveloper
- IDE integration for Netbeans 4.0
- considerably reduced memory consumption
- improved long-term stability for profiling
- heap walker: in the cumulated incoming reference view, reference holders as well as referenced objects can be displayed and selected
- option to keep the profiled JVM alive
- support for Java Web Start 1.5
- CSV export for graphs
- enhancements in XML export for trees
- integration wizard for profiling servers in IBM WSAD
- integration wizards for Pramati 3.5 and Pramati 4.x application server
- integration wizard for Websphere 4.0 Advanced Edition
- integration wizard for Sun Java System Web Server
- integration wizard for Sun Java System Application Server
- integration wizard for Oracle 10g Application server
- integration wizard for Apple WebObjects Developer 5.x
- snapshot files (*.jps) can be opened from the command line and from the Windows explorer
- JBuilder IDE integration now supports JBuilder 2005
- much better appearance of the JProfiler GUI with Windows native look and feel
- JProfiler GUI now also runs under Java 1.5
- Bug fixes:
- monitor statistics were broken
- invalid class files caused a shutdown of the profiled application
- many bug fixes in the GUI

Mule is the leading open source ESB (Enterprise Service Bus) and integration platform. Mule is a scalable, highly distributable object broker that can seamlessly handle interactions with services and applications using disparate transport and messaging technologies.
Main features:
- J2EE 1.4 Enterprise Service Bus (ESB) and Messaging broker
- Pluggable connectivity such as JMS (1.0.2b and 1.1), VM (embedded), JDBC, TCP, UDP, multicast, http, servlet, SMTP, POP3, file, XMPP.
- JBI Integration.
- Orchestration of services using WS-BPEL and Mule components and routers.
- Support for asynchronous, synchronous and request-response event processing over any transport.
- Web Services using XFire (STaX-based) Axis or Glue.
- Flexible deployment [Topologies] including Client/Server, Peer-to-Peer, ESB and Enterprise Service Network.
- Declarative and Programmatic transaction support including XA support.
- End-to-End support for routing, transport and transformation of events.
- Spring framework Integration. Can be used as the ESB container and Mule can be easily embedded into Spring applications.
- Highly scalable enterprise server using the SEDA processing model.
- REST API to provide technology agnostic and language neutral web based access to Mule Events
- Powerful event routing based on patterns in the popular EIP book.
- Dynamic, declarative, content-based and rule-based routing options.
- Non-Intrusive approach. Any object can be managed by the ESB container.
- Powerful Application Integration framework
- Fully extensible development model
Enhancements:
- XFire now supports STaX-based streaming SOAP, JavaSpaces JAAS Security Provider, Spring Remoting, HiveMind, and these transaction managers: Weblogic, Websphere, JRun, JBoss, Resin, and Generic Jndi-based.
- Performance improvements were made and full character set encoding support and internationalization was implemented.
- Transport-specific session handling was added.
- Over 300 issues were closed.
- The Sandbox now has jBPM Transport, specialised Tibco transport, specialised MQ Series transport, a SAP module, and Maven Archetypes for building template projects.

jUDDI provides a Java toolkit and registry implementation of UDDI.
jUDDI (pronounced "Judy") is an implementation of the Universal Description, Discovery, and Integration (UDDI) specification for Web Services.
Main features:
- Open Source
- Platform Independent
- Supports for JDK 1.3.1 and later
- UDDI version 2.0 compliant implementation
- Use with any relational database that supports ANSI standard SQL (MySQL, DB2, Sybase, JDataStore, HSQLDB, etc.)
- Deployable on any Java application server that supports the Servlet 2.3 specification (Jakarta Tomcat, JOnAS, WebSphere, WebLogic, Borland Enterprise Server, JRun, etc.)
- jUDDI registry supports a clustered deployment configuration.
- Easy integration with existing authentication systems