Docstoc

Web Integration Technology

Document Sample
Web Integration Technology Powered By Docstoc
					                 Web Integration Technical
                       Whitepaper
     A Technical Introduction to the Web Integration Technology and
                            Software Platform




Revision 4.0, August 2005
Kapow Technologies
http://www.kapowtech.com
Copyright 2003-2005 Kapow Technologies
http://www.kapowtech.com
All rights reserved.
Contents

I NTRODUCTION
  The Challenges of Integration
    Expensive
    Time consuming
    Low responsiveness
  Types of Integration
  Web Integration
  Benefits of Web Integration

KAPOW T ECHNOLOGIES R OBOS UITE PLATFORM
  Web Clipping
  Data Collection
  Application Integration

T ECHNOLOGY
  RoboSuite Overview
    RoboSuite Architecture
    Robot Basics
    Error Handling
  The Visual Development Environment
    ModelMaker
    RoboMaker
  The Runtime Environment
    RoboServer
    RoboSuite Control Center
    RoboRunner
    RoboManager

PLATFORM REQUIREMENTS

M ORE I NFORMATION

ABOUT KAPOW T ECHNOLOGIES
Introduction
Across the world, the web browser is becoming the most dominant way to access content, applications and
systems. It is now common for companies to let their employees, partners and customers access all kinds of
information and services via the web. However, with web systems mushrooming both inside and outside the
firewall, it is not always easy to get these systems to work together in a integrated way. They are often built by
different departments and organizations using a variety of technologies. One thing that they have in common,
though, is the HTTP transport protocol and the HTML syntax. This represents a special type of API that can be
leveraged for integration.
The RoboSuite platform from Kapow Technologies is a unique platform that enables this type of integration of
any web-browsable systems or applications.
Typical solutions implemented using RoboSuite include portlets created from existing web applications,
collection and integration of data and content, composite application integration and web service-enabling of
existing web applications.
This document outlines the challenges of traditional integration methods and introduces Web Integration as a
possible solution to these challenges. In addition, the document provides a technical introduction to the
RoboSuite platform, and explains the advantages it provides over existing methods.


The Challenges of Integration
Today’s enterprises are challenged with increasingly critical IT integration problems. Despite efforts to
consolidate, IT departments are faced with numerous applications that are not designed to interact with each
other. Companies also frequently need connections to applications outside of the enterprise, particularly in cases
where they interact with customers, suppliers, distributors or government agencies. Traditional application
integration as well as web services have been applied to solve these problems but IT organization face a number
of issues with these approaches:


Expensive
The traditional application integration approach relies on having control over the application and modifying the
applications, adding for example a web service interface that exposes the desired functionality and data. This
approach results in expensive, long-running development projects involving highly skilled programmers, with
high risk and high architectural impact.


Time consuming
At the same time, as enterprise IT organizations are pressed on budgets, with fixed or reduced resources, today’s
environment requires them to get integrations up and running at an ever increasing pace. Defining API’s and
communication paths is a time consuming process. The industry efforts around web services, which promise to
deliver a standard for programmatic interfaces to applications, may help on this, once web services have been
created. However, this still leaves the problem of actually implementing these web services. Modifying an existing
application to expose its functionality and data in a programmatic interface will still be a considerable task and
only be possible when there is full control over the application source code.


