On-line Analytical Processing OLAP by linzhengnd

VIEWS: 3 PAGES: 39

									Web Services
    November 2001
         Web Services as Program Components
• A Web Service is a URL addressable resource that returns
  requested data, e.g. current weather or the map for a neighborhood.

• Web Services use standard web protocols: HTTP, XML, SOAP,
  WSDL allow computer to computer communication, regardless of
  their language or platform.

• Web Services are reusable components, like ‘LEGO blocks’, that
  allow agile development of richer applications with less effort.

• Web services can transform the web from a medium for viewing and
  downloading to data/knowledge-exchange and distributed computing
  platform. (Berners-Lee)
Web Services: Connect, Communicate, Describe, Discover

      Enabling Protocols of the Web Services architecture:

  • Connect: Extensible Markup Language (XML) is the universal data
    format that makes connection and data sharing possible.

  • Communicate. Simple Object Access Protocol (SOAP) is the new W3C
    protocol for data communication, e.g. making requests.

  • Describe. Web Service Description Language (WSDL) describes the
    functions, parameters and the returned results from a service

  • Discover. Universal Description, Discovery and Integration (UDDI) is a
    broad W3C effort for locating and understanding web services.
    Interoperability through a Layered Protocol Stack

                             Interoperability        Standards
                                Service Integr.    WSFL, XLANG

                              Service Discovery        UDDI                   OGC Catalog


                              Service Descript.        WSDL
                                                                               OGC Coverage,
                                 Web Service                                CoordTransfom, WMS

                               Connectivity
                                Data Binding           HTTP, SOAP

                                Data Schema           HTML, XML               OGC -GML

                               Data Encoding         ASCII, XML, etc.

                              Comm. Protocols        TCP/IP, HTTP, FTP

•   Web Services are implemented on a layered stack of technologies and standards
•   The lower layers enable binding and exchange of messages; higher levels enable interoperability
•   Applications are formed dynamically from distributed components through publish-find-bind
    mechanisms
              Web Services Components and Actions
                       Components:           Provider – User – Broker
                       Actions:              Publish – Find - Bind



                                           Service
                                           Broker

                                    Find                 Publish



                     Service               Bind               Service
                      User                                    Provider


•   Service providers publish services to a service broker.
•   Service users find the needed service and get access key from a service broker
•   With the access key, users bind to the service provider
•   The result is a dynamic binding mechanism between the service users and providers
                                                Web Service Standards



                                                         Service
                                                         Broker

                                                                            Publish
                                              Find                          UDDI, WSDL
                                            UDDI, WSDL




                            Service                    Access                    Service
                             User                   SOAP, XML
                                                                                 Provider


                                   Each operation is governed by standard protocols:

•   Discovery and Integration: UDDI (Universal Description, Discovery and Integration)
•   Service Description: WSDL (Web Services Description Language)
•   Content Envelope: SOAP (Simple Object Access Protocol)
•   Data Encoding: XML (Extensible Modeling Language)
             Web Application: Chained Web Services


                                                      Service
                                                      Broker

                                Find
                                                             Publish


                  Service            Bind                                Bind
                                                   Service                            Service
                   User                         Provider/User                         Provider
                                    Chain                                Chain


•   A Web Service Provider may also be a User of other services
•   Multiple web services can be chained into an interactive workflow system
•   The result is an agile application that can be created ‘just in time’ by the user for a specific need
    4D Data Access though a Web Service Portal

                                            Service
                                            Broker


                                Find           Publish
                               UDDI, WSDL      UDDI, WSDL                Web Publish
                                                                           HTTP, FTP

                   Service              Access                Service                   Web
 Service
                  User Chain                                   Proxy                   Server
Consumer                              SOAP, XML



      Ordinary web content can be delivered as a Web Service through a Proxy Server.

