congress.policy_engines.agnostic module¶

class congress.policy_engines.agnostic.DseRuntime(name)¶

Bases: congress.policy_engines.agnostic.Runtime, congress.dse2.data_service.DataService

create_default_policies()¶

execute_action(service_name, action, action_args)¶

Event handler for action execution.

Parameters:	service_name – openstack service to perform the action on, e.g. ‘nova’, ‘neutron’ action – action to perform on service, e.g. an API call action_args – positional-args and named-args in format: {‘positional’: [‘p_arg1’, ‘p_arg2’], ‘named’: {‘name1’: ‘n_arg1’, ‘name2’: ‘n_arg2’}}.

extend_schema(service_name, schema)¶

get_snapshot(table_name)¶

Method that returns the current data for the given table.

Should be overridden.

initialize_table_subscriptions()¶

Initialize table subscription.

Once policies have all been loaded, this function subscribes to all the necessary tables. See UPDATE_TABLE_SUBSCRIPTIONS as well.

on_first_subs(tables)¶

handler for policy table subscription

when a previously non-subscribed table gains a subscriber, register a trigger for the tables and publish table results when there is updates.

on_no_subs(tables)¶

Remove triggers when tables have no subscribers.

process_policy_update(events, persistent=False)¶

pub_policy_result(table, olddata, newdata)¶

Callback for policy table triggers.

receive_data(publisher, table, data, is_snapshot=False)¶

Event handler for when a dataservice publishes data.

That data can either be the full table (as a list of tuples) or a delta (a list of Events).

receive_data_full(publisher, table, data)¶

Handler for when dataservice publishes full table.

receive_data_update(publisher, table, data)¶

Handler for when dataservice publishes a delta.

receive_policy_update(msg)¶

service_exists(service_name)¶

set_schema(name, schema, complete=False)¶

Set the schema for module NAME to be SCHEMA.

set_synchronizer()¶

start()¶

Start the DataService.

This method is called by a DseNode before any RPCs are invoked.

stop()¶

Stop the DataService.

This method is called by a DseNode when the DataService instance is no longer needed. No RPCs will invoked on stopped DataServices.

update_table_subscriptions(oldtables, newtables)¶

Update table subscription.

Change the subscriptions from OLDTABLES to NEWTABLES, ensuring to load all the appropriate services.

class congress.policy_engines.agnostic.DseRuntimeEndpoints(dse)¶

Bases: object

RPC endpoints exposed by DseRuntime.

delete_policy(context, name, disallow_dangling_refs=False)¶

execute_action(context, service_name, action, action_args)¶

get_row_data(context, table_id, source_id, trace=False)¶

get_status(context, source_id, params)¶

get_tablename(context, source_id, table_id)¶

get_tablenames(context, source_id)¶

initialize_datasource(context, name, schema)¶

persistent_create_policy(context, name=None, id_=None, abbr=None, kind=None, desc=None)¶

persistent_create_policy_with_rules(context, policy_rules_obj)¶

persistent_delete_policy(context, name_or_id)¶

persistent_delete_rule(context, id_, policy_name_or_id)¶

persistent_get_policies(context)¶

persistent_get_policy(context, id_)¶

persistent_get_rule(context, id_, policy_name)¶

persistent_get_rules(context, policy_name)¶

persistent_insert_rule(context, policy_name, str_rule, rule_name, comment)¶

persistent_load_policies(context)¶

simulate(context, query, theory, sequence, action_theory, delta=False, trace=False, as_list=False)¶

sync_one_policy(context, policy_name)¶

synchronize_policies(context)¶

class congress.policy_engines.agnostic.ExecutionLogger¶

Bases: object

content()¶

critical(msg, *args)¶

debug(msg, *args)¶

empty()¶

error(msg, *args)¶

info(msg, *args)¶

warn(msg, *args)¶

class congress.policy_engines.agnostic.ExperimentalRuntime¶

Bases: congress.policy_engines.agnostic.Runtime

access_control(action, support='')¶

Event handler for making access_control request.

ACTION is an atom describing a proposed action instance. SUPPORT is any data that should be assumed true when posing the query. Returns True iff access is granted.

execute(action_sequence)¶

Event handler for execute:

Execute a sequence of ground actions in the real world.

execute_obj(actions)¶

Executes the list of ACTION instances one at a time.

For now, our execution is just logging.

execute_string(actions_string)¶

explain(query, tablenames=None, find_all=False, target=None)¶

Event handler for explanations.

