def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( vm=dict(required=True, aliases=['name']), vm_guest_ip=dict(aliases=['secondary_ip']), network=dict(), vpc=dict(), state=dict(choices=['present', 'absent'], default='present'), domain=dict(), account=dict(), project=dict(), zone=dict(), poll_async=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True, required_if=([('state', 'absent', ['vm_guest_ip']) ])) acs_instance_nic_secondaryip = AnsibleCloudStackInstanceNicSecondaryIp( module) state = module.params.get('state') if state == 'absent': nic = acs_instance_nic_secondaryip.absent_nic_ip() else: nic = acs_instance_nic_secondaryip.present_nic_ip() result = acs_instance_nic_secondaryip.get_result(nic) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update(dict( id=dict(), name=dict(required=True), gateway=dict(), netmask=dict(), start_ip=dict(), end_ip=dict(), zone=dict(), state=dict(choices=['present', 'enabled', 'disabled', 'absent'], default='present'), )) module = AnsibleModule( argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True ) acs_pod = AnsibleCloudStackPod(module) state = module.params.get('state') if state in ['absent']: pod = acs_pod.absent_pod() else: pod = acs_pod.present_pod() result = acs_pod.get_result(pod) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update(dict( ip_address=dict(required=True), vm=dict(), vm_guest_ip=dict(), network=dict(), vpc=dict(), state=dict(choices=['present', 'absent'], default='present'), zone=dict(), domain=dict(), account=dict(), project=dict(), poll_async=dict(type='bool', default=True), )) module = AnsibleModule( argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True ) acs_static_nat = AnsibleCloudStackStaticNat(module) state = module.params.get('state') if state in ['absent']: ip_address = acs_static_nat.absent_static_nat() else: ip_address = acs_static_nat.present_static_nat() result = acs_static_nat.get_result(ip_address) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update(dict( path=dict(required=True), state=dict(choices=['present', 'absent'], default='present'), network_domain=dict(), clean_up=dict(type='bool', default=False), poll_async=dict(type='bool', default=True), )) module = AnsibleModule( argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True ) acs_dom = AnsibleCloudStackDomain(module) state = module.params.get('state') if state in ['absent']: domain = acs_dom.absent_domain() else: domain = acs_dom.present_domain() result = acs_dom.get_result(domain) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True), service_offering=dict(), state=dict(choices=[ 'present', 'started', 'stopped', 'restarted', 'absent' ], default="present"), domain=dict(), account=dict(), project=dict(), zone=dict(), poll_async=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_router = AnsibleCloudStackRouter(module) state = module.params.get('state') if state in ['absent']: router = acs_router.absent_router() else: router = acs_router.present_router() result = acs_router.get_result(router) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True), state=dict(choices=['present', 'absent'], default='present'), domain=dict(), account=dict(), project=dict(), cidrs=dict(type='list', aliases=['cidr']), esp_policy=dict(), esp_lifetime=dict(type='int'), gateway=dict(), ike_policy=dict(), ike_lifetime=dict(type='int'), ipsec_psk=dict(no_log=True), dpd=dict(type='bool'), force_encap=dict(type='bool'), poll_async=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_vpn_cgw = AnsibleCloudStackVpnCustomerGateway(module) state = module.params.get('state') if state == "absent": vpn_customer_gateway = acs_vpn_cgw.absent_vpn_customer_gateway() else: vpn_customer_gateway = acs_vpn_cgw.present_vpn_customer_gateway() result = acs_vpn_cgw.get_result(vpn_customer_gateway) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True), affinity_type=dict(), description=dict(), state=dict(choices=['present', 'absent'], default='present'), domain=dict(), account=dict(), project=dict(), poll_async=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_ag = AnsibleCloudStackAffinityGroup(module) state = module.params.get('state') if state in ['absent']: affinity_group = acs_ag.remove_affinity_group() else: affinity_group = acs_ag.create_affinity_group() result = acs_ag.get_result(affinity_group) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True), state=dict(default='present', choices=['present', 'absent']), domain=dict(), account=dict(), project=dict(), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_ig = AnsibleCloudStackInstanceGroup(module) state = module.params.get('state') if state in ['absent']: instance_group = acs_ig.absent_instance_group() else: instance_group = acs_ig.present_instance_group() result = acs_ig.get_result(instance_group) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True), public_key=dict(), domain=dict(), account=dict(), project=dict(), state=dict(choices=['present', 'absent'], default='present'), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) if not HAS_LIB_SSHPUBKEYS: module.fail_json(msg=missing_required_lib("sshpubkeys"), exception=SSHPUBKEYS_IMP_ERR) acs_sshkey = AnsibleCloudStackSshKey(module) state = module.params.get('state') if state in ['absent']: ssh_key = acs_sshkey.remove_ssh_key() else: public_key = module.params.get('public_key') if public_key: ssh_key = acs_sshkey.register_ssh_key(public_key) else: ssh_key = acs_sshkey.create_ssh_key() result = acs_sshkey.get_result(ssh_key) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True, aliases=['ip_address']), url=dict(), password=dict(no_log=True), username=dict(), hypervisor=dict(), allocation_state=dict( choices=['enabled', 'disabled', 'maintenance']), pod=dict(), cluster=dict(), host_tags=dict(type='list', aliases=['host_tag']), zone=dict(), state=dict(choices=['present', 'absent'], default='present'), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_host = AnsibleCloudStackHost(module) state = module.params.get('state') if state == 'absent': host = acs_host.absent_host() else: host = acs_host.present_host() result = acs_host.get_result(host) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( id=dict(required=True, type='int'), name=dict(), endpoint=dict(), state=dict(choices=['present', 'absent'], default='present'), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), required_if=[ ('state', 'present', ['name', 'endpoint']), ], supports_check_mode=True) acs_region = AnsibleCloudStackRegion(module) state = module.params.get('state') if state == 'absent': region = acs_region.absent_region() else: region = acs_region.present_region() result = acs_region.get_result(region) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True), ip_address=dict(aliases=['public_ip']), vms=dict(required=True, aliases=['vm'], type='list'), state=dict(choices=['present', 'absent'], default='present'), zone=dict(), domain=dict(), project=dict(), account=dict(), poll_async=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_lb_rule_member = AnsibleCloudStackLBRuleMember(module) state = module.params.get('state') if state in ['absent']: rule = acs_lb_rule_member.remove_members() else: rule = acs_lb_rule_member.add_members() result = acs_lb_rule_member.get_result(rule) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( url=dict(), name=dict(required=True), zone=dict(required=True), provider=dict(), force_recreate=dict(type='bool', default=False), state=dict(choices=['present', 'absent'], default='present'), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), required_if=[ ('state', 'present', ['url', 'provider']), ], supports_check_mode=True) acis_do = AnsibleCloudstackImageStore(module) state = module.params.get('state') if state == "absent": image_store = acis_do.absent_image_store() else: image_store = acis_do.present_image_store() result = acis_do.get_result(image_store) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( vpn_customer_gateway=dict(required=True), vpc=dict(required=True), domain=dict(), account=dict(), project=dict(), zone=dict(), passive=dict(type='bool', default=False), force=dict(type='bool', default=False), state=dict(choices=['present', 'absent'], default='present'), poll_async=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_vpn_conn = AnsibleCloudStackVpnConnection(module) state = module.params.get('state') if state == "absent": vpn_conn = acs_vpn_conn.absent_vpn_connection() else: vpn_conn = acs_vpn_conn.present_vpn_connection() result = acs_vpn_conn.get_result(vpn_conn) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True, aliases=['display_name']), vm=dict(required=True), description=dict(), zone=dict(), snapshot_memory=dict(type='bool', default=False), state=dict(choices=['present', 'absent', 'revert'], default='present'), domain=dict(), account=dict(), project=dict(), poll_async=dict(type='bool', default=True), tags=dict(type='list', aliases=['tag']), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_vmsnapshot = AnsibleCloudStackVmSnapshot(module) state = module.params.get('state') if state in ['revert']: snapshot = acs_vmsnapshot.revert_vm_to_snapshot() elif state in ['absent']: snapshot = acs_vmsnapshot.remove_snapshot() else: snapshot = acs_vmsnapshot.create_snapshot() result = acs_vmsnapshot.get_result(snapshot) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True), display_text=dict(), state=dict(choices=['enabled', 'present', 'disabled', 'absent'], default='present'), service_capabilities=dict(type='list', aliases=['service_capability']), service_offering=dict(), supported_services=dict(type='list', aliases=['supported_service']), service_providers=dict(type='list', aliases=['service_provider']), poll_async=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_vpc_offering = AnsibleCloudStackVPCOffering(module) state = module.params.get('state') if state in ['absent']: vpc_offering = acs_vpc_offering.delete_vpc_offering() else: vpc_offering = acs_vpc_offering.create_or_update() result = acs_vpc_offering.get_result(vpc_offering) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True), display_text=dict(), state=dict(choices=['present', 'absent', 'active', 'suspended'], default='present'), domain=dict(), account=dict(), poll_async=dict(type='bool', default=True), tags=dict(type='list', aliases=['tag']), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_project = AnsibleCloudStackProject(module) state = module.params.get('state') if state in ['absent']: project = acs_project.absent_project() elif state in ['active', 'suspended']: project = acs_project.state_project(state=state) else: project = acs_project.present_project() result = acs_project.get_result(project) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update(dict( vm=dict(required=True, aliases=['name']), network=dict(required=True), vpc=dict(), ip_address=dict(), state=dict(choices=['present', 'absent'], default='present'), domain=dict(), account=dict(), project=dict(), zone=dict(), poll_async=dict(type='bool', default=True), )) module = AnsibleModule( argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True, ) acs_nic = AnsibleCloudStackInstanceNic(module) state = module.params.get('state') if state == 'absent': nic = acs_nic.absent_nic() else: nic = acs_nic.present_nic() result = acs_nic.get_result(nic) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update(dict( name=dict(required=True), description=dict(), vpc=dict(required=True), state=dict(choices=['present', 'absent'], default='present'), zone=dict(), domain=dict(), account=dict(), project=dict(), poll_async=dict(type='bool', default=True), )) module = AnsibleModule( argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True ) acs_network_acl = AnsibleCloudStackNetworkAcl(module) state = module.params.get('state') if state == 'absent': network_acl = acs_network_acl.absent_network_acl() else: network_acl = acs_network_acl.present_network_acl() result = acs_network_acl.get_result(network_acl) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( uuid=dict(aliases=['id']), name=dict(required=True), description=dict(), role_type=dict( choices=['User', 'DomainAdmin', 'ResourceAdmin', 'Admin'], default='User'), state=dict(choices=['present', 'absent'], default='present'), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_role = AnsibleCloudStackRole(module) state = module.params.get('state') if state == 'absent': role = acs_role.absent_role() else: role = acs_role.present_role() result = acs_role.get_result(role) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( ip_address=dict(required=False), state=dict(choices=['present', 'absent'], default='present'), vpc=dict(), network=dict(), zone=dict(), domain=dict(), account=dict(), project=dict(), tags=dict(type='list', aliases=['tag']), poll_async=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), required_if=[ ('state', 'absent', ['ip_address', 'tags'], True), ], mutually_exclusive=(['vpc', 'network'], ), supports_check_mode=True) acs_ip_address = AnsibleCloudStackIPAddress(module) state = module.params.get('state') if state in ['absent']: ip_address = acs_ip_address.disassociate_ip_address() else: ip_address = acs_ip_address.present_ip_address() result = acs_ip_address.get_result(ip_address) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update(dict( name=dict(required=True), display_text=dict(), network_offering=dict(), zone=dict(), start_ip=dict(), end_ip=dict(), gateway=dict(), netmask=dict(), start_ipv6=dict(), end_ipv6=dict(), cidr_ipv6=dict(), gateway_ipv6=dict(), vlan=dict(), vpc=dict(), isolated_pvlan=dict(), clean_up=dict(type='bool', default=False), network_domain=dict(), subdomain_access=dict(type='bool'), state=dict(choices=['present', 'absent', 'restarted'], default='present'), acl=dict(), acl_type=dict(choices=['account', 'domain']), project=dict(), domain=dict(), account=dict(), poll_async=dict(type='bool', default=True), tags=dict(type='list', aliases=['tag']), )) required_together = cs_required_together() required_together.extend([ ['netmask', 'gateway'], ]) module = AnsibleModule( argument_spec=argument_spec, required_together=required_together, supports_check_mode=True ) acs_network = AnsibleCloudStackNetwork(module) state = module.params.get('state') if state == 'absent': network = acs_network.absent_network() elif state == 'restarted': network = acs_network.restart_network() else: network = acs_network.present_network() result = acs_network.get_result(network) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True, aliases=['physical_network']), zone=dict(), domain=dict(), vlan=dict(), nsps_disabled=dict(type='list'), nsps_enabled=dict(type='list'), network_speed=dict(choices=['1G', '10G']), broadcast_domain_range=dict(choices=['POD', 'ZONE']), isolation_method=dict(choices=['VLAN', 'GRE', 'L3']), state=dict(choices=['present', 'enabled', 'disabled', 'absent'], default='present'), tags=dict(aliases=['tag']), poll_async=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_network = AnsibleCloudStackPhysicalNetwork(module) state = module.params.get('state') nsps_disabled = module.params.get('nsps_disabled', []) nsps_enabled = module.params.get('nsps_enabled', []) if state in ['absent']: network = acs_network.absent_network() else: network = acs_network.present_network() if nsps_disabled is not None: for name in nsps_disabled: acs_network.update_nsp(name=name, state='Disabled') if nsps_enabled is not None: for nsp_name in nsps_enabled: if nsp_name.lower() in ['virtualrouter', 'vpcvirtualrouter']: acs_network.set_vrouter_element_state(enabled=True, nsp_name=nsp_name) elif nsp_name.lower() == 'internallbvm': acs_network.set_loadbalancer_element_state(enabled=True, nsp_name=nsp_name) acs_network.update_nsp(name=nsp_name, state='Enabled') result = acs_network.get_result(network) if nsps_enabled: result['nsps_enabled'] = nsps_enabled if nsps_disabled: result['nsps_disabled'] = nsps_disabled module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( state=dict(choices=['enabled', 'present', 'disabled', 'absent'], default='present'), display_text=dict(), guest_ip_type=dict(choices=['Shared', 'Isolated']), name=dict(required=True), supported_services=dict(type='list', aliases=['supported_service'], choices=[ 'Dns', 'PortForwarding', 'Dhcp', 'SourceNat', 'UserData', 'Firewall', 'StaticNat', 'Vpn', 'Lb', ]), traffic_type=dict(default='Guest'), availability=dict(), conserve_mode=dict(type='bool'), details=dict(type='list'), egress_default_policy=dict(choices=['allow', 'deny']), persistent=dict(type='bool'), keepalive_enabled=dict(type='bool'), max_connections=dict(type='int'), network_rate=dict(type='int'), service_capabilities=dict(type='list', aliases=['service_capability']), service_offering=dict(), service_providers=dict(type='list', aliases=['service_provider']), specify_ip_ranges=dict(type='bool'), specify_vlan=dict(type='bool'), for_vpc=dict(type='bool'), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_network_offering = AnsibleCloudStackNetworkOffering(module) state = module.params.get('state') if state in ['absent']: network_offering = acs_network_offering.delete_network_offering() else: network_offering = acs_network_offering.create_or_update() result = acs_network_offering.get_result(network_offering) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( network_acl=dict(required=True, aliases=['acl']), rule_position=dict(required=True, type='int', aliases=['number']), vpc=dict(required=True), cidrs=dict(type='list', default=['0.0.0.0/0'], aliases=['cidr']), protocol=dict(choices=['tcp', 'udp', 'icmp', 'all', 'by_number'], default='tcp'), protocol_number=dict(type='int'), traffic_type=dict(choices=['ingress', 'egress'], aliases=['type'], default='ingress'), action_policy=dict(choices=['allow', 'deny'], aliases=['action'], default='allow'), icmp_type=dict(type='int'), icmp_code=dict(type='int'), start_port=dict(type='int', aliases=['port']), end_port=dict(type='int'), state=dict(choices=['present', 'absent'], default='present'), zone=dict(), domain=dict(), account=dict(), project=dict(), tags=dict(type='list', aliases=['tag']), poll_async=dict(type='bool', default=True), )) required_together = cs_required_together() required_together.extend([ ['icmp_type', 'icmp_code'], ]) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), mutually_exclusive=( ['icmp_type', 'start_port'], ['icmp_type', 'end_port'], ), supports_check_mode=True) acs_network_acl_rule = AnsibleCloudStackNetworkAclRule(module) state = module.params.get('state') if state == 'absent': network_acl_rule = acs_network_acl_rule.absent_network_acl_rule() else: network_acl_rule = acs_network_acl_rule.present_network_acl_rule() result = acs_network_acl_rule.get_result(network_acl_rule) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update(dict(zone=dict(type='str', aliases=['name']), )) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) acs_zone_info = AnsibleCloudStackZoneInfo(module=module) result = acs_zone_info.get_zone() module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True), state=dict(choices=[ 'present', 'absent', 'enabled', 'disabled', 'locked', 'unlocked' ], default='present'), account_type=dict(choices=['user', 'root_admin', 'domain_admin'], default='user'), network_domain=dict(), domain=dict(default='ROOT'), email=dict(), first_name=dict(), last_name=dict(), username=dict(), password=dict(no_log=True), timezone=dict(), role=dict(), ldap_domain=dict(), ldap_type=dict(choices=['GROUP', 'OU'], default='GROUP'), poll_async=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_acc = AnsibleCloudStackAccount(module) state = module.params.get('state') if state in ['absent']: account = acs_acc.absent_account() elif state in ['enabled', 'unlocked']: account = acs_acc.enable_account() elif state in ['disabled']: account = acs_acc.disable_account() elif state in ['locked']: account = acs_acc.lock_account() else: account = acs_acc.present_account() result = acs_acc.get_result(account) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( name=dict(required=True), display_text=dict(), cpu_number=dict(type='int'), cpu_speed=dict(type='int'), limit_cpu_usage=dict(type='bool'), deployment_planner=dict(), domain=dict(), host_tags=dict(type='list', aliases=['host_tag']), hypervisor_snapshot_reserve=dict(type='int'), disk_bytes_read_rate=dict(type='int', aliases=['bytes_read_rate']), disk_bytes_write_rate=dict(type='int', aliases=['bytes_write_rate']), disk_iops_read_rate=dict(type='int'), disk_iops_write_rate=dict(type='int'), disk_iops_max=dict(type='int'), disk_iops_min=dict(type='int'), is_system=dict(type='bool', default=False), is_volatile=dict(type='bool'), is_iops_customized=dict(type='bool', aliases=['disk_iops_customized']), memory=dict(type='int'), network_rate=dict(type='int'), offer_ha=dict(type='bool'), provisioning_type=dict(choices=['thin', 'sparse', 'fat']), service_offering_details=dict(type='list'), storage_type=dict(choices=['local', 'shared']), system_vm_type=dict( choices=['domainrouter', 'consoleproxy', 'secondarystoragevm' ]), storage_tags=dict(type='list', aliases=['storage_tag']), state=dict(choices=['present', 'absent'], default='present'), is_customized=dict(type='bool'), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_so = AnsibleCloudStackServiceOffering(module) state = module.params.get('state') if state == "absent": service_offering = acs_so.absent_service_offering() else: service_offering = acs_so.present_service_offering() result = acs_so.get_result(service_offering) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update(dict( ip_address=dict(), network=dict(), cidrs=dict(type='list', default='0.0.0.0/0', aliases=['cidr']), protocol=dict(choices=['tcp', 'udp', 'icmp', 'all'], default='tcp'), type=dict(choices=['ingress', 'egress'], default='ingress'), icmp_type=dict(type='int'), icmp_code=dict(type='int'), start_port=dict(type='int', aliases=['port']), end_port=dict(type='int'), state=dict(choices=['present', 'absent'], default='present'), zone=dict(), domain=dict(), account=dict(), project=dict(), poll_async=dict(type='bool', default=True), tags=dict(type='list', aliases=['tag'], default=None), )) required_together = cs_required_together() required_together.extend([ ['icmp_type', 'icmp_code'], ]) module = AnsibleModule( argument_spec=argument_spec, required_together=required_together, required_one_of=( ['ip_address', 'network'], ), mutually_exclusive=( ['icmp_type', 'start_port'], ['icmp_type', 'end_port'], ['ip_address', 'network'], ), supports_check_mode=True ) acs_fw = AnsibleCloudStackFirewall(module) state = module.params.get('state') if state in ['absent']: fw_rule = acs_fw.remove_firewall_rule() else: fw_rule = acs_fw.create_firewall_rule() result = acs_fw.get_result(fw_rule) module.exit_json(**result)
def main(): argument_spec = cs_argument_spec() argument_spec.update( dict( username=dict(required=True), account=dict(), state=dict(choices=[ 'present', 'absent', 'enabled', 'disabled', 'locked', 'unlocked' ], default='present'), domain=dict(default='ROOT'), email=dict(), first_name=dict(), last_name=dict(), password=dict(no_log=True), timezone=dict(), keys_registered=dict(type='bool', default=False), poll_async=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec=argument_spec, required_together=cs_required_together(), supports_check_mode=True) acs_acc = AnsibleCloudStackUser(module) state = module.params.get('state') if state == 'absent': user = acs_acc.absent_user() elif state in ['enabled', 'unlocked']: user = acs_acc.enable_user() elif state == 'disabled': user = acs_acc.disable_user() elif state == 'locked': user = acs_acc.lock_user() else: user = acs_acc.present_user() result = acs_acc.get_result(user) module.exit_json(**result)