•   The Proxy Server supplies a web server- to - web service ‘wrapper’
•   The Proxy Server publishes the web service to the Broker
•   The User accesses the Proxy to get the distributed Web Server data
                                    Distributed Data Browser Architecture



   XDim Data
                   XML Web
        SQL
                    Services
        Table
                                 Session Manager (Broker)                           Data Views
        OLAP                                                                Layered Map       Time Chart
        Cube
                                   Connection     Cursor-Query
     GIS Data                       Manager         Manager
      Satellite
                   OpenGIS                                              Cursor
                   Services       Data Access       Data View                                 Text, Table
      Vector
                                    Manager         Manager
                                                                            Scatter Chart
    Text Data
         Web          HTTP
         Page        Services

         Text
         Data

Distributed data of multiple      The Broker handles the views,             Data are rendered by linked
types (spatial, temporal text)    connections, data access, cursor          Data Views (map, time, text)
                           Web Services Standards

                                                         Service
                                                         Broker

                             Find
                                                                   Publish
                           UDDI, WSDL
                                                                  UDDI, WSDL



                 Service            Bind                                        Bind
                                  SOAP, XML
                                                      Service                               Service
                  User                             Provider/User                           Provider
                                  Chain                                                Chain
                                                                                    WSFL/XLANG



•   Discovery and Integration:   UDDI (Universal Description, Discovery and Integration)
•   Service Description:         WSDL (Web Services Description Language)
•   Content Envelope:            SOAP (Simple Object Access Protocol)
•   Data Encoding:               XML (Extensible Modeling Language)
•   Service Chaining:            WSFL (Web Services Flow Language, IBM) or XLANG (Message flow language, Microsoft)
             Web Application: Chained Web Services


                                                  Data/Service
                                                   Catalog

                                Find
                                                             Publish


                  Service            Bind                                Bind
                                                   Voyager                             Data
                   User                           Data Service                        Provider
                                    Chain                                Chain


•   Any Web Service Provider may be a User of other services
•   Multiple web services can be chained into an interactive ‘workflow’ system
•   The result is an agile application that can be created ‘just in time’ by the user for a specific need
     Dvoy_Services: Generic Software components

                                                                           User Interface Module
                                                           UIM extracts relevant UI parameters from STATE
                 User Interface
                                                           User changes UI parameters
                    Module
                                                           UIM transmits modified UI parameters to STATE
                        Selector


                               state I/o ports
                                                                           Service Chain STATE Module
                                                               Contains the state params for all services in the chain
                  Service state
                                                               Has ports for getting/setting state params

                               state I/o ports
                                                                                Service Adopter Module
Web service
 Input data                                                     Gets input data from upsteam service
               Webservice            Adaptor
                                                                Gets service params from STATE
                                                                Make service call
                                   Web service calls
                                                                                Web service Service Module
                       Webservice                                 Gets service call from Adopter module
                                                 Web service
              Param 1                                             Executes service
                                                 Output data
              Param2                                              Returns output data


                                      Service Adopter Module
                        PointAccess->Grid->GridRender Service Chain

                      GetMapPointData                                  RenderMapviewPoint
                          Selector                                           Selector

                                     state I/o ports

                          Service state                                    Service state

                                     state I/o ports

                        GetMapPointData                                RenderMapviewPoint
                            Adaptor                                          Adaptor
                                     Web service calls

                        GetMapPointData                                RenderMapviewPoint
                       dataset_abbr: IMPROVE             Web service   dataset_url:
                                                         Output data
                       Param_abber SOILf
                                                                       output_format:
                       datatime: 2001-04-16
                                                                       out_image_width:
                       sql_filter:
                                                                       Etc…..


•   The service chain interpreter make ONLY 2 sequential calls, stated in the data flow program:
     –   GetMapPointDataAdaptor
     –   RenderMapviewPoint Adaptor
                          PointAccess->Grid->GridRender Service Chain



     GetMapPointData                                    GridMapviewPoint
                                                            Selector          RenderMapviewGrid
         Selector
                                                                                   Selector
                    state I/o ports


           Service state                                   Service state          Service state
                    state I/o ports

         GetMapPointData                                GridMapviewPoint      RenderMapviewGrid
             Adaptor                                        Adaptor                 Adaptor
                    Web service calls
                                        Web service
         GetMapPointData                Output data     GridMapviewPoint      RenderMapviewGrid
      dataset_abbr: IMPROVE
                                                      dataset_url:            dataset_url:
      Param_abber SOILf                               output_format:          output_format:
      datatime: 2001-04-16                            out_image_width:        out_image_width:
      sql_filter:                                     Etc…..                  Etc…..


