Page History

class Console:
      <constructor>(name=<name-str>,
                    domain=(optional) domain string for console's AMQP address,
                    notifier=<class Notifier>,
                    reply_timeout=<default for all blocking calls>,
                    agent_timeout=<default timeout for agent heartbeat>,
                    subscription_duration=<default lifetime of a subscription>)

      .destroy(timeout=None): Must be called to release Console's resources.

      .add_connection(QPID Connection): Connect the console to the AMQP cloud.

      .remove_connection(conn): Remove the AMQP connection from the console.  Un-does the add_connection() operation, and
          releases any agents associated with the connection.  All blocking methods are unblocked and given a failure status.
          All outstanding asynchronous operations are cancelled without producing WorkItems.

      .get_address():
          Get the AMQP address this Console is listening to (type str).

      .find_agent( name string, [timeout] ): Query for the presence of a specific agent in the QMF domain. Returns a
          class Agent if the agent is present.  If the agent is not already known to the console, this call will send
          a query for the agent and block (with default timeout override) waiting for a response.

      .enable_agent_discovery( [Query] ): Called to enable the asynchronous Agent Discovery process. Once enabled, AGENT_ADDED
          and AGENT_DELETED work items can arrive on the WorkQueue.  If a query is supplied, it will be used to filter agent
          notifications.

      .disable_agent_discovery(): Called to disable the async Agent Discovery process enabled by calling enable_agent_discovery().

      .get_workitem_count(): Returns the count of pending WorkItems that can be retrieved.

      .get_next_workitem([timeout=0]): Obtains the next pending work item, or None if none available.

      .release_workitem(wi): Releases a WorkItem instance obtained by getNextWorkItem(). Called when the application has finished
          processing the WorkItem.

      .get_agents(): Returns a list of available agents (class Agent)

      .get_agent( name string ): Return the class Agent for the named agent, if known.

      .get_packages( [class Agent] ): Returns a list of the names of all known packages.  If an optional Agent is provided, then
          only those packages available from that Agent are returned.

      .get_classes( [class Agent] ):  Returns a list of SchemaClassIds for all available Schema.  If an optional Agent is provided,
          then the returned SchemaClassIds are limited to those Schema known to the given Agent.

      .get_schema( class SchemaClassId [, class Agent]): Return a list of all available class SchemaClass across all known agents.
          If an optional Agent is provided, restrict the returned schema to those supported by that Agent.

      .get_objects( _SchemaClassId= | _package=, _class= |
                    _object_identifier=,
                   [timeout=],
                   [list-of-class-Agent] ): perform a blocking query for QmfConsoleObjects.  Returns a list (possibly empty) of matching
           objects. The selector for the query may be either:
           * class SchemaClassId - all objects whose schema match the schema identified by _SchemaClassId parameter.
           * package/class name - all objects whose schema are contained by the named package and class.
           * the object identified by _object_identifier
           This method will block until all known agents reply, or the timeout expires. Once the timeout expires, all
           data retrieved to date is returned. If a list of agents is supplied, then the query is sent to only those agents.

      .create_subscription( agent, class Query, app_context [, reply_handle] [, timeout] ): creates a subscription to the agent
          using the given Query.  The app_context is an application-provided handle that will accompany each subscription update
          send from the agent.  Subscription updates will appear as SUBSCRIPTION_INDICATION WorkItems on the Console's work queue.
          This method may be called asynchronously by providing a reply_handle argument.  When called asynchronously, the result
          of this method call is returned in a SUBSCRIPTION_RESPONSE WorkItem.  Timeout can be used to override the console's
          default reply timeout.  When called synchronously, this method returns a class SubscriptionParams object containing
          the result of the subscription request.

      .refresh_subscription( SubscriptionId [,reply_handle] [, duration=<secs>timeout] ): (re)activatesrenews a subscription identified by SubscriptionId.  UsesThis
 the console default duration
      method may be called unlessasynchronously theby durationproviding isa explicitlyreply_handle specified.

argument. When called asynchronously, the result
           .cancel_subscription( SubscriptionId ): terminates the given subscription.
of this method call is returned in a SUBSCRIPTION_RESPONSE WorkItem.  Timeout can be used to override the console's
          default reply timeout.  When called synchronously, this method returns a class SubscriptionParams object containing
          the result of the subscription request.

      .cancel_subscription( SubscriptionId ): terminates the given subscription.

class AgentExternal(Agent):
      <constructor>(name=<name-string>,
                    domain=(optional) domain string for agent's AMQP address,
                    notifier= class Notifier,
                    heartbeat_interval=30,
                    max_msg_size=65535)
      .alloc_object_id( name="object name"): indicate to QMF that the named object is available to be managed.  Once this method returns,
          the agent will service requests from consoles referencing this data.
      .free_object_id( name="object name" ): indicate to QMF that the named object is no longer available to be managed.
      .query_response( handle=<handle from WorkItem>,
                      class QmfAgentObject): send a managed object in reply to a received query. Note that ownership of the object
          instance is returned to the caller on return from this call.
      .query_complete( handle=<handle from WorkItem>,
                      result=<status code> ):  Indicate to the agent that the application has completed processing a query request.
          Zero or more calls to the queryResponse() method should be invoked before calling query_complete().  If the query should
          fail - for example, due to authentication error - the result should be set to a non-zero error code ?TBD?.

      .subscription_response( handle=<handle from WorkItem>,
                             result=<status code>subscription_handle=<agent-provided context>,
                             subscriptionexpire_handle=<application context>): Indicate the status of a subscription request.  If result
time=<datetime>,
                             error=<QmfData>): Indicate the result of a subscription request or subscription refresh.
          If replying to isa sucessful zerosubscription, the Agent application must provide a unique subscription is accepted by the application, and an subscription handle is provided.  This handle must
  _handle.  If replying
          to a sucessful subscription refresh, the original subscription_handle must be supplied.  expire_time should be set to
        be passed tothe theUTC applicationtimestamp when the agentsubscription next unsubscribes.

iff there is no associated
          object (a method call against the agent itself).
      .get_args(): returns a map of input arguments for the method. Arguments
          are in "name"=<value> pairs.  Returns None if no arguments are supplied.
      .get_user_id(): returns authenticated user id of caller if present, else None.