Prev   Next

Part VI. OGSA-DAI for server developers

This part describes how to extend OGSA-DAI's functionality by developing activities, data resource plug-ins, presentation layers and security components. It assumes a lot of knowledge of OGSA-DAI concepts and programming in Java.

Table of Contents

97. An introduction to writing activities
97.1. What to consider when writing an activity
97.2. Writing client toolkit activity proxies
98. How to write a simple "hello world" activity with one output
98.1. How to write the "hello world" activity
98.2. How to deploy the "hello world" activity
98.3. How to write the "hello world" client proxy
98.4. How to write a client that uses the "hello world" activity
99. How to write a "hello name" activity with one input and output
99.1. How to write the "hello name" activity using the activity base class
99.2. How to write the "hello name" activity using the matched iterative activity class
99.3. How to deploy the "hello name" activity
99.4. How to write the "hello name" client proxy
99.5. How to write a client that uses the "hello name" activity
100. How to write a list reduction activity with one input, one list input and one output
100.1. How to write the list reduction activity using the matched iterative activity class
100.2. How to deploy the list reduction activity
100.3. How to write the list reduction client proxy
100.4. How to write a client that uses the list reduction activity
101. How to write a list processing activity with one input, one list input and one list output
101.1. How to write the list processing activity using the matched iterative activity class
101.2. How to deploy the list processing activity
101.3. How to write the list processing client proxy
101.4. How to write a client that uses the list processing activity
102. How to write a tuple processing activity with one input, one list input and one list output
102.1. Lists of tuples and tuple meta-data
102.2. TupleProcessing activity specification
102.3. How to write the tuple processing activity using the matched iterative activity class
102.4. How to deploy the tuple processing activity
102.5. How to write the tuple processing client proxy
102.6. How to write a client that uses the tuple processing activity
103. How to write an activity that uses a resource provided by an activity extension interface
103.1. How to write the list directory activity
103.2. How to deploy the list directory activity
103.3. How to write the list directory client proxy
103.4. How to write a client that uses the list directory activity
104. How to write a resource factory activity
CreateRelationalResource
104.1. Coding the relational resource factory activity
104.2. How to deploy the relational resource factory activity
104.3. How to write the relational resource factory client proxy
104.4. How to write a relational resource factory client
104.5. Removing the ability for the client to select the template
104.6. A warning about deploying resource factories
104.7. Extending the resource factory activity
105. Extending the resource factory activity
ExtendedCreateRelationalResource
105.1. Coding the extended relational resource factory activity
105.2. How to deploy the extended relational resource factory activity
105.3. How to write the extended relational resource factory client proxy
105.4. How to write an extended relational resource factory client
106. Activity types and choosing an activity base class
106.1. Matched activities
106.2. Iterative activities
106.3. Multiple input activities
106.4. Multiple output activities
106.5. Activity types and base classes
107. Passing information between activities and the activity framework using activity extension interfaces
108. How to handle errors in activities
108.1. How to handle errors in activities that are caused by the client
108.2. How to handle errors in activities that arise in the server
108.3. How to handle activity termination errors
108.4. How to handle errors in pipes
108.5. How to handle errors with binary and character inputs
108.6. An example
109. How to declare activity inputs for matched activities
109.1. Typed inputs
109.2. Typed optional inputs
109.3. Typed input lists
109.4. Typed optional input lists
109.5. Relational table meta data lists
109.6. Tuple lists
109.7. Character and binary data
109.8. Binary and character data
109.9. Character and binary data lists
109.10. Binary and character data lists
109.11. Nested typed inputs
109.12. Nested character and binary data
109.13. Nested binary and character data
109.14. String inputs
109.15. String input lists
109.16. Nested string inputs
110. Choosing the client toolkit activity proxy base class
111. Client toolkit activity proxies and activity inputs and outputs
111.1. Setting up inputs and outputs
111.2. How to allow activities to be connected to other activities
111.3. How to allow clients to provide input values
111.4. Validation of inputs and outputs
112. Client toolkit activity proxies and exposing data for clients
112.1. Simple types
112.2. Lists of simple types
112.3. Lists of character arrays
112.4. Lists of byte arrays
112.5. Parsing the data
112.6. Activities with multiple outputs of the same name
112.7. How does a client proxy activity get access to the data in a request status?
113. An introduction to writing data resources
113.1. When is a data resource created?
113.2. Consider providing a data resource state wrapper
113.3. Provide the resource ID
113.4. Support resource destruction
113.5. Implement the resource functionality
113.6. Provide a resource accessor
113.7. Develop resource properties
113.8. Deploy your data resource
113.9. Summary of key points
113.10. Case study
114. How to write a data resource - case-study
114.1. About the generic data resource state object
114.2. Write a data resource implementation class
114.3. Write a data resource state wrapper
114.4. Provide the resource ID
114.5. Support resource destruction
114.6. Provide a resource accessor
114.7. Implement the resource functionality
114.8. Summary of key points
115. How to support persisted resource properties
115.1. How to add persisted resource properties in-code
116. How to implement on-demand resource properties
117. How to implement on-demand resource properties that read their values from files
117.1. How to use a file to store a resource property value
117.2. Abstracting away from files
118. How to debug OGSA-DAI server components
118.1. How to log debugging information
118.2. How to debug using Eclipse
119. How to register message bundles
119.1. How to create a message bundle
119.2. How to register a message bundle
120. How to log internationalized messages
120.1. How to define message IDs
120.2. How to log messages
120.3. How to define error IDs
121. How to log exceptions
122. How to write OGSA-DAI compliant exceptions
122.1. Why write OGSA-DAI compliant exceptions?
122.2. How to write a new exception
122.3. How to associate an exception with an error ID
122.4. How to write a constructor for your exception
122.5. How to chain exceptions
123. OGSA-DAI server context
123.1. Mandatory contents
123.2. Optional contents
124. How to use the OGSA-DAI context to share components throughout the OGSA-DAI server
124.1. How to add components to the OGSA-DAI context in-code
124.2. How to add components to the OGSA-DAI context via a configuration file
125. Security contexts
125.1. Security contexts
125.2. Security context interface
125.3. Default OGSA-DAI Axis security context
126. How to use security contexts in your components
127. How to write a login provider
127.1. What are login providers
127.2. Default simple file-based login provider
127.3. How to write a login provider
127.4. How to use a login providers
128. How to monitor activity inputs
128.1. Using block reader listeners
128.2. Using activity input listeners
129. How to transform workflows before they are executed
129.1. Example code
129.2. How to configure workflow transformations in OGSA-DAI
130. How to write a monitoring framework
130.1. What is a monitoring framework?
130.2. Default monitoring frameworks
130.3. How to write a monitoring framework
130.4. Monitoring frameworks and resource-related events
130.5. How to deploy a monitoring framework
131. How to write a presentation layer
I. Appendix - OGSA-DAI server APIs UML
J. Appendix - Activity development guidelines
J.1. Activity class names
J.2. Activity output names
J.3. Activity error handling
J.4. JavaDoc
J.5. Client toolkit activity proxies
Prev   Next
Chapter 96. Monitoring client-server communications with Apache Axis TCPMon Home Chapter 97. An introduction to writing activities