Given a ground query and a collection of tablenames that we want the explanation in terms of, return proof(s) that the query is true. If FIND_ALL is True, returns list; otherwise, returns single proof.

explain_obj(query, tablenames, find_all, theory)¶

explain_string(query_string, tablenames, find_all, theory)¶

explain_tuple(tuple, tablenames, find_all, theory)¶

remediate(formula)¶

Event handler for remediation.

remediate_obj(formula)¶

Find a collection of action invocations

That if executed result in FORMULA becoming false.

remediate_string(policy_string)¶

remediate_tuple(tuple, theory)¶

class congress.policy_engines.agnostic.PolicySubData(trigger)¶

Bases: object

changes()¶

trigger()¶

class congress.policy_engines.agnostic.Runtime¶

Bases: object

Runtime for the Congress policy language.

Only have one instantiation in practice, but using a class is natural and useful for testing.

ACTION_THEORY = 'action'¶

DEFAULT_THEORY = 'classification'¶

add_policy_obj_to_runtime(policy_obj)¶

Add policy obj to runtime

arity(table, theory, modal=None)¶

Return number of columns for TABLE in THEORY.

TABLE can include the policy name. <policy>:<table> THEORY is the name of the theory we are asking. MODAL is the value of the modal, if any.

assert_policy_exists(policy_name)¶

Checks if policy exists or not.

Param:	policy_name: policy name
Returns:	True, if policy exists
Raises:	PolicyRuntimeException, if policy doesn’t exist.

construct_policy_obj(name, abbr=None, kind=None, id_=None, desc=None, owner=None)¶

Construct policy obj

content(target=None)¶

Event handler for querying content().

create_policy(name, abbr=None, kind=None, id_=None, desc=None, owner=None)¶

Create a new policy and add it to the runtime.

ABBR is a shortened version of NAME that appears in traces. KIND is the name of the datastructure used to represent a policy.

debug_mode()¶

delete(formula, target=None)¶

Event handler for arbitrary deletion (rules and facts).

delete_policy(name_or_id, disallow_dangling_refs=False)¶

Deletes policy with name NAME or throws KeyError or DanglingRefs.

find_subpolicy(required_tables, prohibited_tables, output_tables, target=None)¶

Return a subset of rules in @theory.

@required_tables is the set of tablenames that a rule must depend on. @prohibited_tables is the set of tablenames that a rule must NOT depend on. @output_tables is the set of tablenames that all rules must support.

get_action_names(target)¶

Return a list of the names of action tables.

get_row_data(table_id, source_id, trace=False)¶

get_status(source_id, params)¶

get_tablename(source_id, table_id)¶

get_tablenames(source_id)¶

get_target(name)¶

get_target_name(name)¶

Resolve NAME to the name of a proper policy (even if it is None).

Raises PolicyException there is no such policy.

get_tracer()¶

Return (Runtime’s tracer, dict of tracers for each theory).

Useful so we can temporarily change tracing.

initialize_datasource(name, schema)¶

Initializes datasource by creating policy and setting schema.

initialize_tables(tablenames, facts, target=None)¶

Event handler for (re)initializing a collection of tables

@facts must be an iterable containing compile.Fact objects.

insert(formula, target=None)¶

Event handler for arbitrary insertion (rules and facts).

parse(string)¶

parse1(string)¶

persistent_create_policy(name, id_=None, abbr=None, kind=None, desc=None, db_session=None)¶

persistent_create_policy_with_rules(policy_rules_obj)¶

persistent_delete_policy(name_or_id)¶

persistent_delete_rule(id_, policy_name_or_id)¶

persistent_get_policies()¶

persistent_get_policy(id_)¶

persistent_get_rule(id_, policy_name)¶

Return data for rule with id_ in policy_name.

persistent_get_rules(policy_name)¶

Return data for all rules in policy_name.

persistent_insert_rule(policy_name, str_rule, rule_name, comment)¶

persistent_insert_rules(policy_name, rules, create_policy=False, id_=None, abbr=None, kind=None, desc=None)¶

Insert and persists rule into policy_name.

persistent_load_policies()¶

Load policies from database.

persistent_load_rules()¶

Load all rules from the database.

policy(target=None)¶

Event handler for querying policy.

policy_names()¶

Returns list of policy names.

policy_object(name=None, id=None)¶

Return policy by given name. Raises KeyError if does not exist.

policy_type(name)¶

Return type of policy NAME. Throws KeyError if does not exist.

