0%

Learn Tuxedo by developing solutions in Python for real-world problems

Key Features

  • Understand Tuxedo through a modern lens by experimenting with Python code
  • Boost your productivity by using Python programming to perform common Tuxedo programming tasks
  • Manage real-world integration tasks with small Python programs

Book Description

Despite being developed in the 1980s, Oracle Tuxedo still runs a significant part of critical infrastructure and is not going away any time soon. Modernizing Oracle Tuxedo Applications with Python will help you get to grips with the most important Tuxedo concepts by writing Python code.

The book starts with an introduction to Oracle Tuxedo and guides you in installing its latest version and Python bindings for Tuxedo on Linux. You'll then learn how to build your first server and client, configure Tuxedo, and start running an application. As you advance, you'll understand load balancing and work with the BBL server, which is at the heart of a Tuxedo application. This Tuxedo book will also cover Boolean expressions and different ways to export Tuxedo buffers for storage and transmission, before showing you how to implement servers and clients and use the management information base to change the configuration dynamically. Once you've learned how to configure Tuxedo for transactions and control them in application code, you'll discover how to use the store-and-forward functionality to reach destinations and use an Oracle database from a Tuxedo application.

By the end of this Oracle Tuxedo book, you'll be able to perform common Tuxedo programming tasks with Python and integrate Tuxedo applications with other parts of modern infrastructure.

What you will learn

  • Understand Oracle Tuxedo as a microservice platform
  • Develop Oracle Tuxedo applications using Python 3
  • Perform administration tasks programmatically with Python 3
  • Extract Tuxedo statistics for monitoring application performance
  • Integrate Tuxedo into the modern software ecosystem
  • Understand how distributed transactions work in Tuxedo

Who this book is for

This book is for developers who are new to Tuxedo and are looking to develop a new modern front-end or integrate Tuxedo in their applications. The book will also help experienced Tuxedo, C or COBOL developers to improve their productivity and QA engineers to automate Tuxedo application tests. Beginner-level knowledge of Python and Linux shell is required before getting started with this book.

Table of Contents

  1. Modernizing Oracle Tuxedo Applications with Python
  2. Contributors
  3. About the author
  4. About the reviewer
  5. Preface
    1. Who this book is for
    2. What this book covers
    3. To get the most out of this book
    4. Download the example code files
    5. Code in Action
    6. Download the color images
    7. Conventions used
    8. Get in touch
    9. Reviews
  6. Section 1: The Basics
  7. Chapter 1: Introduction and Installing Tuxedo
    1. Technical requirements
    2. Introducing Tuxedo
    3. A Unix-inspired application server
    4. Understanding Tuxedo through modern lens
    5. Availability
    6. Performance
    7. Services
    8. Polyglot development
    9. Transactions
    10. XATMI
    11. Tuxedo today
    12. Reviewing the need for Python
    13. Installing Tuxedo and Python
    14. Summary
    15. Questions
    16. Further reading
  8. Chapter 2: Building Your First Tuxedo Application
    1. Technical requirements
    2. Creating a server
    3. Creating a client
    4. Creating a configuration file for Tuxedo
    5. RESOURCES section
    6. MACHINES section
    7. GROUPS section
    8. SERVERS section
    9. TUXCONFIG
    10. Starting the application
    11. Administering the application
    12. Stopping the application
    13. Summary
    14. Questions
    15. Further reading
  9. Chapter 3: Tuxedo in Detail
    1. Technical requirements
    2. Learning what BBL is
    3. Understanding queues
    4. Configuring queues
    5. Introducing services and load balancing
    6. Exploring the MSSQ configuration
    7. Exploring the SSSQ configuration
    8. Summary
    9. Questions
    10. Further reading
  10. Chapter 4: Understanding Typed Buffers
    1. Technical requirements
    2. Introducing typed buffers
    3. Using STRING typed buffers
    4. Using CARRAY typed buffers
    5. Using FML32 typed buffers
    6. Using FML32 in Python
    7. Working with field identifiers
    8. Defining fields
    9. Displaying FML32 typed buffers
    10. Writing FML32 expressions
    11. Importing and exporting typed buffers
    12. Summary
    13. Questions
    14. Further reading
  11. Section 2: The Good Bits
  12. Chapter 5: Developing Servers and Clients
    1. Technical requirements
    2. Writing to ULOG
    3. Understanding server lifetime
    4. Understanding the advertising of services
    5. Receiving inputs in a service
    6. Returning outputs from a service
    7. Optimizing tpreturn
    8. Understanding client lifetime
    9. Calling a service
    10. Joining the application
    11. Summary
    12. Questions
    13. Further reading
  13. Chapter 6: Administering the Application Using MIBs
    1. Technical requirements
    2. Introducing MIB
    3. Developing multiple versions of an application
    4. Using tpadmcall to create TUXCONFIG
    5. Upgrading the servers
    6. Reconfiguring the application
    7. Monitoring the application
    8. Monitoring queues
    9. Summary
    10. Questions
    11. Further reading
  14. Chapter 7: Distributed Transactions
    1. Technical requirements
    2. Configuring Tuxedo for transactions
    3. Managing transactions
    4. Understanding timeouts
    5. Blocking timeouts
    6. Summary
    7. Questions
    8. Further reading
  15. Chapter 8: Using Tuxedo Message Queue
    1. Technical requirements
    2. Creating and configuring queues
    3. Using queues
    4. Forwarding messages
    5. Summary
    6. Questions
    7. Further reading
  16. Chapter 9: Working with Oracle Database
    1. Technical requirements
    2. Preparing the database
    3. Using local transactions with Oracle Database
    4. Using global transactions with Oracle Database
    5. Multi-threading and global transactions
    6. Summary
    7. Questions
    8. Further reading
  17. Section 3: Integrations
  18. Chapter 10: Accessing the Tuxedo Application
    1. Technical requirements
    2. Using the Tuxedo Workstation client
    3. Configuring Workstation Listener
    4. Exposing Tuxedo services as web services
    5. Summary
    6. Questions
    7. Further reading
  19. Chapter 11: Consuming External Services in Tuxedo
    1. Technical requirements
    2. Consuming services
    3. Adding fault tolerance for external services
    4. Handling stateful protocols
    5. Summary
    6. Questions
  20. Chapter 12: Modernizing the Tuxedo Applications
    1. Technical requirements
    2. Introducing NATS
    3. Developing a basic NATS application
    4. Developing a bi-directional gateway
    5. Summary
    6. Questions
    7. Further reading
  21. Assessments
    1. Chapter 1
    2. Chapter 2
    3. Chapter 3
    4. Chapter 4
    5. Chapter 5
    6. Chapter 6
    7. Chapter 7
    8. Chapter 8
    9. Chapter 9
    10. Chapter 10
    11. Chapter 11
    12. Chapter 12
    13. Why subscribe?
  22. Other Books You May Enjoy
    1. Packt is searching for authors like you
    2. Leave a review - let other readers know what you think
3.144.84.155