•   The service chain interpreter make ONLY 3 sequential calls, stated in the data flow program:
     –    GetMapPointDataAdaptor
     –    GridMapviewPointAdaptor
     –    RenderMapviewGridAdaptor
                         Federated Data Warehouse Architecture
•   Three-tier architecture consisting of
     –   Provider Tier: Back-end servers containing heterogeneous data, maintained by the federation members
     –   Proxy Tier: Retrieves Provider data and homogenizes it into common, uniform Datasets
     –   User Tier: Accesses the Proxy Server and uses the uniform data for presentation, integration or further processing
•   The Provider servers interact only with the Proxy Server in accordance with the Federation Contract
     –   The contract sets the rules of interaction (accessible data subsets; types of queries submitted by the Proxy)
     –   The Proxy layer allows strong security measures, e.g. through Secure Socket layer
•   The data User interacts only with the generic Proxy Server using flexible Web Services interface
     –   Generic data queries, applicable to all data in the Warehouse (e.g. space, time, parameter data sub-cube)
     –   The data query is addressed to a Web Service provided by the Proxy Server of the Federation
     –   Uniformly formatted, self-describing XML data packages are handed to the user for presentation or further machine processing

                                                                     Federated Data Warehouse

                 User Tier                                            Proxy Tier                                Provider Tier
                                                               Data Homogenization, etc.                       Heterogeneous Data
              Data Consumption

              Presentation                                        SQLDataAdapter1                                SQLServer1

                                                                 ImageDataAdapter2                               ImageServer2
               Processing

                                                                CustomDataAdapter                                LegacyServer
              Integration

          Data Access & Use                                          Proxy Server                             Member Servers
                         Web Service, Uniform Query & Data                            Firewall; Federation Contract
                             Voyager: The Program
                                              Controls




                                                 Ports
                Data Sources                                                       Displays




                                                                  Device Drivers
                                            Voyager Core
                                  Wrapper    Data Selection
                                     s        Data Access
                                             Data Portrayal

                                  Adoptive Abstract I/O Layer
•   The Voyager program consists of a stable core and adoptive input/output section
•   The core executes the data selection, access portrayal tasks
•   The adoptive, abstract I/O layer connects the core to evolving web data, flexible
    displays and to the a configurable user interface:
     – Wrappers encapsulate the heterogeneous external data sources and homogenize the access
     – Device Drivers translate generic, abstract graphic objects to specific devices and formats
     – Ports expose the internal parameters of Voyager to external controls
                  ASP.NET: Dynamic Web pages

• Easy WebApp development
     – drag-drop of controls on a WebForm
     – Binding control properties to class members and event handlers
•   Controls execute on serve but render themselves in HTML
•   User input at browser is posted to the server as class data and as properties
•   No need to know HTML – rendering is done by the controls
•   Clear separation of UI (form layout) and ‘business logic’ behind the form
•   ASP.Net is compiled for high performance
•   Automatic Validation Controls on the client makes input more robust
•   Automatic data biding of data source to controls – i.e Data Grid
      ADO.NET: DataSet and DataAdapter, another

•   The DataSet is a container object for one or more DataTables, DataRelations and
    Constraints. To draw a comparison to classic ASP/ADO, the DataTable is analogous
    to a RecordSet, and the DataSet is a container for one or more DataTables. DataSet
    knows nothing about particular data access interfaces like OLEDB or ODBC

•   The DataAdapter is the bridge between a DataSet and the data source, such as a
    Microsoft SQL Server database. The DataAdapter manages creating and opening a
    Connection, executing a Command, returning a DataReader, populating a
    DataTable and closing the DataReader and Connection. This can be done multiple
    times to populate multiple DataTables in the same DataSet.

•   Using a DataSet and DataAdapter is more memory intensive than using a
    DataReader, since all of the records returned are populated into a DataTable (taking
    up valuable system resources). The DataReader streams data, using up the memory
    required for only one record at a time. With that said, there are instances when you
    would want to use a DataSet and DataAdapter, such as when you need to manipulate
    the data, iterate through it, or alter it and update it.
              ADO.NET: Remote Database Access
                 Microsoft ADO.NET PPT