Low responsiveness
For applications outside of the enterprise's realm, the modifications required by traditional integration methods
will most often not even be possible. As a result, many business-critical integration projects are near impossible.
For the enterprise, the consequences are reduced productivity, increased operational costs, missed business
opportunities, and reduced business agility.
Types of Integration
Figure 1 is a generalized illustration of possible integration points into a given application. Conceptually, three
types of connections can be made: connections at the presentation layer, at the functional layer, or at the data
layer.


                                          !"                         !"




                                                              #$
                                 Enterprise
                                 Application

                                 Corporate
                                  Portal




                                                             #& #
                                                              # $
                                                              %
                                Integration
                                Middleware


                                                              $(#
                                    CMS
                                                              '




                                         )   "
                                       "# % ! !"(

                                                Application
                                      Figure 1: Application Integration Points

The presentation layer is the human user interface, either web-based or a platform-specific GUI or terminal
interface. This user interface allows a human to interact with the application, and is not as such initially intended
for use by other applications to connect.
The functional layer is the traditional place for programmatic access to an application, and is done by integrating
with an API or using web services. This will provide direct access to most of the business logic of an application. In
the cases where these integration points do not exist, they must be created by changing the application code.
Integration at the data layer will typically be done with connections to one or more databases. This is an effective
way to access data, but does not provide access to the business logic and will often compromise data integrity if
the business rules from the functional layer are not adhered to.


Web Integration
Web Integration is a unique and innovative approach to the challenges of integrating and web service-enabling of
existing applications. With Web Integration, non-intrusive integration can be done fast, iteratively, at low cost,
and with low skill requirements.
The key to Web Integration is to exploit the fact that many applications already have an HTML-based web
interface that can give access to their functionality and data, even logic included in the presentation layer.
Although this web interface is intended for human users, Web Integration can turn the web interface into a well-
defined programmatic interface that exposes the full functionality and data of the application. This is illustrated
in Figure 2.

                             !"                                                   !"




                                           #$




                                                                          #$
                   Enterprise
                   Application


                                           #& #
                                              $
                    Corporate               #
                     Portal                 %




                                                                         #& #
                                                                          # $
                                                                          %
                   Integration
                                            '




                   Middleware




                                                                          $(#
                      CMS




                                                                          '
                                                 (
                                                # ( !"(

                                     Figure 2: Web Integration access points

As the figure shows, the Web Integration Server accesses the presentation layer of an application through the web
interface. The Web Integration Server can then make one or more of the following access points available: a
modified web interface, an API, a web service, or structured data. As an example, this means that in terms of web
services, this approach can be used to easily web service-enable any application that has a web interface.
Using Web Integration, other applications can access the full functionality and data of the application, as if the
application itself had been changed to provide that interface.
This can be applied in powerful solutions, such as:
   •   Enterprise portals: Content and functionality of existing web-enabled applications can be used in an
        enterprise portal.
   •   Web Services: Any web-enabled application can be turned into a web service.
   •   Content Migration: Content from various sources in the enterprise can be restructured and migrated into a
        new context, such as a content management system.
   •   Composite Applications: Aggregate functionality from a number of existing applications to form a new
        application that automates higher-level business processes.
   •   Data Collection: Services characterized by a large number of source web sites, such as price comparison
        sites and e-procurement sites, can be implemented efficiently by collection and restructuring data from
        large web based information sources.
   •   Market Intelligence: Information from competitors, media providers, government databases, and so on,
        can be collected regularly for market intelligence purposes.
   •   Automation: In general, Web Integration is very suitable for replacing human tasks involving an
        information flow between a range of web-enabled applications.
Benefits of Web Integration
Web Integration has a number of important benefits compared to traditional integration approaches:
   Low cost: Using Web Integration, the effort required becomes orders-of-magnitude less expensive compared
          to traditional integration. There are many reasons, but to name a few, they include: less need for
          expensive high-end programmers and no change in existing applications, security and firewall setup.
   Non-
   Non- intrusive integration: Web Integration is done without modifying the application to be integrated,
          thereby lowering the risk and impact of the integration project, eliminating the need for resource
          consuming architectural changes and re-factoring and avoiding the politics of cross-enterprise
          projects. This also has the benefit to integrate to applications beyond control where there is no other
          alternative than to integrate through the web front-end.
         Risk:
   Lower Risk : Web Integration allows for very short and cost-effective implementation cycles. The first
          integration can often be up and running in a matter of days, and further integration can be done
          iteratively, as experiences and ROI from the first integrations are analyzed. This allows enterprises to
          try out new business opportunities at a much lower risk than using traditional methods..
   Time-to-
   Time- to-market: Even complicated Web Integration projects can be completed in weeks rather than months
          or years. Enterprises can gain competitive advantages by leveraging their existing enterprise
          applications much faster than competitors and thus increasing the business agility.
                   accurate
   Faster and more accur ate design phase: Since the web interface is equally well understood by the business
          person and the programmer, the communication to create the application design becomes a lot easier
          and less error prone.
   Low skill requirements: A traditional integration project requires highly skilled and scarcely available
          developers. Extensive knowledge of the applications to integrate and of enterprise application
          integration in general is required. With Web Integration, the work that involves connecting to web-
          enabled applications will require developers with just basic programming experience and HTML
          knowledge. This will reduce, or even eliminate, the need for high-skilled expensive developers in an
          integration project.
Kapow Technologies RoboSuite Platform

Kapow RoboSuite is the leading Web Integration platform on the market. It enables fast and powerful integration
of web-based content and applications into portals, content management, knowledge management systems etc.
RoboSuite can access web resources and automate web interactions to extract and reuse online content, data or
business functionality, regardless of origin and underlying technology. The platform includes an intuitive visual
design environment, as well as comprehensive Web Integration lifecycle tools, that simplify integration and speed
project delivery so that users can achieve faster and better results than with traditional integration approaches.
New integrations are created in an easy-to-use visual development environment, without changing a single line
of code in the web interface or application. Using RoboSuite, other applications can access the full functionality
and data of the application, as if the application itself had been changed to provide that interface. Furthermore,
RoboSuite is independent of and has no impact on the existing enterprise IT infrastructure. Because of its server-
based architecture, RoboSuite can be used from any application almost regardless of platform and infrastructure,
without requiring any architectural or infrastructure changes.
This section describes the three common uses of the RoboSuite platform:
   •   Web Clipping: Reusing the web interface of existing web-enabled applications in your portal.
   •   Data Collection: Collecting data from any web-enabled data source.
   •   Application Integration: Integrating functionality and data of any web-enabled application into your
        application.




Web Clipping
Web clipping is an integration method that reuses selected parts of an existing web interface in another web
interface. This is done by clipping the HTML of the existing web interface and modifying the HTML for use in the
new web interface.
Web clipping is typically used for enhancing enterprise portals in a cost effective way. A portal consists of portlets
with real-time information and functionality from a variety of sources. Developing a portal typically involves
significant integration tasks, because the portal requires integration to the functionality and data of other
applications, some of which may not even be inside the realm of the enterprise.
However, using RoboSuite, the web interfaces of existing web-enabled applications can easily be turned into
portlets in the portal, by clipping the required segments of those web interfaces and reusing them in the portlets,
possibly adapting them to match the visual style of the portal. No changes to the underlying applications or
databases are required, no traditional integration work is required, and no new portlet-based user interfaces
need to be implemented for the applications.
Figure 3 shows a portal connected to two applications using RoboSuite. RoboSuite generates the portlet content
dynamically by clipping the relevant content and functionality from the existing applications. This could be a
customer snapshot from an existing customer service application, or selected functionality from a company’s
web-enabled ERP system.
                                    Web-enabled
                                    Applications
                                                                        Enterprise
                                                                          Portal
                                                                             Portlets




                                                        RoboSuite




                                               Figure 3 : Web Clipping

A unique feature of RoboSuite is that it supports continuous clipping (see Figure 4). This means that clipping can
continue after the user interacts with a clip in a portlet. For example, assume that a search form is clipped and
shown in a portlet    . With continuous clipping, if the user fills in the form and submits it   - , the search result
page can be clipped as well, and shown in the portlet     . Without continuous clipping, the search result page
would open up in a new browser window, causing the user to leave the portal. Thus, with continuous clipping, the
user can stay inside the portal while interacting with clipped content.




                        book


                                                                                Search
                                                                                book




                                           Figure 4: Continuous Clipping

Using RoboSuite for clipping has a number of advantages for creating portlets:
   •      Programming:
       No Programming Existing applications and content can be made available in the portal without any
        programming, and without any modification to those applications, using RoboSuite’s visual development
        environment.
   •         Redesign:
       No UI Redesign The portal developer does not need to design a new user interface. If the portal has a
        different visual style than the existing applications, RoboSuite can modify the clipped segments to match
        that style.
   •   Improved reach: Clipping can be used to integrate external functionality and content where the IT
                reach
        department has no control over the source applications.
   •   The lower cost and shorter time it takes to create portlets with RoboSuite, lowers the threshold for when
        it is feasible to integrate external applications in the portal. This makes it possible to populate the portal
        faster and make it an instant success with the business users.
Data Collection
Data collection is the process of extracting and collecting data from a number of different web enabled data
sources. The data collection may involve data transformation and validation, because the source data models may
not match the desired output data model.
There are several scenarios where RoboSuite can be used for data collection purposes, including:
   •   Data migration — implementing a content management system and feeding it with data from legacy web
          sites.
   •   Competitor tracking — gathering competitive product information, press releases, patent information, etc.
          from competitor web sites.
   •   Market places — gathering product information from a large number of websites, and implementing a
          price comparison function, or similar.
Data collection can be done on a one-off basis or on a continual basis. RoboSuite handles all the issues around
data sources being temporarily inaccessible, data sources that change their web interface over time, data
validation, data transformation, and so on.
The result of the data collection can be made available in a number of formats, as shown in Figure 5. Typically, the
data would be stored in a database, written in XML format to a file, or submitted to a content management
system.

                     Data Sources                                                Collected Data




                                                                    Database




                                                                      XML
                                                     RoboSuite


                                                                       CMS




                                                 Figure 5: Data Collection

RoboSuite includes advanced support for data transformation and validation, as well as functionality that
optimizes the data collection process when it is done regularly.
Using RoboSuite for data collection has a number of benefits:
      Lower Cost:
    • Lower Cost no programming of adapters or connectors is required and the non-intrusive nature of
           RoboSuite removes the need to change existing systems in order to prepare them for collection.
              Time:
    • Reduced Time the code-free the iterative approach offered by RoboSuite significantly reduces the time to
           value for any data collection project. In addition to that, it makes it possible to run the old and the new
           data entry tools concurrently, allowing for a phased approach to system implementation.
                      uality:
    • Improved data quality RoboSuite can remove bad and redundant data, greatly increasing the overall
                    q uality
           value of a data collection project.
Application Integration
Application integration is about connecting disparate applications, their data and functionality. Typically, an
application connects with another application using an adapter, which is a component that translates the
functions and data models between the two applications.
Adapters may be written to connect two specific applications, or they may translate one application’s functions
and data to an industry standard API, or to an API understood by an integration middleware component.
RoboSuite acts as a uni- or bi-directional adapter between any web-enabled applications.
Figure 6 shows an enterprise application, integration middleware, or similar, that connects to a number of
applications using adapters. Applications A and B are connected with adapters that are specific to those
applications and to the enterprise application. Application C has a web service interface, which connects directly
to the enterprise application’s web service interface. Applications D, E and F have web interfaces, and therefore
they can be connected using RoboSuite. RoboSuite acts as an adapter that connects to any web-enabled
application via the web interface, and exposes the functionality and data of that application as an API or web
service.


                                                                          *    #%            !"



                                                                          *    #%            !"

                             % (
                           "# % #
                               !"
                                                                               #& #
                                                                                 $


                                                                                             !"
                                                                                #
                                                                                %




                            % %
                           ! ! #              # $
                            !%                %
                                             #& #
                                                (
                                               #(
                                                                                             !"
                                                                                 $
                                                             #& #




                                                                                #




                          )
                        "# % !"                                                          '
                                                              # $
                                                              %




                          * - #
                        ,* # %
                                                                                             !"
                                                                                 $




                               ,
                                                                                #




                                                                                             !"
                                                                                #$




                                                             !                           +


                                          Figure 6 : Application Integration

Application integration is the most advanced form of Web Integration. It allows the developer full access to the
functionality and data of the web-enabled applications. The definitions of how to interface the web-enabled
applications are created in RoboSuite’s visual development environment, and programmatic access to
applications is done through the RoboSuite APIs.
RoboSuite APIs include a Java API, a JSP tag library, and a .NET API. Interfaces for specific application frameworks
are also available, including BEA WebLogic Workshop and IBM WebSphere. This also enables easy creation of web
service wrappers for web-enabled applications. Additional interfaces will become available, or can be developed
on request.
Examples of application integration using RoboSuite include:
   •   Integration to enterprise applications such as CRM, ERP, legacy systems, etc.
   •   Integration to customer systems, suppliers or partners, such as order entry or shipment tracking systems.
   •   Account aggregation, such as building a uniform enterprise portal interface to multiple external web sites,
           e.g. e-procurement sites.
   •   Making existing web-enabled applications or portals available as portlets with re-engineered user
           interfaces, as opposed to just reusing the existing web interface by means of web clipping.
                                                                                                                       .




Using RoboSuite for application integration has a number of benefits:
   •   Lower Cost: existing applications and external content can be integrated without any programming,
             Cost
        using RoboSuite’s visual development environment. The non-intrusive nature of RoboSuite alleviates the
        need to change existing systems thus reducing the cost significantly compared to traditional methods.
   •   Reduced Time : the lack of programming and the iterative approach offered by RoboSuite significantly
        reduces the time to value for any integration project.
   •             each:
       Improved Reach in cases where political barriers or security restrictions prevent the IT department from
        opening up a backend API, it is possible for RoboSuite to access systems though an existing web interface .
   •         Risk:
       Lower Risk Web Integration allows for very short and cost-effective implementation cycles. The first
        integration can often be up and running in a matter of days, and further integration can be done
        iteratively, as experiences and ROI from the first integrations are analyzed. This allows enterprises to try
        out new business opportunities at a much lower risk than using traditional methods.
Technology
This section will provide an overview of the technical components of RoboSuite.


RoboSuite Overview
RoboSuite is a Web Integration platform that has a number of components. It consists of a visual development
environment and a runtime environment.
Fundamental to RoboSuite is the concept of robots. A robot is an agent that operates as an interface to a web-
                                           robots
enabled application. A robot can be viewed as a description of how to interact and navigate a web site in an
automated fashion. A robot may be invoked as a result of a call to a RoboSuite API, and it will return one or more
objects as output. It may also be scheduled to run regularly in order to perform data collection tasks, or it can be
called automatically from another application platform for the purpose of clipping.
The RoboSuite platform is used to create, execute, and manage collections of robots, and to create a
programmatic interface to the robots.


RoboSuite Architecture
An overview of the RoboSuite architecture is shown in Figure 7. It shows the RoboSuite runtime and development
environments, the robots and object models, and the interfaces to other systems.

                                                                  #$
                               /&       /                                %
                                                                        ! #(        ,   + #(       '       $(#
                                                                 % (
                                                                #& #




                                !
                                                        !                   !   !              !   # &




                            !       #                                                          #   # &
                                                    !             ' (   #
                                                                                           !
                                                                                                       $
                           !            !   $   %           $                              %           $




                                "



                                                Figure 7 : RoboSuite Architecture

Robots and objects models are created in the visual development environment and executed in the runtime
environment. A robot contains instructions on how to interface to one or more source web applications. Object
models define the format for input and output from robots. Robots and object models are stored as XML
definitions in files, along with other files of an integration project.
The visual development environment consists of the RoboMaker and ModelMaker applications. RoboMaker is
used for creating and editing robots, and ModelMaker is used for defining object models.
Robots are executed in the runtime environment, using either RoboServer or RoboRunner. RoboServer is a server
application that provides a number of interfaces for invoking robots through the RoboSuite APIs. RoboRunner is
an application that runs robots in “batch mode” from the command line, typically outputting the results into data
storage, such as a database, XML or the file system.
The runtime environment also includes monitoring tools: RoboSuite Control Center is a client application used to
monitor one or more RoboServers, and RoboManager is used to view the logs created by robots that are executed
in either RoboServer or RoboRunner.
RoboSuite can interact with other IT systems. This includes APIs that interface to RoboServer functions. A number
of different APIs exist for different programming environments, including Java, JSP, and .NET. In addition to this,
code generation tools exists to automatically create ready-to-use interfacing code for Java, C#, generic web
services and specific application frameworks including BEA WebLogic, IBM WebSphere and other portal
frameworks through JSR 168 compatible portlets.


Robot Basics
                                steps.
A robot consists of a number of steps Steps are connected with connections that control the program flow. A
robot will typically start by loading a URL to a web-enabled application. As the steps are executed, the robot
navigates the web interface, assigning values to object attributes, iterating through page structures, and so on.
All useful robots will also have steps where objects are returned as output (and thus either passed back through
the RoboSuite API, or written to a data store).
Figure 8 shows an example of a simple robot. It is a data collection robot that extracts job postings (title, and
description) from a web site. It will submit a form, and iterate through the resulting web pages.




                                                Figure 8: Example Robot

                                 finders,       action,
A step contains zero or more tag finders a step action and an error handling mechanism. The tag finders define
the parts of the current page that should be processed by the step action. Tag finders either operate on the logical
document structure, or use various types of pattern matching, or both. For example, the tag finder may be
instructed to locate the second cell in the first row of the first table, or it may locate the cell with the style
definition “price”, and so on.
The step action operates on the tags identified by the tag finders, and performs the actual action of the step. A
large number of step actions are available, all designed to accommodate the variety of situations one encounters
in a web interface.
Using these building blocks, robots can be instructed to do any number of things as they navigate one or more
web-enabled applications, including:
   •   Load pages, and follow links.
   •   Crawl and iterate over pages and frames.
   •   Submit forms, manage sessions and cookies.
   •   Execute JavaScript.
   •   Iterate over page elements, such as links, paragraphs and table rows, etc.
   •   Do conditional execution based on content, object attributes, error situations etc.
   •   Extract data, including text, numbers, dates, images, and binary data.
   •   Transform and validate data
   •   Clip and modify HTML.
   •   Define and set variables for temporary context, finite loop control etc.
   •   Return and process objects.
This is just a short list of examples, but it is also important to understand that RoboMaker is modular and
extensible as additional steps can be developed; making it possible to accommodate special cases should it be
necessary.


Error Handling
RoboSuite includes a number of mechanisms to make robots robust against changes in source web applications
or to detect changes and exit with an instructional message. Furthermore, the RoboSuite runtime environment
includes tools to monitor robots and notify administrators if problems occur.
The Visual Development Environment
The RoboSuite Visual Development Environment consists of two applications — ModelMaker and RoboMaker.
They are used at development time to create and debug robots and object models.


ModelMaker
ModelMaker is used to create and edit object models. An object model is like a type definition in a programming
language — it defines the structure of the objects that form the input and output of a robot.




                                               Figure 9 : ModelMaker

An object model consists of one or more attribute definitions, each of which define an attribute name, type, and
other information.
A given robot will return (or store) objects defined by one or more object models. For example, a data collection
robot for job postings could return objects defined by the object model Job. Job would contain attributes such as
title and source (short text types), date (date type), description (long text) and so on. This example is shown in the
screenshot in Figure 9.
In case the objects are stored in a database at runtime, the database will have a table definition matching the
object model. ModelMaker can generate the SQL necessary to create the required tables in the database.
RoboMaker
RoboMaker is an easy-to-use visual environment for creating, editing, and debugging robots. RoboMaker includes
wizards for creating robots that are used for web clipping, data collection and application integration.




                                                      10:
                                               Figure 10: RoboMaker

RoboMaker interactively executes the robot as it is being written. This is important as it means that the user can
always see the web page that the current step will operate on. Using point-and-click on the web page, the user
can define the action to perform on the page, such as following a link, submitting a form, or extracting
information into an object. In effect, creating a robot is similar to clicking through a site in a web browser. Having
this instant verification of the desired steps speeds up integration projects tremendously and allows for iterative
modeling of the integration.
To minimize the programming effort involved in executing Robots from an API level, RoboMaker also includes a
number of code generation tools intended to create ready-to-use code for specific APIs and programming
environments, including:
   Java:
   Java
       - Automatic generation of Java classes that interface using the RoboSuite Java API.
       - Automatic generation of Java Portlets (JSR 168 Portlets).
       - Automatic generation of JSP-Based Portlets.
    NET:
   .NET
       - Automatic generation of C# classes that interface using the RoboSuite .NET API.
       - Automatic generation of .NET Web Services
   BEA WebLogic
       - Automatic generation of web clipping portlets for use in BEA WebLogic Portal.
   IBM WebSphere:
       WebSphere
       - Automatic generation of web clipping portlets for use in IBM WebSphere Portal.
RoboMaker also includes RoboDebugger for debugging robots, shown in Figure 11. In RoboDebugger, you can do
everything you would expect from a debugger, including single-stepping, setting breakpoints, viewing the
current execution state, and viewing the extracted objects and generated error messages. At any point in the
execution, you can stop the robot, go to the RoboMaker window and modify the robot, and then resume
debugging in RoboDebugger from that point or from the start.




                                                  11:
                                           Figure 11: RoboDebugger
The Runtime Environment
Web enabled applications can be accessed through RoboSuite using either RoboServer or RoboRunner. These two
applications are described in the following sections, along with the monitoring tools RoboSuite Control Center
and RoboManager.


RoboServer
RoboServer is a server application for executing robots. RoboServer allows for parallel execution of multiple robots
ensuring high performance and scalability. RoboServer can be accessed by RoboSuite Control Center,
RoboManager or programmatically by external programs.
There are a number of ways to program against RoboServer, each method suitable for a given programming
environment. Most applications will use one of the higher-level RoboSuite APIs. Currently, they include:
   •                  API:
       RoboSuite Java API The API for Java.
   •   RoboSuite JSP Tag Library: A JSP tag library that provides an easy way to interface to RoboServer from web
                         Library
        applications written using JSP.
   •   RoboSuite .NET API: The API for Microsoft .NET.
                      API
The APIs may be invoked either synchronously or asynchronously. Synchronous calls return the result in the same
function call (immediately when data it is available). Asynchronous calls return immediately, and the result is
retrieved later when it is available.
As shown in figure 12, RoboServer can run Robots in clustered mode thereby providing load balancing and failover
for increased scalability and availability.


                                              !"           !



                                                           !
                                               ( %) )
                                              0 #" !




                                                                        ( %1
                                                                       0 #!
                                                                       $ %#(
                                                                      ! ! #& %




                                                           !



                                          Figure 12:
                                          Figure 12 : Clustering in RoboSuite

In addition to this, RoboServer may be configured to write status information into the RoboManager database,
which contains information about robots executions, and error messages. This information is viewed using
RoboManager. The status information can also be written to files, or sent as emails to the system administrator.
RoboSuite Control Center
RoboSuite Control Center is a visual client application that connects to RoboServer. It is used to control the
functions of RoboServer, monitor the state of running robots, and to start and stop robots.




                                              13:
                                       Figure 13 : RoboSuite Control Center

RoboSuite Control Center can manage a set of servers, including adding new servers and manageing Robots
within each server, as well as monitoring the state of each robot. This provides system administrators with an
easy-to-use tool for large scale RoboSuite deployments.


RoboRunner
RoboRunner is the RoboSuite application used for executing robots as a command-line invocation. In conjunction
with a scheduler, such as crontab in Unix systems, RoboRunner can run robots in batch at specific time intervals.
RoboRunner is used for data collection applications. RoboRunner is highly configurable, in terms of allocation of
processing power and storage of extracted objects, timeout strategies, limits on extracted objects, etc.
Resulting objects are written to a storage environment. Currently, the available storage environments include:
   •   SQL database: Stores objects in an SQL database. All major databases are supported.
           database
   •   Files: Stores objects in files, for example as XML or CSV (comma separated values).
       Files
As with RoboServer, RoboRunner can store status information in the RoboManager database, or in files. It can also
send emails to the system administrator in case of errors.
RoboManager
RoboManager is used to view status and error messages generated by robots executed using RoboServer and
RoboRunner. Administrators can identify robots that are broken because of inaccessible sites, or because of
significant web interface changes. RoboManager has extensive tools for locating robots as well as he ability to
identify individual runs of robots based on time of execution, messages submitted, and a number of other
parameters. This is especially important when RoboSuite is used in large scale environments with hundreds of
robots that run frequently (e.g. high-frequency collection of competitor prices).




                                                    14:
                                             Figure 14: RoboManager
Platform Requirements
         Requirements
RoboSuite is available for the following platforms:
   •   Windows
   •   Linux
Additionally, the RoboSuite runtime environment alone is available for the following platforms:
   •   Solaris
   •   HP-UX
   •   AIX
RoboSuite supports the following databases:
   •   Oracle
   •   IBM DB2
   •   Microsoft SQL Server
   •   Sybase
   •   PointBase Server
   •   MySQL
   •   PostgreSQL


RoboSuite is available for the following Portal platforms:
   •   BEA WebLogic
   •   IBM WebSphere
   •   Plumtree
   •   Generic JSR 168 Portals
                                                 .




More Information
Kapow Technologies web site:
http://www.kapowtech.com

      Developer
Kapow Developer Connection web site:
http://kdc.kapowtech.com

Patent applications:
PCT/DK00/00163, PCT/DK00/00429, PCT/DK00/00700
Kapow Technologies A/S - Headquarter EMEA
Dr. Neergaards Vej 5A
DK - 2970 Hørsholm
Denmark
Phone +45 7033 1000
Fax +45 7033 1001 / +45 4516 2470




Kapow Technologies - Headquarter US
1999 S. Bascom Ave. Ste 700
Campbell
CA 95008
United States
Phone +1 800 805 0828




About Kapow Technologies
Kapow Technologies is a leader in Web Integration – a new integration paradigm using the broadly available web
front-end. The Kapow RoboSuite platform uniquely enables flexible and fast integration of content, data and
applications from any source available through a browser into portals, content management systems,
applications, databases or as web services. The platform includes an intuitive visual design environment that
simplifies integration and speed project delivery so that users can achieve faster and better results than with
traditional integration approaches. Kapow Technologies has close to 100 public and private customers worldwide
including US Army, Deutsche Post, Lycos Europe, Barclays Bank, DZ Bank, Swedish Defense and Danish
Broadcasting Corp. and partnerships with major industry players like BEA, IBM, Plumtree, WRQ, Autonomy and
others. For more information: www.kapowtech.com.
Copyright 2005 Kapow Technologies A/S.
http://www.kapowtech.com
All rights reserved.

				
DOCUMENT INFO
Shared By:
Categories:
Tags: white, paper
Stats:
views:500
posted:4/5/2008
language:English
pages:25