process_policy_update(events, persistent=False)¶

production_mode()¶

project(sequence, policy_theory, action_theory)¶

Apply the list of updates SEQUENCE.

Apply the list of updates SEQUENCE, where actions are described in ACTION_THEORY. Return an update sequence that will undo the projection.

SEQUENCE can include atom insert/deletes, rule insert/deletes, and action invocations. Projecting an action only simulates that action’s invocation using the action’s description; the results are therefore only an approximation of executing actions directly. Elements of SEQUENCE are just formulas applied to the given THEORY. They are NOT Event()s.

SEQUENCE is really a program in a mini-programming language–enabling results of one action to be passed to another. Hence, even ignoring actions, this functionality cannot be achieved by simply inserting/deleting.

project_updates(delta, theory)¶

Project atom/delta rule insertion/deletion.

Takes an atom/rule DELTA with update head table (i.e. ending in + or -) and inserts/deletes, respectively, that atom/rule into THEORY after stripping the +/-. Returns None if DELTA had no effect on the current state.

register_trigger(tablename, callback, policy=None, modal=None)¶

Register CALLBACK to run when table TABLENAME changes.

rename_policy(oldname, newname)¶

Renames policy OLDNAME to NEWNAME or raises KeyError.

reserved_tablename(name)¶

resolve_conflicts(atoms)¶

If p+(args) and p-(args) are present, removes the p-(args).

select(query, target=None, trace=False)¶

Event handler for arbitrary queries.

Returns the set of all instantiated QUERY that are true.

set_schema(name, schema, complete=False)¶

Set the schema for module NAME to be SCHEMA.

set_tracer(tracer)¶

simulate(query, theory, sequence, action_theory, delta=False, trace=False, as_list=False)¶

Event handler for simulation.

Param:	query is a string/object to query after
Param:	theory is the policy to query
Param:	sequence is a string/iter of updates to state/policy or actions
Param:	action_theory is the policy that contains action descriptions
Param:	delta indicates whether to return changes to query caused by sequence
Param:	trace indicates whether to include a string description of the implementation. When True causes the return value to be the tuple (result, trace).
Param:	as_list controls whether the result is forced to be a list of answers

Returns a list of instances of query. If query/sequence are strings the query instance list is a single string (unless as_list is True in which case the query instance list is a list of strings). If query/sequence are objects then the query instance list is a list of objects.

The computation of a query given an action sequence. That sequence can include updates to atoms, updates to rules, and action invocations. Returns a collection of Literals (as a string if the query and sequence are strings or as a Python collection otherwise). If delta is True, the return is a collection of Literals where each tablename ends with either + or - to indicate whether that fact was added or deleted. Example atom update: q+(1) or q-(1) Example rule update: p+(x) :- q(x) or p-(x) :- q(x) Example action invocation:

create_network(17), options:value(17, "name", "net1") :- true

table_contents_queries(tablename, policy, modal=None)¶

Return list of queries yielding contents of TABLENAME in POLICY.

table_log(table, msg, *args)¶

tablenames(body_only=False, include_builtin=False, theory_name=None, include_modal=True)¶

Return tablenames occurring in some theory.

unregister_trigger(trigger)¶

Unregister CALLBACK for table TABLENAME.

update(sequence, target=None, persistent=False)¶

Event handler for applying an arbitrary sequence of insert/deletes.

If TARGET is supplied, it overrides the targets in SEQUENCE.

class congress.policy_engines.agnostic.Trigger(tablename, policy, callback, modal=None)¶

Bases: object

A chunk of code that should be run when a table’s contents changes.

class congress.policy_engines.agnostic.TriggerRegistry(dependency_graph)¶

Bases: object

A collection of triggers and algorithms to analyze that collection.

register_table(tablename, policy, callback, modal=None)¶

Register CALLBACK to run when TABLENAME changes.

relevant_triggers(events)¶

Return the set of triggers that are relevant to the EVENTS.

Each EVENT may either be a compile.Event or a tablename.

classmethod triggers_by_table(triggers)¶

Return dictionary from tables to triggers.

unregister(trigger)¶

Unregister trigger ID.

update_dependencies(dependency_graph_changes=None)¶

Inform registry of changes to the dependency graph.

Changes are accounted for in self.dependency_graph, but by giving the list of changes we can avoid recomputing all dependencies from scratch.

congress.policy_engines.agnostic.list_to_database(atoms)¶

congress.policy_engines.agnostic.string_to_database(string, theories=None)¶