ICT ALMA Common Software

Space shortcuts

Page tree

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 2 Next »

Introduction

On this day we will focus on implementing the logic for our component. By the end of the day, we expect the groups to:

  • Learn the details of their interfaces and the interaction with other components as described in the first session and ACS Workshop - Project Details confluence page
  • Learn about lifecycle methods
  • Learn how to interact with other components
  • Logic implementation on the methods
  • Adding logging to the implementations
  • Start the error handling (catch and throw) of ACS exceptions

Guides

As a guide, we're going to show you sample code for logging, to define exceptions, throw and catch exceptions.

Component Details

The component details will be presented in the first session from ACS Workshop - Project Details page to describe the interfaces and interactions of the project's components.

Lifecycle Methods

The ACS components have a couple of methods associated with its lifecycle that automatically gets executed at different phases of the component initialization and deactivation.

  • initialize(): 
    • Called to give the component time to initialize itself. For instance, the component could retrieve connections, read in configuration files/parameters, build up in-memory tables, etc.
    • In fact, this method might be called quite some time before functional requests can be sent to the component
  • execute():

    • Called after initialize to tell the component that it has to be ready to accept incoming functional calls any time

  • cleanUp():

    • Called after the last functional call to the component has finished

    • The component should then orderly release resources etc.

  • aboutToAbort():

    • Called when due to some error condition the component is about to be forcefully removed some unknown amount of time later (usually not very much...).

    • The component should make an effort to die as neatly as possible

    • Because of its urgency, this method will be called asynchronously to the execution of any other method of the component

Implementing Lifecycle functionality

  • Python

    class <name>(...):
    ...
    def initialize():
        #Assign variable values
        #Initialize data
        ...
    def execute():
        #Retrieve components
        #Consider ready to receive calls (Change states if appropriate)
        ...
    def cleanUp():
        #Release components
        #Release resources
        ...
    def aboutToAbort():
        #Do any critical clean up
        #Continue with less critical stuff such as releasing components and other activities similar to cleanUp
        ...
    ...

  • Java

    public class <name> ... {
    ...
    public void initialize() {
        //Assign variable values
        //Initialize data
        ...
    }
    public void execute() {
        //Retrieve components
        //Consider ready to receive calls (Change states if appropriate)
        ...
    }
    public void cleanUp() {
        //Release components
        //Release resources
        ...
    }
    public void aboutToAbort() {
        //Do any critical clean up
        //Continue with less critical stuff such as releasing components and other activities similar to cleanUp
        ...
    }
    ...
}

  • C++

    class <name> : ... {
    ...
    void initialize();
    void execute();
    void cleanUp();
    void aboutToAbort();
    ...
};

    void <name>::initialize() {
    //Assign variable values
    //Initialize data
    ...
}


void <name>::execute() {
    //Retrieve components
    //Consider ready to receive calls (Change states if appropriate)
    ...
}


void <name>::cleanUp() {
    //Release components
    //Release resources
    ...
}


void <name>::aboutToAbort() {
    //Do any critical clean up
    //Continue with less critical stuff such as releasing components and other activities similar to cleanUp
    ...
}






  • No labels