• ADO.Net is a set of classes (DataSet and DataAdapter) to access remote data
  sources; it decouples data source from data consumer through indirection

• DataSet is a data container object of structured information on a set of tables;
  it can can locally cash portions of the database and synchronize changes

• Each DataSet object is associated with a subclass of DataAdapter tailored to
  interact with a particular data source, e.g. SQLAdopter

• To change the data source, the consumer need only to change the DataAdapter

• User can access tables as properties of DataSet – no need to know SQL

• While in transit, XML data can pass through firewalls over regular HTTP port.
                   DataSet: a Small Relational Database

The DataTable fulfills the role of a database table
The DataColumn determines the data type and name of the column
The DataConstraint adds extended information such as primary key,…
A collection of DataRow objects holds the data in the DataTable
The DataRow also plays the part of an updateable cache ( a cursor???)




 DataRelation objects link related DataTable objects in the DataSet, providing referential integrity features similar
     to a database.

 The DataTable objects can be nested to whatever depth is necessary to replicate the structure of a hierarchical
     XML document or a relational database.

 A DataTable can access its relevant linkages using its child and parent Data Relation collections.

 DataRows make the navigation in a hierarchy even simpler using the GetChildRows() command with the
     DataRelation name as a parameter.
                                         DataSet
                                    Common client data store
                                                               DataSet
                                                                Tables
                                                                     Table
•   Relational View of Data
                                                                       Columns
    –   Tables, Columns, Rows,                                               Column
        Constraints, Relations                                         Constraints
•   Directly create metadata                                                 Constraint
                                                                       Rows
    and insert data                                                          Row
•   Explicit Disconnected Model                                 Relations
                                                                      Relation
    –   Disconnected, remotable object
    –   No knowledge of data source or properties
        •   Common Behavior
        •   Predictable performance characteristics
    –   Array-like indexing
    –   Strong Typing
                             DataAdapter

• Loads a table from a data                           DataSet

  store and writes changes back.
    – Exposes two methods:                         Fill() Update()
        • Fill(DataSet,DataTable)             SelectCommand

        • Update(DataSet,DataTable)           InsertCommand

    – Provides mappings between               UpdateCommand
                                              DeleteCommand
      tables & columns
                                              Mappings
                                              Mappings
                                               Mappings
    – User provides insert/update/delete       DataAdapter
      commands
        • Allows use of Stored Procedures
                                              Data
        • Autogen component available         store
    – Allows single DataSet to be populated
      from multiple different datasources
                 DataAdapter: Accessing the Data

•   Each .NET data provider has a DataAdapter object: OleDbDataAdapter,
    SqlDataAdapter (can we make DataAdapters to legacy data servers?)

•   The SelectCommand property of the DataAdapter retrieves data from the data source.

•   The InsertCommand, UpdateCommand, and DeleteCommand properties manage
    updates to the data in the data source.

•   The Fill method populates a DataTable object in a DataSet with the results of the
    SelectCommand
           An Introduction to GXA: Global XML Web Services Architecture

Summary: Discusses the Global XML Web Services Architecture (GXA), an open architecture for application internetworking. (2
printed pages)
Extensible Markup Language (XML) Web services are the fundamental building blocks in the move to distributed computing on the
Internet. Open standards and the focus on communication and collaboration among people and applications have created an
environment where XML Web services have become the platform for application integration. Applications are constructed using
multiple XML Web services from various sources that work together regardless of where they reside or how they were implemented.
XML Web services are successful for two reasons: They are based on open standards that making them interoperable, and the
technology used to implement them is ubiquitous.
XML Web services are built on XML, the Simple Object Access Protocol (SOAP), the Web Services Description Language (WSDL), and
Universal Description, Discovery, and Integration (UDDI) specifications. These constitute a set of baseline specifications that provide
the foundation for application integration and aggregation. From these baseline specifications, companies are building real solutions
and getting real value from them. But, as companies develop XML Web services, their solutions have become more complex and their
need for standards beyond this baseline is readily apparent. The baseline specifications are a strong start for XML Web services, but
today developers are compelled to implement higher-level functionality such as security, routing, reliable messaging, and transactions
in proprietary and often non-interoperable ways.
Addressing this need for additional specifications for XML Web services in these areas, Microsoft® and IBM presented an architectural
sketch for the evolution of XML Web services at the W3C Workshop on Web Services in April 2001. This sketch was the forerunner of
the Microsoft Global XML Web Services Architecture (GXA). GXA provides principles, specifications and guidelines for advancing the
protocols of today's XML Web services standards to address more complex and sophisticated tasks in standard ways, allowing XML
Web services to continue to meet customer needs as the fabric of application internetworking.
GXA is based on four design tenets:
         Modular—GXA uses the extensibility of the SOAP specification to deliver a set of composable modules that can be
