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

95. An introduction to writing activities
95.1. What to consider when writing an activity
95.2. Writing client toolkit activity proxies
96. How to write a simple "hello world" activity with one output
96.1. How to write the "hello world" activity
96.2. How to deploy the "hello world" activity
96.3. How to write the "hello world" client proxy
96.4. How to write a client that uses the "hello world" activity
97. How to write a "hello name" activity with one input and output
97.1. How to write the "hello name" activity using the activity base class
97.2. How to write the "hello name" activity using the matched iterative activity class
97.3. How to deploy the "hello name" activity
97.4. How to write the "hello name" client proxy
97.5. How to write a client that uses the "hello name" activity
98. How to write a list reduction activity with one input, one list input and one output
98.1. How to write the list reduction activity using the matched iterative activity class
98.2. How to deploy the list reduction activity
98.3. How to write the list reduction client proxy
98.4. How to write a client that uses the list reduction activity
99. How to write a list processing activity with one input, one list input and one list output
99.1. How to write the list processing activity using the matched iterative activity class
99.2. How to deploy the list processing activity
99.3. How to write the list processing client proxy
99.4. How to write a client that uses the list processing activity
100. How to write a tuple processing activity with one input, one list input and one list output
100.1. Lists of tuples and tuple meta-data
100.2. TupleProcessing activity specification
100.3. How to write the tuple processing activity using the matched iterative activity class
100.4. How to deploy the tuple processing activity
100.5. How to write the tuple processing client proxy
100.6. How to write a client that uses the tuple processing activity
101. How to write an activity that uses a resource provided by an activity extension interface
101.1. How to write the list directory activity
101.2. How to deploy the list directory activity
101.3. How to write the list directory client proxy
101.4. How to write a client that uses the list directory activity
102. How to write a resource factory activity
CreateRelationalResource
102.1. Coding the relational resource factory activity
102.2. How to deploy the relational resource factory activity
102.3. How to write the relational resource factory client proxy
102.4. How to write a relational resource factory client
102.5. Removing the ability for the client to select the template
102.6. A warning about deploying resource factories
102.7. Extending the resource factory activity
103. Extending the resource factory activity
ExtendedCreateRelationalResource
103.1. Coding the extended relational resource factory activity
103.2. How to deploy the extended relational resource factory activity
103.3. How to write the extended relational resource factory client proxy
103.4. How to write an extended relational resource factory client
104. Activity types and choosing an activity base class
104.1. Matched activities
104.2. Iterative activities
104.3. Multiple input activities
104.4. Multiple output activities
104.5. Activity types and base classes
105. Passing information between activities and the activity framework using activity extension interfaces
106. How to handle errors in activities
106.1. How to handle errors in activities that are caused by the client
106.2. How to handle errors in activities that arise in the server
106.3. How to handle activity termination errors
106.4. How to handle errors in pipes
106.5. How to handle errors with binary and character inputs
106.6. An example
107. How to declare activity inputs for matched activities
107.1. Typed inputs
107.2. Typed optional inputs
107.3. Typed input lists
107.4. Typed optional input lists
107.5. Relational table meta data lists
107.6. Tuple lists
107.7. Character and binary data
107.8. Binary and character data
107.9. Character and binary data lists
107.10. Binary and character data lists
107.11. Nested typed inputs
107.12. Nested character and binary data
107.13. Nested binary and character data
107.14. String inputs
107.15. String input lists
107.16. Nested string inputs
108. Choosing the client toolkit activity proxy base class
109. Client toolkit activity proxies and activity inputs and outputs
109.1. Setting up inputs and outputs
109.2. How to allow activities to be connected to other activities
109.3. How to allow clients to provide input values
109.4. Validation of inputs and outputs
110. Client toolkit activity proxies and exposing data for clients
110.1. Simple types
110.2. Lists of simple types
110.3. Lists of character arrays
110.4. Lists of byte arrays
110.5. Parsing the data
110.6. Activities with multiple outputs of the same name
110.7. How does a client proxy activity get access to the data in a request status?
111. An introduction to writing data resources
111.1. When is a data resource created?
111.2. Consider providing a data resource state wrapper
111.3. Provide the resource ID
111.4. Support resource destruction
111.5. Implement the resource functionality
111.6. Provide a resource accessor
111.7. Develop resource properties
111.8. Deploy your data resource
111.9. Summary of key points
111.10. Case study
112. How to write a data resource - case-study
112.1. About the generic data resource state object
112.2. Write a data resource implementation class
112.3. Write a data resource state wrapper
112.4. Provide the resource ID
112.5. Support resource destruction
112.6. Provide a resource accessor
112.7. Implement the resource functionality
112.8. Summary of key points
113. How to support persisted resource properties
113.1. How to add persisted resource properties in-code
114. How to implement on-demand resource properties
115. How to implement on-demand resource properties that read their values from files
115.1. How to use a file to store a resource property value
115.2. Abstracting away from files
116. How to debug OGSA-DAI server components
116.1. How to log debugging information
116.2. How to debug using Eclipse
117. How to register message bundles
117.1. How to create a message bundle
117.2. How to register a message bundle
118. How to log internationalized messages
118.1. How to define message IDs
118.2. How to log messages
118.3. How to define error IDs
119. How to log exceptions
120. How to write OGSA-DAI compliant exceptions
120.1. Why write OGSA-DAI compliant exceptions?
120.2. How to write a new exception
120.3. How to associate an exception with an error ID
120.4. How to write a constructor for your exception
120.5. How to chain exceptions
121. OGSA-DAI server context
121.1. Mandatory contents
121.2. Optional contents
122. How to use the OGSA-DAI context to share components throughout the OGSA-DAI server
122.1. How to add components to the OGSA-DAI context in-code
122.2. How to add components to the OGSA-DAI context via a configuration file
123. Security contexts
123.1. Security contexts
123.2. Security context interface
124. How to use security contexts in your components
125. How to write a login provider
125.1. What are login providers
125.2. Default simple file-based login provider
125.3. How to write a login provider
125.4. How to use a login providers
126. How to monitor activity inputs
126.1. Using block reader listeners
126.2. Using activity input listeners
127. How to transform workflows before they are executed
127.1. Example code
127.2. How to configure workflow transformations in OGSA-DAI
128. How to write a monitoring framework
128.1. What is a monitoring framework?
128.2. Default monitoring frameworks
128.3. How to write a monitoring framework
128.4. Monitoring frameworks and resource-related events
128.5. How to deploy a monitoring framework
129. How to write a presentation layer
H. Appendix - OGSA-DAI server APIs UML
I. Appendix - Activity development guidelines
I.1. Activity class names
I.2. Activity output names
I.3. Activity error handling
I.4. JavaDoc
I.5. Client toolkit activity proxies
Prev   Next
Chapter 94. Monitoring client-server communications with Apache Axis TCPMon Home Chapter 95. An introduction to writing activities