diff options
Diffstat (limited to 'Testcases/vnc_api/gen/vnc_api_extension_gen.py')
| -rw-r--r-- | Testcases/vnc_api/gen/vnc_api_extension_gen.py | 2469 |
1 files changed, 2469 insertions, 0 deletions
diff --git a/Testcases/vnc_api/gen/vnc_api_extension_gen.py b/Testcases/vnc_api/gen/vnc_api_extension_gen.py new file mode 100644 index 0000000..63de5e7 --- /dev/null +++ b/Testcases/vnc_api/gen/vnc_api_extension_gen.py @@ -0,0 +1,2469 @@ + +# AUTO-GENERATED file from IFMapApiGenerator. Do Not Edit! + +class ResourceApiGen(object): + def pre_domain_create(self, resource_dict): + """ + Method called before domain is created + """ + pass + #end pre_domain_create + + def post_domain_create(self, resource_dict): + """ + Method called after domain is created + """ + pass + #end post_domain_create + + def pre_domain_read(self, resource_id): + """ + Method called before domain is read + """ + pass + #end pre_domain_read + + def post_domain_read(self, resource_id, resource_dict): + """ + Method called after domain is read + """ + pass + #end post_domain_read + + def pre_domain_update(self, resource_id, resource_dict): + """ + Method called before domain is updated + """ + pass + #end pre_domain_update + + def post_domain_update(self, resource_id, resource_dict): + """ + Method called after domain is updated + """ + pass + #end post_domain_update + + def pre_domain_delete(self, resource_id): + """ + Method called before domain is deleted + """ + pass + #end pre_domain_delete + + def post_domain_delete(self, resource_id, resource_dict): + """ + Method called after domain is deleted + """ + pass + #end post_domain_delete + + def pre_global_vrouter_config_create(self, resource_dict): + """ + Method called before global-vrouter-config is created + """ + pass + #end pre_global_vrouter_config_create + + def post_global_vrouter_config_create(self, resource_dict): + """ + Method called after global-vrouter-config is created + """ + pass + #end post_global_vrouter_config_create + + def pre_global_vrouter_config_read(self, resource_id): + """ + Method called before global-vrouter-config is read + """ + pass + #end pre_global_vrouter_config_read + + def post_global_vrouter_config_read(self, resource_id, resource_dict): + """ + Method called after global-vrouter-config is read + """ + pass + #end post_global_vrouter_config_read + + def pre_global_vrouter_config_update(self, resource_id, resource_dict): + """ + Method called before global-vrouter-config is updated + """ + pass + #end pre_global_vrouter_config_update + + def post_global_vrouter_config_update(self, resource_id, resource_dict): + """ + Method called after global-vrouter-config is updated + """ + pass + #end post_global_vrouter_config_update + + def pre_global_vrouter_config_delete(self, resource_id): + """ + Method called before global-vrouter-config is deleted + """ + pass + #end pre_global_vrouter_config_delete + + def post_global_vrouter_config_delete(self, resource_id, resource_dict): + """ + Method called after global-vrouter-config is deleted + """ + pass + #end post_global_vrouter_config_delete + + def pre_instance_ip_create(self, resource_dict): + """ + Method called before instance-ip is created + """ + pass + #end pre_instance_ip_create + + def post_instance_ip_create(self, resource_dict): + """ + Method called after instance-ip is created + """ + pass + #end post_instance_ip_create + + def pre_instance_ip_read(self, resource_id): + """ + Method called before instance-ip is read + """ + pass + #end pre_instance_ip_read + + def post_instance_ip_read(self, resource_id, resource_dict): + """ + Method called after instance-ip is read + """ + pass + #end post_instance_ip_read + + def pre_instance_ip_update(self, resource_id, resource_dict): + """ + Method called before instance-ip is updated + """ + pass + #end pre_instance_ip_update + + def post_instance_ip_update(self, resource_id, resource_dict): + """ + Method called after instance-ip is updated + """ + pass + #end post_instance_ip_update + + def pre_instance_ip_delete(self, resource_id): + """ + Method called before instance-ip is deleted + """ + pass + #end pre_instance_ip_delete + + def post_instance_ip_delete(self, resource_id, resource_dict): + """ + Method called after instance-ip is deleted + """ + pass + #end post_instance_ip_delete + + def pre_network_policy_create(self, resource_dict): + """ + Method called before network-policy is created + """ + pass + #end pre_network_policy_create + + def post_network_policy_create(self, resource_dict): + """ + Method called after network-policy is created + """ + pass + #end post_network_policy_create + + def pre_network_policy_read(self, resource_id): + """ + Method called before network-policy is read + """ + pass + #end pre_network_policy_read + + def post_network_policy_read(self, resource_id, resource_dict): + """ + Method called after network-policy is read + """ + pass + #end post_network_policy_read + + def pre_network_policy_update(self, resource_id, resource_dict): + """ + Method called before network-policy is updated + """ + pass + #end pre_network_policy_update + + def post_network_policy_update(self, resource_id, resource_dict): + """ + Method called after network-policy is updated + """ + pass + #end post_network_policy_update + + def pre_network_policy_delete(self, resource_id): + """ + Method called before network-policy is deleted + """ + pass + #end pre_network_policy_delete + + def post_network_policy_delete(self, resource_id, resource_dict): + """ + Method called after network-policy is deleted + """ + pass + #end post_network_policy_delete + + def pre_loadbalancer_pool_create(self, resource_dict): + """ + Method called before loadbalancer-pool is created + """ + pass + #end pre_loadbalancer_pool_create + + def post_loadbalancer_pool_create(self, resource_dict): + """ + Method called after loadbalancer-pool is created + """ + pass + #end post_loadbalancer_pool_create + + def pre_loadbalancer_pool_read(self, resource_id): + """ + Method called before loadbalancer-pool is read + """ + pass + #end pre_loadbalancer_pool_read + + def post_loadbalancer_pool_read(self, resource_id, resource_dict): + """ + Method called after loadbalancer-pool is read + """ + pass + #end post_loadbalancer_pool_read + + def pre_loadbalancer_pool_update(self, resource_id, resource_dict): + """ + Method called before loadbalancer-pool is updated + """ + pass + #end pre_loadbalancer_pool_update + + def post_loadbalancer_pool_update(self, resource_id, resource_dict): + """ + Method called after loadbalancer-pool is updated + """ + pass + #end post_loadbalancer_pool_update + + def pre_loadbalancer_pool_delete(self, resource_id): + """ + Method called before loadbalancer-pool is deleted + """ + pass + #end pre_loadbalancer_pool_delete + + def post_loadbalancer_pool_delete(self, resource_id, resource_dict): + """ + Method called after loadbalancer-pool is deleted + """ + pass + #end post_loadbalancer_pool_delete + + def pre_virtual_DNS_record_create(self, resource_dict): + """ + Method called before virtual-DNS-record is created + """ + pass + #end pre_virtual_DNS_record_create + + def post_virtual_DNS_record_create(self, resource_dict): + """ + Method called after virtual-DNS-record is created + """ + pass + #end post_virtual_DNS_record_create + + def pre_virtual_DNS_record_read(self, resource_id): + """ + Method called before virtual-DNS-record is read + """ + pass + #end pre_virtual_DNS_record_read + + def post_virtual_DNS_record_read(self, resource_id, resource_dict): + """ + Method called after virtual-DNS-record is read + """ + pass + #end post_virtual_DNS_record_read + + def pre_virtual_DNS_record_update(self, resource_id, resource_dict): + """ + Method called before virtual-DNS-record is updated + """ + pass + #end pre_virtual_DNS_record_update + + def post_virtual_DNS_record_update(self, resource_id, resource_dict): + """ + Method called after virtual-DNS-record is updated + """ + pass + #end post_virtual_DNS_record_update + + def pre_virtual_DNS_record_delete(self, resource_id): + """ + Method called before virtual-DNS-record is deleted + """ + pass + #end pre_virtual_DNS_record_delete + + def post_virtual_DNS_record_delete(self, resource_id, resource_dict): + """ + Method called after virtual-DNS-record is deleted + """ + pass + #end post_virtual_DNS_record_delete + + def pre_route_target_create(self, resource_dict): + """ + Method called before route-target is created + """ + pass + #end pre_route_target_create + + def post_route_target_create(self, resource_dict): + """ + Method called after route-target is created + """ + pass + #end post_route_target_create + + def pre_route_target_read(self, resource_id): + """ + Method called before route-target is read + """ + pass + #end pre_route_target_read + + def post_route_target_read(self, resource_id, resource_dict): + """ + Method called after route-target is read + """ + pass + #end post_route_target_read + + def pre_route_target_update(self, resource_id, resource_dict): + """ + Method called before route-target is updated + """ + pass + #end pre_route_target_update + + def post_route_target_update(self, resource_id, resource_dict): + """ + Method called after route-target is updated + """ + pass + #end post_route_target_update + + def pre_route_target_delete(self, resource_id): + """ + Method called before route-target is deleted + """ + pass + #end pre_route_target_delete + + def post_route_target_delete(self, resource_id, resource_dict): + """ + Method called after route-target is deleted + """ + pass + #end post_route_target_delete + + def pre_floating_ip_create(self, resource_dict): + """ + Method called before floating-ip is created + """ + pass + #end pre_floating_ip_create + + def post_floating_ip_create(self, resource_dict): + """ + Method called after floating-ip is created + """ + pass + #end post_floating_ip_create + + def pre_floating_ip_read(self, resource_id): + """ + Method called before floating-ip is read + """ + pass + #end pre_floating_ip_read + + def post_floating_ip_read(self, resource_id, resource_dict): + """ + Method called after floating-ip is read + """ + pass + #end post_floating_ip_read + + def pre_floating_ip_update(self, resource_id, resource_dict): + """ + Method called before floating-ip is updated + """ + pass + #end pre_floating_ip_update + + def post_floating_ip_update(self, resource_id, resource_dict): + """ + Method called after floating-ip is updated + """ + pass + #end post_floating_ip_update + + def pre_floating_ip_delete(self, resource_id): + """ + Method called before floating-ip is deleted + """ + pass + #end pre_floating_ip_delete + + def post_floating_ip_delete(self, resource_id, resource_dict): + """ + Method called after floating-ip is deleted + """ + pass + #end post_floating_ip_delete + + def pre_floating_ip_pool_create(self, resource_dict): + """ + Method called before floating-ip-pool is created + """ + pass + #end pre_floating_ip_pool_create + + def post_floating_ip_pool_create(self, resource_dict): + """ + Method called after floating-ip-pool is created + """ + pass + #end post_floating_ip_pool_create + + def pre_floating_ip_pool_read(self, resource_id): + """ + Method called before floating-ip-pool is read + """ + pass + #end pre_floating_ip_pool_read + + def post_floating_ip_pool_read(self, resource_id, resource_dict): + """ + Method called after floating-ip-pool is read + """ + pass + #end post_floating_ip_pool_read + + def pre_floating_ip_pool_update(self, resource_id, resource_dict): + """ + Method called before floating-ip-pool is updated + """ + pass + #end pre_floating_ip_pool_update + + def post_floating_ip_pool_update(self, resource_id, resource_dict): + """ + Method called after floating-ip-pool is updated + """ + pass + #end post_floating_ip_pool_update + + def pre_floating_ip_pool_delete(self, resource_id): + """ + Method called before floating-ip-pool is deleted + """ + pass + #end pre_floating_ip_pool_delete + + def post_floating_ip_pool_delete(self, resource_id, resource_dict): + """ + Method called after floating-ip-pool is deleted + """ + pass + #end post_floating_ip_pool_delete + + def pre_physical_router_create(self, resource_dict): + """ + Method called before physical-router is created + """ + pass + #end pre_physical_router_create + + def post_physical_router_create(self, resource_dict): + """ + Method called after physical-router is created + """ + pass + #end post_physical_router_create + + def pre_physical_router_read(self, resource_id): + """ + Method called before physical-router is read + """ + pass + #end pre_physical_router_read + + def post_physical_router_read(self, resource_id, resource_dict): + """ + Method called after physical-router is read + """ + pass + #end post_physical_router_read + + def pre_physical_router_update(self, resource_id, resource_dict): + """ + Method called before physical-router is updated + """ + pass + #end pre_physical_router_update + + def post_physical_router_update(self, resource_id, resource_dict): + """ + Method called after physical-router is updated + """ + pass + #end post_physical_router_update + + def pre_physical_router_delete(self, resource_id): + """ + Method called before physical-router is deleted + """ + pass + #end pre_physical_router_delete + + def post_physical_router_delete(self, resource_id, resource_dict): + """ + Method called after physical-router is deleted + """ + pass + #end post_physical_router_delete + + def pre_bgp_router_create(self, resource_dict): + """ + Method called before bgp-router is created + """ + pass + #end pre_bgp_router_create + + def post_bgp_router_create(self, resource_dict): + """ + Method called after bgp-router is created + """ + pass + #end post_bgp_router_create + + def pre_bgp_router_read(self, resource_id): + """ + Method called before bgp-router is read + """ + pass + #end pre_bgp_router_read + + def post_bgp_router_read(self, resource_id, resource_dict): + """ + Method called after bgp-router is read + """ + pass + #end post_bgp_router_read + + def pre_bgp_router_update(self, resource_id, resource_dict): + """ + Method called before bgp-router is updated + """ + pass + #end pre_bgp_router_update + + def post_bgp_router_update(self, resource_id, resource_dict): + """ + Method called after bgp-router is updated + """ + pass + #end post_bgp_router_update + + def pre_bgp_router_delete(self, resource_id): + """ + Method called before bgp-router is deleted + """ + pass + #end pre_bgp_router_delete + + def post_bgp_router_delete(self, resource_id, resource_dict): + """ + Method called after bgp-router is deleted + """ + pass + #end post_bgp_router_delete + + def pre_virtual_router_create(self, resource_dict): + """ + Method called before virtual-router is created + """ + pass + #end pre_virtual_router_create + + def post_virtual_router_create(self, resource_dict): + """ + Method called after virtual-router is created + """ + pass + #end post_virtual_router_create + + def pre_virtual_router_read(self, resource_id): + """ + Method called before virtual-router is read + """ + pass + #end pre_virtual_router_read + + def post_virtual_router_read(self, resource_id, resource_dict): + """ + Method called after virtual-router is read + """ + pass + #end post_virtual_router_read + + def pre_virtual_router_update(self, resource_id, resource_dict): + """ + Method called before virtual-router is updated + """ + pass + #end pre_virtual_router_update + + def post_virtual_router_update(self, resource_id, resource_dict): + """ + Method called after virtual-router is updated + """ + pass + #end post_virtual_router_update + + def pre_virtual_router_delete(self, resource_id): + """ + Method called before virtual-router is deleted + """ + pass + #end pre_virtual_router_delete + + def post_virtual_router_delete(self, resource_id, resource_dict): + """ + Method called after virtual-router is deleted + """ + pass + #end post_virtual_router_delete + + def pre_config_root_create(self, resource_dict): + """ + Method called before config-root is created + """ + pass + #end pre_config_root_create + + def post_config_root_create(self, resource_dict): + """ + Method called after config-root is created + """ + pass + #end post_config_root_create + + def pre_config_root_read(self, resource_id): + """ + Method called before config-root is read + """ + pass + #end pre_config_root_read + + def post_config_root_read(self, resource_id, resource_dict): + """ + Method called after config-root is read + """ + pass + #end post_config_root_read + + def pre_config_root_update(self, resource_id, resource_dict): + """ + Method called before config-root is updated + """ + pass + #end pre_config_root_update + + def post_config_root_update(self, resource_id, resource_dict): + """ + Method called after config-root is updated + """ + pass + #end post_config_root_update + + def pre_config_root_delete(self, resource_id): + """ + Method called before config-root is deleted + """ + pass + #end pre_config_root_delete + + def post_config_root_delete(self, resource_id, resource_dict): + """ + Method called after config-root is deleted + """ + pass + #end post_config_root_delete + + def pre_subnet_create(self, resource_dict): + """ + Method called before subnet is created + """ + pass + #end pre_subnet_create + + def post_subnet_create(self, resource_dict): + """ + Method called after subnet is created + """ + pass + #end post_subnet_create + + def pre_subnet_read(self, resource_id): + """ + Method called before subnet is read + """ + pass + #end pre_subnet_read + + def post_subnet_read(self, resource_id, resource_dict): + """ + Method called after subnet is read + """ + pass + #end post_subnet_read + + def pre_subnet_update(self, resource_id, resource_dict): + """ + Method called before subnet is updated + """ + pass + #end pre_subnet_update + + def post_subnet_update(self, resource_id, resource_dict): + """ + Method called after subnet is updated + """ + pass + #end post_subnet_update + + def pre_subnet_delete(self, resource_id): + """ + Method called before subnet is deleted + """ + pass + #end pre_subnet_delete + + def post_subnet_delete(self, resource_id, resource_dict): + """ + Method called after subnet is deleted + """ + pass + #end post_subnet_delete + + def pre_global_system_config_create(self, resource_dict): + """ + Method called before global-system-config is created + """ + pass + #end pre_global_system_config_create + + def post_global_system_config_create(self, resource_dict): + """ + Method called after global-system-config is created + """ + pass + #end post_global_system_config_create + + def pre_global_system_config_read(self, resource_id): + """ + Method called before global-system-config is read + """ + pass + #end pre_global_system_config_read + + def post_global_system_config_read(self, resource_id, resource_dict): + """ + Method called after global-system-config is read + """ + pass + #end post_global_system_config_read + + def pre_global_system_config_update(self, resource_id, resource_dict): + """ + Method called before global-system-config is updated + """ + pass + #end pre_global_system_config_update + + def post_global_system_config_update(self, resource_id, resource_dict): + """ + Method called after global-system-config is updated + """ + pass + #end post_global_system_config_update + + def pre_global_system_config_delete(self, resource_id): + """ + Method called before global-system-config is deleted + """ + pass + #end pre_global_system_config_delete + + def post_global_system_config_delete(self, resource_id, resource_dict): + """ + Method called after global-system-config is deleted + """ + pass + #end post_global_system_config_delete + + def pre_service_appliance_create(self, resource_dict): + """ + Method called before service-appliance is created + """ + pass + #end pre_service_appliance_create + + def post_service_appliance_create(self, resource_dict): + """ + Method called after service-appliance is created + """ + pass + #end post_service_appliance_create + + def pre_service_appliance_read(self, resource_id): + """ + Method called before service-appliance is read + """ + pass + #end pre_service_appliance_read + + def post_service_appliance_read(self, resource_id, resource_dict): + """ + Method called after service-appliance is read + """ + pass + #end post_service_appliance_read + + def pre_service_appliance_update(self, resource_id, resource_dict): + """ + Method called before service-appliance is updated + """ + pass + #end pre_service_appliance_update + + def post_service_appliance_update(self, resource_id, resource_dict): + """ + Method called after service-appliance is updated + """ + pass + #end post_service_appliance_update + + def pre_service_appliance_delete(self, resource_id): + """ + Method called before service-appliance is deleted + """ + pass + #end pre_service_appliance_delete + + def post_service_appliance_delete(self, resource_id, resource_dict): + """ + Method called after service-appliance is deleted + """ + pass + #end post_service_appliance_delete + + def pre_service_instance_create(self, resource_dict): + """ + Method called before service-instance is created + """ + pass + #end pre_service_instance_create + + def post_service_instance_create(self, resource_dict): + """ + Method called after service-instance is created + """ + pass + #end post_service_instance_create + + def pre_service_instance_read(self, resource_id): + """ + Method called before service-instance is read + """ + pass + #end pre_service_instance_read + + def post_service_instance_read(self, resource_id, resource_dict): + """ + Method called after service-instance is read + """ + pass + #end post_service_instance_read + + def pre_service_instance_update(self, resource_id, resource_dict): + """ + Method called before service-instance is updated + """ + pass + #end pre_service_instance_update + + def post_service_instance_update(self, resource_id, resource_dict): + """ + Method called after service-instance is updated + """ + pass + #end post_service_instance_update + + def pre_service_instance_delete(self, resource_id): + """ + Method called before service-instance is deleted + """ + pass + #end pre_service_instance_delete + + def post_service_instance_delete(self, resource_id, resource_dict): + """ + Method called after service-instance is deleted + """ + pass + #end post_service_instance_delete + + def pre_namespace_create(self, resource_dict): + """ + Method called before namespace is created + """ + pass + #end pre_namespace_create + + def post_namespace_create(self, resource_dict): + """ + Method called after namespace is created + """ + pass + #end post_namespace_create + + def pre_namespace_read(self, resource_id): + """ + Method called before namespace is read + """ + pass + #end pre_namespace_read + + def post_namespace_read(self, resource_id, resource_dict): + """ + Method called after namespace is read + """ + pass + #end post_namespace_read + + def pre_namespace_update(self, resource_id, resource_dict): + """ + Method called before namespace is updated + """ + pass + #end pre_namespace_update + + def post_namespace_update(self, resource_id, resource_dict): + """ + Method called after namespace is updated + """ + pass + #end post_namespace_update + + def pre_namespace_delete(self, resource_id): + """ + Method called before namespace is deleted + """ + pass + #end pre_namespace_delete + + def post_namespace_delete(self, resource_id, resource_dict): + """ + Method called after namespace is deleted + """ + pass + #end post_namespace_delete + + def pre_logical_interface_create(self, resource_dict): + """ + Method called before logical-interface is created + """ + pass + #end pre_logical_interface_create + + def post_logical_interface_create(self, resource_dict): + """ + Method called after logical-interface is created + """ + pass + #end post_logical_interface_create + + def pre_logical_interface_read(self, resource_id): + """ + Method called before logical-interface is read + """ + pass + #end pre_logical_interface_read + + def post_logical_interface_read(self, resource_id, resource_dict): + """ + Method called after logical-interface is read + """ + pass + #end post_logical_interface_read + + def pre_logical_interface_update(self, resource_id, resource_dict): + """ + Method called before logical-interface is updated + """ + pass + #end pre_logical_interface_update + + def post_logical_interface_update(self, resource_id, resource_dict): + """ + Method called after logical-interface is updated + """ + pass + #end post_logical_interface_update + + def pre_logical_interface_delete(self, resource_id): + """ + Method called before logical-interface is deleted + """ + pass + #end pre_logical_interface_delete + + def post_logical_interface_delete(self, resource_id, resource_dict): + """ + Method called after logical-interface is deleted + """ + pass + #end post_logical_interface_delete + + def pre_route_table_create(self, resource_dict): + """ + Method called before route-table is created + """ + pass + #end pre_route_table_create + + def post_route_table_create(self, resource_dict): + """ + Method called after route-table is created + """ + pass + #end post_route_table_create + + def pre_route_table_read(self, resource_id): + """ + Method called before route-table is read + """ + pass + #end pre_route_table_read + + def post_route_table_read(self, resource_id, resource_dict): + """ + Method called after route-table is read + """ + pass + #end post_route_table_read + + def pre_route_table_update(self, resource_id, resource_dict): + """ + Method called before route-table is updated + """ + pass + #end pre_route_table_update + + def post_route_table_update(self, resource_id, resource_dict): + """ + Method called after route-table is updated + """ + pass + #end post_route_table_update + + def pre_route_table_delete(self, resource_id): + """ + Method called before route-table is deleted + """ + pass + #end pre_route_table_delete + + def post_route_table_delete(self, resource_id, resource_dict): + """ + Method called after route-table is deleted + """ + pass + #end post_route_table_delete + + def pre_physical_interface_create(self, resource_dict): + """ + Method called before physical-interface is created + """ + pass + #end pre_physical_interface_create + + def post_physical_interface_create(self, resource_dict): + """ + Method called after physical-interface is created + """ + pass + #end post_physical_interface_create + + def pre_physical_interface_read(self, resource_id): + """ + Method called before physical-interface is read + """ + pass + #end pre_physical_interface_read + + def post_physical_interface_read(self, resource_id, resource_dict): + """ + Method called after physical-interface is read + """ + pass + #end post_physical_interface_read + + def pre_physical_interface_update(self, resource_id, resource_dict): + """ + Method called before physical-interface is updated + """ + pass + #end pre_physical_interface_update + + def post_physical_interface_update(self, resource_id, resource_dict): + """ + Method called after physical-interface is updated + """ + pass + #end post_physical_interface_update + + def pre_physical_interface_delete(self, resource_id): + """ + Method called before physical-interface is deleted + """ + pass + #end pre_physical_interface_delete + + def post_physical_interface_delete(self, resource_id, resource_dict): + """ + Method called after physical-interface is deleted + """ + pass + #end post_physical_interface_delete + + def pre_access_control_list_create(self, resource_dict): + """ + Method called before access-control-list is created + """ + pass + #end pre_access_control_list_create + + def post_access_control_list_create(self, resource_dict): + """ + Method called after access-control-list is created + """ + pass + #end post_access_control_list_create + + def pre_access_control_list_read(self, resource_id): + """ + Method called before access-control-list is read + """ + pass + #end pre_access_control_list_read + + def post_access_control_list_read(self, resource_id, resource_dict): + """ + Method called after access-control-list is read + """ + pass + #end post_access_control_list_read + + def pre_access_control_list_update(self, resource_id, resource_dict): + """ + Method called before access-control-list is updated + """ + pass + #end pre_access_control_list_update + + def post_access_control_list_update(self, resource_id, resource_dict): + """ + Method called after access-control-list is updated + """ + pass + #end post_access_control_list_update + + def pre_access_control_list_delete(self, resource_id): + """ + Method called before access-control-list is deleted + """ + pass + #end pre_access_control_list_delete + + def post_access_control_list_delete(self, resource_id, resource_dict): + """ + Method called after access-control-list is deleted + """ + pass + #end post_access_control_list_delete + + def pre_analytics_node_create(self, resource_dict): + """ + Method called before analytics-node is created + """ + pass + #end pre_analytics_node_create + + def post_analytics_node_create(self, resource_dict): + """ + Method called after analytics-node is created + """ + pass + #end post_analytics_node_create + + def pre_analytics_node_read(self, resource_id): + """ + Method called before analytics-node is read + """ + pass + #end pre_analytics_node_read + + def post_analytics_node_read(self, resource_id, resource_dict): + """ + Method called after analytics-node is read + """ + pass + #end post_analytics_node_read + + def pre_analytics_node_update(self, resource_id, resource_dict): + """ + Method called before analytics-node is updated + """ + pass + #end pre_analytics_node_update + + def post_analytics_node_update(self, resource_id, resource_dict): + """ + Method called after analytics-node is updated + """ + pass + #end post_analytics_node_update + + def pre_analytics_node_delete(self, resource_id): + """ + Method called before analytics-node is deleted + """ + pass + #end pre_analytics_node_delete + + def post_analytics_node_delete(self, resource_id, resource_dict): + """ + Method called after analytics-node is deleted + """ + pass + #end post_analytics_node_delete + + def pre_virtual_DNS_create(self, resource_dict): + """ + Method called before virtual-DNS is created + """ + pass + #end pre_virtual_DNS_create + + def post_virtual_DNS_create(self, resource_dict): + """ + Method called after virtual-DNS is created + """ + pass + #end post_virtual_DNS_create + + def pre_virtual_DNS_read(self, resource_id): + """ + Method called before virtual-DNS is read + """ + pass + #end pre_virtual_DNS_read + + def post_virtual_DNS_read(self, resource_id, resource_dict): + """ + Method called after virtual-DNS is read + """ + pass + #end post_virtual_DNS_read + + def pre_virtual_DNS_update(self, resource_id, resource_dict): + """ + Method called before virtual-DNS is updated + """ + pass + #end pre_virtual_DNS_update + + def post_virtual_DNS_update(self, resource_id, resource_dict): + """ + Method called after virtual-DNS is updated + """ + pass + #end post_virtual_DNS_update + + def pre_virtual_DNS_delete(self, resource_id): + """ + Method called before virtual-DNS is deleted + """ + pass + #end pre_virtual_DNS_delete + + def post_virtual_DNS_delete(self, resource_id, resource_dict): + """ + Method called after virtual-DNS is deleted + """ + pass + #end post_virtual_DNS_delete + + def pre_customer_attachment_create(self, resource_dict): + """ + Method called before customer-attachment is created + """ + pass + #end pre_customer_attachment_create + + def post_customer_attachment_create(self, resource_dict): + """ + Method called after customer-attachment is created + """ + pass + #end post_customer_attachment_create + + def pre_customer_attachment_read(self, resource_id): + """ + Method called before customer-attachment is read + """ + pass + #end pre_customer_attachment_read + + def post_customer_attachment_read(self, resource_id, resource_dict): + """ + Method called after customer-attachment is read + """ + pass + #end post_customer_attachment_read + + def pre_customer_attachment_update(self, resource_id, resource_dict): + """ + Method called before customer-attachment is updated + """ + pass + #end pre_customer_attachment_update + + def post_customer_attachment_update(self, resource_id, resource_dict): + """ + Method called after customer-attachment is updated + """ + pass + #end post_customer_attachment_update + + def pre_customer_attachment_delete(self, resource_id): + """ + Method called before customer-attachment is deleted + """ + pass + #end pre_customer_attachment_delete + + def post_customer_attachment_delete(self, resource_id, resource_dict): + """ + Method called after customer-attachment is deleted + """ + pass + #end post_customer_attachment_delete + + def pre_service_appliance_set_create(self, resource_dict): + """ + Method called before service-appliance-set is created + """ + pass + #end pre_service_appliance_set_create + + def post_service_appliance_set_create(self, resource_dict): + """ + Method called after service-appliance-set is created + """ + pass + #end post_service_appliance_set_create + + def pre_service_appliance_set_read(self, resource_id): + """ + Method called before service-appliance-set is read + """ + pass + #end pre_service_appliance_set_read + + def post_service_appliance_set_read(self, resource_id, resource_dict): + """ + Method called after service-appliance-set is read + """ + pass + #end post_service_appliance_set_read + + def pre_service_appliance_set_update(self, resource_id, resource_dict): + """ + Method called before service-appliance-set is updated + """ + pass + #end pre_service_appliance_set_update + + def post_service_appliance_set_update(self, resource_id, resource_dict): + """ + Method called after service-appliance-set is updated + """ + pass + #end post_service_appliance_set_update + + def pre_service_appliance_set_delete(self, resource_id): + """ + Method called before service-appliance-set is deleted + """ + pass + #end pre_service_appliance_set_delete + + def post_service_appliance_set_delete(self, resource_id, resource_dict): + """ + Method called after service-appliance-set is deleted + """ + pass + #end post_service_appliance_set_delete + + def pre_config_node_create(self, resource_dict): + """ + Method called before config-node is created + """ + pass + #end pre_config_node_create + + def post_config_node_create(self, resource_dict): + """ + Method called after config-node is created + """ + pass + #end post_config_node_create + + def pre_config_node_read(self, resource_id): + """ + Method called before config-node is read + """ + pass + #end pre_config_node_read + + def post_config_node_read(self, resource_id, resource_dict): + """ + Method called after config-node is read + """ + pass + #end post_config_node_read + + def pre_config_node_update(self, resource_id, resource_dict): + """ + Method called before config-node is updated + """ + pass + #end pre_config_node_update + + def post_config_node_update(self, resource_id, resource_dict): + """ + Method called after config-node is updated + """ + pass + #end post_config_node_update + + def pre_config_node_delete(self, resource_id): + """ + Method called before config-node is deleted + """ + pass + #end pre_config_node_delete + + def post_config_node_delete(self, resource_id, resource_dict): + """ + Method called after config-node is deleted + """ + pass + #end post_config_node_delete + + def pre_qos_queue_create(self, resource_dict): + """ + Method called before qos-queue is created + """ + pass + #end pre_qos_queue_create + + def post_qos_queue_create(self, resource_dict): + """ + Method called after qos-queue is created + """ + pass + #end post_qos_queue_create + + def pre_qos_queue_read(self, resource_id): + """ + Method called before qos-queue is read + """ + pass + #end pre_qos_queue_read + + def post_qos_queue_read(self, resource_id, resource_dict): + """ + Method called after qos-queue is read + """ + pass + #end post_qos_queue_read + + def pre_qos_queue_update(self, resource_id, resource_dict): + """ + Method called before qos-queue is updated + """ + pass + #end pre_qos_queue_update + + def post_qos_queue_update(self, resource_id, resource_dict): + """ + Method called after qos-queue is updated + """ + pass + #end post_qos_queue_update + + def pre_qos_queue_delete(self, resource_id): + """ + Method called before qos-queue is deleted + """ + pass + #end pre_qos_queue_delete + + def post_qos_queue_delete(self, resource_id, resource_dict): + """ + Method called after qos-queue is deleted + """ + pass + #end post_qos_queue_delete + + def pre_virtual_machine_create(self, resource_dict): + """ + Method called before virtual-machine is created + """ + pass + #end pre_virtual_machine_create + + def post_virtual_machine_create(self, resource_dict): + """ + Method called after virtual-machine is created + """ + pass + #end post_virtual_machine_create + + def pre_virtual_machine_read(self, resource_id): + """ + Method called before virtual-machine is read + """ + pass + #end pre_virtual_machine_read + + def post_virtual_machine_read(self, resource_id, resource_dict): + """ + Method called after virtual-machine is read + """ + pass + #end post_virtual_machine_read + + def pre_virtual_machine_update(self, resource_id, resource_dict): + """ + Method called before virtual-machine is updated + """ + pass + #end pre_virtual_machine_update + + def post_virtual_machine_update(self, resource_id, resource_dict): + """ + Method called after virtual-machine is updated + """ + pass + #end post_virtual_machine_update + + def pre_virtual_machine_delete(self, resource_id): + """ + Method called before virtual-machine is deleted + """ + pass + #end pre_virtual_machine_delete + + def post_virtual_machine_delete(self, resource_id, resource_dict): + """ + Method called after virtual-machine is deleted + """ + pass + #end post_virtual_machine_delete + + def pre_interface_route_table_create(self, resource_dict): + """ + Method called before interface-route-table is created + """ + pass + #end pre_interface_route_table_create + + def post_interface_route_table_create(self, resource_dict): + """ + Method called after interface-route-table is created + """ + pass + #end post_interface_route_table_create + + def pre_interface_route_table_read(self, resource_id): + """ + Method called before interface-route-table is read + """ + pass + #end pre_interface_route_table_read + + def post_interface_route_table_read(self, resource_id, resource_dict): + """ + Method called after interface-route-table is read + """ + pass + #end post_interface_route_table_read + + def pre_interface_route_table_update(self, resource_id, resource_dict): + """ + Method called before interface-route-table is updated + """ + pass + #end pre_interface_route_table_update + + def post_interface_route_table_update(self, resource_id, resource_dict): + """ + Method called after interface-route-table is updated + """ + pass + #end post_interface_route_table_update + + def pre_interface_route_table_delete(self, resource_id): + """ + Method called before interface-route-table is deleted + """ + pass + #end pre_interface_route_table_delete + + def post_interface_route_table_delete(self, resource_id, resource_dict): + """ + Method called after interface-route-table is deleted + """ + pass + #end post_interface_route_table_delete + + def pre_service_template_create(self, resource_dict): + """ + Method called before service-template is created + """ + pass + #end pre_service_template_create + + def post_service_template_create(self, resource_dict): + """ + Method called after service-template is created + """ + pass + #end post_service_template_create + + def pre_service_template_read(self, resource_id): + """ + Method called before service-template is read + """ + pass + #end pre_service_template_read + + def post_service_template_read(self, resource_id, resource_dict): + """ + Method called after service-template is read + """ + pass + #end post_service_template_read + + def pre_service_template_update(self, resource_id, resource_dict): + """ + Method called before service-template is updated + """ + pass + #end pre_service_template_update + + def post_service_template_update(self, resource_id, resource_dict): + """ + Method called after service-template is updated + """ + pass + #end post_service_template_update + + def pre_service_template_delete(self, resource_id): + """ + Method called before service-template is deleted + """ + pass + #end pre_service_template_delete + + def post_service_template_delete(self, resource_id, resource_dict): + """ + Method called after service-template is deleted + """ + pass + #end post_service_template_delete + + def pre_virtual_ip_create(self, resource_dict): + """ + Method called before virtual-ip is created + """ + pass + #end pre_virtual_ip_create + + def post_virtual_ip_create(self, resource_dict): + """ + Method called after virtual-ip is created + """ + pass + #end post_virtual_ip_create + + def pre_virtual_ip_read(self, resource_id): + """ + Method called before virtual-ip is read + """ + pass + #end pre_virtual_ip_read + + def post_virtual_ip_read(self, resource_id, resource_dict): + """ + Method called after virtual-ip is read + """ + pass + #end post_virtual_ip_read + + def pre_virtual_ip_update(self, resource_id, resource_dict): + """ + Method called before virtual-ip is updated + """ + pass + #end pre_virtual_ip_update + + def post_virtual_ip_update(self, resource_id, resource_dict): + """ + Method called after virtual-ip is updated + """ + pass + #end post_virtual_ip_update + + def pre_virtual_ip_delete(self, resource_id): + """ + Method called before virtual-ip is deleted + """ + pass + #end pre_virtual_ip_delete + + def post_virtual_ip_delete(self, resource_id, resource_dict): + """ + Method called after virtual-ip is deleted + """ + pass + #end post_virtual_ip_delete + + def pre_loadbalancer_member_create(self, resource_dict): + """ + Method called before loadbalancer-member is created + """ + pass + #end pre_loadbalancer_member_create + + def post_loadbalancer_member_create(self, resource_dict): + """ + Method called after loadbalancer-member is created + """ + pass + #end post_loadbalancer_member_create + + def pre_loadbalancer_member_read(self, resource_id): + """ + Method called before loadbalancer-member is read + """ + pass + #end pre_loadbalancer_member_read + + def post_loadbalancer_member_read(self, resource_id, resource_dict): + """ + Method called after loadbalancer-member is read + """ + pass + #end post_loadbalancer_member_read + + def pre_loadbalancer_member_update(self, resource_id, resource_dict): + """ + Method called before loadbalancer-member is updated + """ + pass + #end pre_loadbalancer_member_update + + def post_loadbalancer_member_update(self, resource_id, resource_dict): + """ + Method called after loadbalancer-member is updated + """ + pass + #end post_loadbalancer_member_update + + def pre_loadbalancer_member_delete(self, resource_id): + """ + Method called before loadbalancer-member is deleted + """ + pass + #end pre_loadbalancer_member_delete + + def post_loadbalancer_member_delete(self, resource_id, resource_dict): + """ + Method called after loadbalancer-member is deleted + """ + pass + #end post_loadbalancer_member_delete + + def pre_security_group_create(self, resource_dict): + """ + Method called before security-group is created + """ + pass + #end pre_security_group_create + + def post_security_group_create(self, resource_dict): + """ + Method called after security-group is created + """ + pass + #end post_security_group_create + + def pre_security_group_read(self, resource_id): + """ + Method called before security-group is read + """ + pass + #end pre_security_group_read + + def post_security_group_read(self, resource_id, resource_dict): + """ + Method called after security-group is read + """ + pass + #end post_security_group_read + + def pre_security_group_update(self, resource_id, resource_dict): + """ + Method called before security-group is updated + """ + pass + #end pre_security_group_update + + def post_security_group_update(self, resource_id, resource_dict): + """ + Method called after security-group is updated + """ + pass + #end post_security_group_update + + def pre_security_group_delete(self, resource_id): + """ + Method called before security-group is deleted + """ + pass + #end pre_security_group_delete + + def post_security_group_delete(self, resource_id, resource_dict): + """ + Method called after security-group is deleted + """ + pass + #end post_security_group_delete + + def pre_provider_attachment_create(self, resource_dict): + """ + Method called before provider-attachment is created + """ + pass + #end pre_provider_attachment_create + + def post_provider_attachment_create(self, resource_dict): + """ + Method called after provider-attachment is created + """ + pass + #end post_provider_attachment_create + + def pre_provider_attachment_read(self, resource_id): + """ + Method called before provider-attachment is read + """ + pass + #end pre_provider_attachment_read + + def post_provider_attachment_read(self, resource_id, resource_dict): + """ + Method called after provider-attachment is read + """ + pass + #end post_provider_attachment_read + + def pre_provider_attachment_update(self, resource_id, resource_dict): + """ + Method called before provider-attachment is updated + """ + pass + #end pre_provider_attachment_update + + def post_provider_attachment_update(self, resource_id, resource_dict): + """ + Method called after provider-attachment is updated + """ + pass + #end post_provider_attachment_update + + def pre_provider_attachment_delete(self, resource_id): + """ + Method called before provider-attachment is deleted + """ + pass + #end pre_provider_attachment_delete + + def post_provider_attachment_delete(self, resource_id, resource_dict): + """ + Method called after provider-attachment is deleted + """ + pass + #end post_provider_attachment_delete + + def pre_virtual_machine_interface_create(self, resource_dict): + """ + Method called before virtual-machine-interface is created + """ + pass + #end pre_virtual_machine_interface_create + + def post_virtual_machine_interface_create(self, resource_dict): + """ + Method called after virtual-machine-interface is created + """ + pass + #end post_virtual_machine_interface_create + + def pre_virtual_machine_interface_read(self, resource_id): + """ + Method called before virtual-machine-interface is read + """ + pass + #end pre_virtual_machine_interface_read + + def post_virtual_machine_interface_read(self, resource_id, resource_dict): + """ + Method called after virtual-machine-interface is read + """ + pass + #end post_virtual_machine_interface_read + + def pre_virtual_machine_interface_update(self, resource_id, resource_dict): + """ + Method called before virtual-machine-interface is updated + """ + pass + #end pre_virtual_machine_interface_update + + def post_virtual_machine_interface_update(self, resource_id, resource_dict): + """ + Method called after virtual-machine-interface is updated + """ + pass + #end post_virtual_machine_interface_update + + def pre_virtual_machine_interface_delete(self, resource_id): + """ + Method called before virtual-machine-interface is deleted + """ + pass + #end pre_virtual_machine_interface_delete + + def post_virtual_machine_interface_delete(self, resource_id, resource_dict): + """ + Method called after virtual-machine-interface is deleted + """ + pass + #end post_virtual_machine_interface_delete + + def pre_loadbalancer_healthmonitor_create(self, resource_dict): + """ + Method called before loadbalancer-healthmonitor is created + """ + pass + #end pre_loadbalancer_healthmonitor_create + + def post_loadbalancer_healthmonitor_create(self, resource_dict): + """ + Method called after loadbalancer-healthmonitor is created + """ + pass + #end post_loadbalancer_healthmonitor_create + + def pre_loadbalancer_healthmonitor_read(self, resource_id): + """ + Method called before loadbalancer-healthmonitor is read + """ + pass + #end pre_loadbalancer_healthmonitor_read + + def post_loadbalancer_healthmonitor_read(self, resource_id, resource_dict): + """ + Method called after loadbalancer-healthmonitor is read + """ + pass + #end post_loadbalancer_healthmonitor_read + + def pre_loadbalancer_healthmonitor_update(self, resource_id, resource_dict): + """ + Method called before loadbalancer-healthmonitor is updated + """ + pass + #end pre_loadbalancer_healthmonitor_update + + def post_loadbalancer_healthmonitor_update(self, resource_id, resource_dict): + """ + Method called after loadbalancer-healthmonitor is updated + """ + pass + #end post_loadbalancer_healthmonitor_update + + def pre_loadbalancer_healthmonitor_delete(self, resource_id): + """ + Method called before loadbalancer-healthmonitor is deleted + """ + pass + #end pre_loadbalancer_healthmonitor_delete + + def post_loadbalancer_healthmonitor_delete(self, resource_id, resource_dict): + """ + Method called after loadbalancer-healthmonitor is deleted + """ + pass + #end post_loadbalancer_healthmonitor_delete + + def pre_virtual_network_create(self, resource_dict): + """ + Method called before virtual-network is created + """ + pass + #end pre_virtual_network_create + + def post_virtual_network_create(self, resource_dict): + """ + Method called after virtual-network is created + """ + pass + #end post_virtual_network_create + + def pre_virtual_network_read(self, resource_id): + """ + Method called before virtual-network is read + """ + pass + #end pre_virtual_network_read + + def post_virtual_network_read(self, resource_id, resource_dict): + """ + Method called after virtual-network is read + """ + pass + #end post_virtual_network_read + + def pre_virtual_network_update(self, resource_id, resource_dict): + """ + Method called before virtual-network is updated + """ + pass + #end pre_virtual_network_update + + def post_virtual_network_update(self, resource_id, resource_dict): + """ + Method called after virtual-network is updated + """ + pass + #end post_virtual_network_update + + def pre_virtual_network_delete(self, resource_id): + """ + Method called before virtual-network is deleted + """ + pass + #end pre_virtual_network_delete + + def post_virtual_network_delete(self, resource_id, resource_dict): + """ + Method called after virtual-network is deleted + """ + pass + #end post_virtual_network_delete + + def pre_project_create(self, resource_dict): + """ + Method called before project is created + """ + pass + #end pre_project_create + + def post_project_create(self, resource_dict): + """ + Method called after project is created + """ + pass + #end post_project_create + + def pre_project_read(self, resource_id): + """ + Method called before project is read + """ + pass + #end pre_project_read + + def post_project_read(self, resource_id, resource_dict): + """ + Method called after project is read + """ + pass + #end post_project_read + + def pre_project_update(self, resource_id, resource_dict): + """ + Method called before project is updated + """ + pass + #end pre_project_update + + def post_project_update(self, resource_id, resource_dict): + """ + Method called after project is updated + """ + pass + #end post_project_update + + def pre_project_delete(self, resource_id): + """ + Method called before project is deleted + """ + pass + #end pre_project_delete + + def post_project_delete(self, resource_id, resource_dict): + """ + Method called after project is deleted + """ + pass + #end post_project_delete + + def pre_qos_forwarding_class_create(self, resource_dict): + """ + Method called before qos-forwarding-class is created + """ + pass + #end pre_qos_forwarding_class_create + + def post_qos_forwarding_class_create(self, resource_dict): + """ + Method called after qos-forwarding-class is created + """ + pass + #end post_qos_forwarding_class_create + + def pre_qos_forwarding_class_read(self, resource_id): + """ + Method called before qos-forwarding-class is read + """ + pass + #end pre_qos_forwarding_class_read + + def post_qos_forwarding_class_read(self, resource_id, resource_dict): + """ + Method called after qos-forwarding-class is read + """ + pass + #end post_qos_forwarding_class_read + + def pre_qos_forwarding_class_update(self, resource_id, resource_dict): + """ + Method called before qos-forwarding-class is updated + """ + pass + #end pre_qos_forwarding_class_update + + def post_qos_forwarding_class_update(self, resource_id, resource_dict): + """ + Method called after qos-forwarding-class is updated + """ + pass + #end post_qos_forwarding_class_update + + def pre_qos_forwarding_class_delete(self, resource_id): + """ + Method called before qos-forwarding-class is deleted + """ + pass + #end pre_qos_forwarding_class_delete + + def post_qos_forwarding_class_delete(self, resource_id, resource_dict): + """ + Method called after qos-forwarding-class is deleted + """ + pass + #end post_qos_forwarding_class_delete + + def pre_database_node_create(self, resource_dict): + """ + Method called before database-node is created + """ + pass + #end pre_database_node_create + + def post_database_node_create(self, resource_dict): + """ + Method called after database-node is created + """ + pass + #end post_database_node_create + + def pre_database_node_read(self, resource_id): + """ + Method called before database-node is read + """ + pass + #end pre_database_node_read + + def post_database_node_read(self, resource_id, resource_dict): + """ + Method called after database-node is read + """ + pass + #end post_database_node_read + + def pre_database_node_update(self, resource_id, resource_dict): + """ + Method called before database-node is updated + """ + pass + #end pre_database_node_update + + def post_database_node_update(self, resource_id, resource_dict): + """ + Method called after database-node is updated + """ + pass + #end post_database_node_update + + def pre_database_node_delete(self, resource_id): + """ + Method called before database-node is deleted + """ + pass + #end pre_database_node_delete + + def post_database_node_delete(self, resource_id, resource_dict): + """ + Method called after database-node is deleted + """ + pass + #end post_database_node_delete + + def pre_routing_instance_create(self, resource_dict): + """ + Method called before routing-instance is created + """ + pass + #end pre_routing_instance_create + + def post_routing_instance_create(self, resource_dict): + """ + Method called after routing-instance is created + """ + pass + #end post_routing_instance_create + + def pre_routing_instance_read(self, resource_id): + """ + Method called before routing-instance is read + """ + pass + #end pre_routing_instance_read + + def post_routing_instance_read(self, resource_id, resource_dict): + """ + Method called after routing-instance is read + """ + pass + #end post_routing_instance_read + + def pre_routing_instance_update(self, resource_id, resource_dict): + """ + Method called before routing-instance is updated + """ + pass + #end pre_routing_instance_update + + def post_routing_instance_update(self, resource_id, resource_dict): + """ + Method called after routing-instance is updated + """ + pass + #end post_routing_instance_update + + def pre_routing_instance_delete(self, resource_id): + """ + Method called before routing-instance is deleted + """ + pass + #end pre_routing_instance_delete + + def post_routing_instance_delete(self, resource_id, resource_dict): + """ + Method called after routing-instance is deleted + """ + pass + #end post_routing_instance_delete + + def pre_network_ipam_create(self, resource_dict): + """ + Method called before network-ipam is created + """ + pass + #end pre_network_ipam_create + + def post_network_ipam_create(self, resource_dict): + """ + Method called after network-ipam is created + """ + pass + #end post_network_ipam_create + + def pre_network_ipam_read(self, resource_id): + """ + Method called before network-ipam is read + """ + pass + #end pre_network_ipam_read + + def post_network_ipam_read(self, resource_id, resource_dict): + """ + Method called after network-ipam is read + """ + pass + #end post_network_ipam_read + + def pre_network_ipam_update(self, resource_id, resource_dict): + """ + Method called before network-ipam is updated + """ + pass + #end pre_network_ipam_update + + def post_network_ipam_update(self, resource_id, resource_dict): + """ + Method called after network-ipam is updated + """ + pass + #end post_network_ipam_update + + def pre_network_ipam_delete(self, resource_id): + """ + Method called before network-ipam is deleted + """ + pass + #end pre_network_ipam_delete + + def post_network_ipam_delete(self, resource_id, resource_dict): + """ + Method called after network-ipam is deleted + """ + pass + #end post_network_ipam_delete + + def pre_logical_router_create(self, resource_dict): + """ + Method called before logical-router is created + """ + pass + #end pre_logical_router_create + + def post_logical_router_create(self, resource_dict): + """ + Method called after logical-router is created + """ + pass + #end post_logical_router_create + + def pre_logical_router_read(self, resource_id): + """ + Method called before logical-router is read + """ + pass + #end pre_logical_router_read + + def post_logical_router_read(self, resource_id, resource_dict): + """ + Method called after logical-router is read + """ + pass + #end post_logical_router_read + + def pre_logical_router_update(self, resource_id, resource_dict): + """ + Method called before logical-router is updated + """ + pass + #end pre_logical_router_update + + def post_logical_router_update(self, resource_id, resource_dict): + """ + Method called after logical-router is updated + """ + pass + #end post_logical_router_update + + def pre_logical_router_delete(self, resource_id): + """ + Method called before logical-router is deleted + """ + pass + #end pre_logical_router_delete + + def post_logical_router_delete(self, resource_id, resource_dict): + """ + Method called after logical-router is deleted + """ + pass + #end post_logical_router_delete + +#end class ResourceApiGen |