combined as needed to deliver end-to-end capabilities. As new capabilities are required, new modular elements can be created.
          General Purpose—GXA is designed for a wide range of XML Web services scenarios, ranging from B2B and EAI solutions to
peer-to-peer applications and B2C services.
         Federated—GXA is fully distributed and designed to support XML Web services that cross organizational and trust
boundaries and requires no centralized servers or administrative functions.
          Standards-Based—As with previous XML Web services specifications, GXA protocols will be submitted to appropriate
standards bodies and Microsoft will work with interested parties to complete their standardization.
The revolution of the Web was about browsing—making information available for people. While very successful, this left a gap.
Applications and companies were still disconnected islands. Just as ubiquitous support of HTML enabled the World Wide Web,
ubiquitous support of SOAP enables XML Web services. XML Web services are bringing us a new revolution that allows businesses to
interconnect on a programmable Internet. The Global XML Web Services Architecture is the framework for the future of XML Web
services.
                                                   Portal Server
•   A portal solution seemed to fit BHCS's goals well. Commercial portals like Excite or Yahoo! are well known. They provide a specially
    formatted window onto a variety of data, whose source is invisible to users. Enterprise portals work the same way, letting users in an
    organization view a customized presentation of information from many sources. Interactive portal vendors like Sequoia—the vendor
    BHCS ultimately chose—also standardize access to information sources, including legacy apps and databases. This permits updates to
    data, merging data from different sources, and supporting search capabilities based on the context of the data




                                            Mapping Legacy Apps to XML
                                            How do you handle all those legacy apps? XPS can adapt to each
                                            individual legacy app's schemas, mapping their native fields and formats
                                            to XML tags and permitting XML-based indexing in context. Once legacy
                                            data has been converted to XML, administrators can then map data
                                            elements from different information sources that actually correspond to
                                            the same logical entity. For example, "name" in one document may be
                                            the same as "insurance subscriber" in another document; in a new app,
                                            these could both map to "patient."
                                    Distributed Data Browser Architecture



   XDim Data
                   XML Web
        SQL
                    Services
        Table
                                 Session Manager (Broker)                           Data Views
        OLAP                                                                Layered Map       Time Chart
        Cube
                                   Connection     Cursor-Query
     GIS Data                       Manager         Manager
      Satellite
                   OpenGIS                                              Cursor
                   Services       Data Access       Data View                                 Text, Table
      Vector
                                    Manager         Manager
                                                                            Scatter Chart
    Text Data
         Web          HTTP
         Page        Services

         Text
         Data

Distributed data of multiple      The Broker handles the views,             Data are rendered by linked
types (spatial, temporal text)    connections, data access, cursor          Data Views (map, time, text)
                                 .NET Data Providers - A Basic Tutorial




•   Now, the .NET Data provider can be manifested as SQL Server data provider, OLEDB data provider or the ODBC Data
    Provider. For the time being I'll be taking you through this article in the context of the first two Data providers.

    SQL Server Data provider is the most efficient way to connect to an SQL Server Database(version 7.0 onwards). It uses a
    proprietary protocol for connecting to the Database which results in optimized usage of the SQL Server database along with
    faster data transactions.
    The System.Data.Sqlclient namespace contains classes for the SQL Server data provider.
•   OLEDB Data Provider is used with databases that support the OLE DB interfaces. ADO.NET supports the following OLE DB
    Providers
•   SQLOLEDB - Microsoft OLE DB Provider for SQL Server
    MSDAORA - Microsoft OLE DB Provider for Oracle
    Microsoft.Jet.OLEDB.4.0 - OLE DB Provider for Microsoft Jet
                      DVoy Queries as Web Services

Purpose: Locating relevant data measures fir specific location and time

Abstract Query: Find available measures in MyDataCube

Web Service: input: MyDataCube; output: List of measures, MeasureDataCube

Design: Measure table with bounding MeasureDataCube cubes

Implementation: SQL measures table with MeasureDataCube
    SELECT Measures, MeasureDataCube WHERE MeasureDataCube in MyDataCube



    Distinct Locations, Times, Heights
                 DataAdapter: Accessing the Data

•   Each .NET data provider has a DataAdapter object: OleDbDataAdapter,
    SqlDataAdapter (can we make DataAdapters to legacy data servers?)

•   The SelectCommand property of the DataAdapter retrieves data from the data source.

•   The InsertCommand, UpdateCommand, and DeleteCommand properties manage
    updates to the data in the data source.

•   The Fill method populates a DataTable object in a DataSet with the results of the
    SelectCommand
                                                            Diff Calculus
•   Sun's slant, Engstrom says, is to provide a complete "stack" of Web
    services infrastructure, which includes development tools, application
    server platforms, and Sun's server hardware. In his own department,
    Engstrom says Sun is "all about making developers more productive—by
    doing the little things the standard doesn't address."
•   One example of this process is a tool to bring existing applications (such
    as SAP, PeopleSoft, and IBM CICS programs) into the Web-services
                                                                                 Service
    arena with XML adapters. "A big issue for us is how to retrofit," Engstrom
    says. "Because the applications running today are not going away."           Registry                Provider
                                                                                            Publish       Proxy
                                                                                            UDDI, WSDL




                                          Service                                                        Service
                                           User                                                          Provider
                            Web Service Actions and Components



                                           Service
                                           Broker

                                    Find                Publish


                       Service
                                           Access              Service
                        User
                                                               Provider


•   Web Services architecture requires three operations: publish, find, and bind.
•   Service providers publish services to a service broker.
•   Service users find the services and get access key from a service broker
•   With the key, users access the service.
                                                Web Service Standards



                                                         Service
                                                         Broker

                                                                            Publish
                                              Find                          UDDI, WSDL
                                            UDDI, WSDL



                                Service
                                                       Access                    Service
                                 User
                                                    SOAP, XML
                                                                                 Provider


                                   Each operation is governed by standard protocols:

•   Discovery and Integration: UDDI (Universal Description, Discovery and Integration)
•   Service Description: WSDL (Web Services Description Language)
•   Content Envelope: SOAP (Simple Object Access Protocol)
•   Data Encoding: XML (Extensible Modeling Language)
                                    Web Service Standards



                                              Service
                                              Broker

                                                        Publish
                                  Find                  UDDI, WSDL
                                 UDDI, WSDL



                       Service
                                         Access            Service
                        User
                                              SOAP
                                                           Provider


•   Each operation is governed by a separate standard.
•   Service providers publish services to a service broker.
•   Service users find the services and get access key from a service broker
•   With the key, users access the service.
               Web Service Actions and Components


                                           Service
                                           Broker

                                    Find                Publish



                     Service               Access              Service
                      User                                     Provider


•   Web Services architecture requires three operations: publish, find, and bind.
•   Service providers publish services to a service broker.
•   Service users find the services and get access key from a service broker
•   With the key, users access the service.
                                                           Diff Calculus




                                                                      Service
                                                                      Broker

                                                           Find                           Publish


                                       Service
                                                                    Access                           Service
                                        User
                                                                                                     Provider

•   Sun's slant, Engstrom says, is to provide a complete "stack" of Web services infrastructure, which includes development tools, application server
    platforms, and Sun's server hardware. In his own department, Engstrom says Sun is "all about making developers more productive—by doing the
    little things the standard doesn't address."
•   One example of this process is a tool to bring existing applications (such as SAP, PeopleSoft, and IBM CICS programs) into the Web-services
    arena with XML adapters. "A big issue for us is how to retrofit," Engstrom says. "Because the applications running today are not going away."
                                   Dvoy Web Services



                                            Service
                                            Broker
     getMeasureList->MeasureList
getMeasureRec(MeasureID)->MeasureRec
                                     Find                Publish



                     Service                Bind              Service
                      User                                    Provider
                               getDimensions(MeasureID)->DimIDList
                                   getDimTable(MeasureID, > DimTable
                           getFactTable(MeasureID, FactQuery> FactTable
                Web Services Enabled by Standards

Web Services operate ‘on top’ of many layers of Internet standards, TCP/IP, HTTP…
Web services also the use an array of its own standards - some still in development.
The data sharing standards for are to facilitate discovery, description and invocation



     Discovery                   Description                   Invocation
        UDDI                  WSDL, XSchema                       SOAP
        Disco                      XSD, XSI                       XML



On top of these Internet and Web Service Standards, we will need to develop our own:
   Naming conventions
   Metadata standards
   Uniform database schemata, etc
                            Major Service Categories
                    As envisioned by Open GiS Consortium (OGC)
                                                          OGC     Service class
                                                          0000
                                                          code   OGC web service [ROOT]
                                                          1000     Human interaction
                                                          1100        Portrayal
                                                          1110           Geospatial viewer
Service Category      Description                         1111              Animation
                                                          1112              Mosaicing
                                                          1113              Perspective
                                                          1114              Imagery
Human Interaction     Managing user interfaces,           1120           Geospatial symbol editor
                                                          1130           Feature generalization editor
                      graphics, presentation.             1200
                                                          1300
                                                                      Service interaction editor
                                                                      Registry browser
                                                          2000     Information Management
                                                          2100        Feature access
                                                          2200        Coverage access
Info. Management      Managing and storage of             2210           Real-time sensor
                                                          2300        Map access
                      metadata, schemas, datasets.        2400
                                                          2500
                                                                      Gazetteer
                                                                      Registry
                                                          2600        Sensor access
                                                          2700        Order handling
Workflow                                                  3000     Workflow
                      Services that support specific      3100        Chain definition
                                                          3200        Enactment
                      tasks or work-related activities.   3300
                                                          4000
                                                                      Subscription
                                                                   Processing
                                                          4100        Spatial
Processing            Data processing, computations;      4110
                                                          4120
                                                                         Coordinate conversion
                                                                         Coordinate transformation
                                                          4130           Representation conversion
                      no data storage or transfer         4140           Orthorectification
                                                          4150           Subsetting
                                                          4160           Sampling
                                                          4170           Feature manipulation
                                                          4180           Feature generalization
                                                          4190           Route determination
                                                          41A0           Positioning
Communication         Services that encode and transfer   4200        Thematic
                                                          4210           Geoparameter calculation
                      data across networks.               4220
                                                          4221
                                                                         Thematic classification
                                                                            Unsupervised
                                                          4222              Supervised
Sys. Management       Managing system components,         4230
                                                          4240
                                                                         Change detection
                                                                         Radiometric correction
                                                          4250           Geospatial analysis
                      applications, networks (access).    4260           Image processing
                                                          4261              Reduced resolution generation
                                                          4262              Image manipulation
                                                          4263              Image synthesis
                                                          4270           Geoparsing
                                                          4280           Geocoding
                                                          4300        Temporal
                                                          4310           Reference system transformation
                                                          4320           Subsetting
                                                          4330           Sampling
                                                          4340           Proximity analysis
                                                          4400        Metadata
                                                          4410           Statistical analysis
                                                          4420           Annotation
                                                          5000     Communication
                                                          5100        Encoding
                                                          5200        Format conversion
                                                          5300        Messaging
                                                          6000     System Management
                                          SOAP and WSDL
                          SOAP
  Envelope for message description and processing
  A set of encoding rules for expressing data types
  Convention for remote procedure calls and responses
  A binding convention for exchanging messages




                       WSDL
Message format
Ports

								
To top