def main():
argument_spec = vultr_argument_spec()
argument_spec.update(
dict(domain=dict(required=True),
name=dict(default="", aliases=['subrecord']),
state=dict(choices=['present', 'absent'], default='present'),
ttl=dict(type='int', default=300),
record_type=dict(choices=RECORD_TYPES,
default='A',
aliases=['type']),
multiple=dict(type='bool', default=False),
priority=dict(type='int', default=0),
data=dict()))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
('state', 'present', ['data']),
('multiple', True, ['data']),
],
supports_check_mode=True,
)
vr_record = AnsibleVultrDnsRecord(module)
if module.params.get('state') == "absent":
record = vr_record.absent_record()
else:
record = vr_record.present_record()
result = vr_record.get_result(record)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(dict(
group=dict(required=True),
start_port=dict(type='int', aliases=['port']),
end_port=dict(type='int'),
protocol=dict(choices=['tcp', 'udp', 'gre', 'icmp'], default='tcp'),
cidr=dict(),
ip_version=dict(choices=['v4', 'v6'], default='v4'),
state=dict(choices=['present', 'absent'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
vr_firewall_rule = AnsibleVultrFirewallRule(module)
if module.params.get('state') == "absent":
firewall_rule = vr_firewall_rule.absent_firewall_rule()
else:
firewall_rule = vr_firewall_rule.present_firewall_rule()
result = vr_firewall_rule.get_result(firewall_rule)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(
dict(
group=dict(required=True),
start_port=dict(type='int', aliases=['port']),
end_port=dict(type='int'),
protocol=dict(choices=['tcp', 'udp', 'gre', 'icmp'],
default='tcp'),
cidr=dict(),
ip_version=dict(choices=['v4', 'v6'], default='v4'),
state=dict(choices=['present', 'absent'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
vr_firewall_rule = AnsibleVultrFirewallRule(module)
if module.params.get('state') == "absent":
firewall_rule = vr_firewall_rule.absent_firewall_rule()
else:
firewall_rule = vr_firewall_rule.present_firewall_rule()
result = vr_firewall_rule.get_result(firewall_rule)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(
dict(
name=dict(type='str', required=True),
email=dict(type='str', ),
password=dict(type='str', no_log=True),
force=dict(type='bool', default=False),
api_enabled=dict(type='bool', default=True),
acls=dict(type='list', choices=ACLS, aliases=['acl']),
state=dict(type='str',
choices=['present', 'absent'],
default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
('state', 'present', ['email', 'acls']),
],
supports_check_mode=True,
)
vultr_user = AnsibleVultrUser(module)
if module.params.get('state') == "absent":
user = vultr_user.absent_user()
else:
user = vultr_user.present_user()
result = vultr_user.get_result(user)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(
dict(
name=dict(required=True),
ssh_key=dict(),
state=dict(choices=['present', 'absent'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
('state', 'present', ['ssh_key']),
],
supports_check_mode=True,
)
vultr_ssh_key = AnsibleVultrSshKey(module)
if module.params.get('state') == "absent":
ssh_key = vultr_ssh_key.absent_ssh_key()
else:
ssh_key = vultr_ssh_key.present_ssh_key()
result = vultr_ssh_key.get_result(ssh_key)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(dict(
domain=dict(required=True),
name=dict(default="", aliases=['subrecord']),
state=dict(choices=['present', 'absent'], default='present'),
ttl=dict(type='int', default=300),
record_type=dict(choices=RECORD_TYPES, default='A', aliases=['type']),
multiple=dict(type='bool', default=False),
priority=dict(type='int', default=0),
data=dict()
))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
('state', 'present', ['data']),
('multiple', True, ['data']),
],
supports_check_mode=True,
)
vr_record = AnsibleVultrDnsRecord(module)
if module.params.get('state') == "absent":
record = vr_record.absent_record()
else:
record = vr_record.present_record()
result = vr_record.get_result(record)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(dict(
name=dict(required=True),
email=dict(),
password=dict(no_log=True),
force=dict(type='bool', default=False),
api_enabled=dict(type='bool', default=True),
acls=dict(type='list', aliases=['acl']),
state=dict(choices=['present', 'absent'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
('state', 'present', ['email', 'acls']),
],
supports_check_mode=True,
)
vr_user = AnsibleVultrUser(module)
if module.params.get('state') == "absent":
user = vr_user.absent_user()
else:
user = vr_user.present_user()
result = vr_user.get_result(user)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(dict(
name=dict(required=True),
script=dict(),
script_type=dict(default='boot', choices=['boot', 'pxe'], aliases=['type']),
state=dict(choices=['present', 'absent'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
('state', 'present', ['script']),
],
supports_check_mode=True,
)
vr_script = AnsibleVultrStartupScript(module)
if module.params.get('state') == "absent":
script = vr_script.absent_script()
else:
script = vr_script.present_script()
result = vr_script.get_result(script)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(
dict(
name=dict(required=True, aliases=['domain']),
server_ip=dict(),
state=dict(choices=['present', 'absent'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
('state', 'present', ['server_ip']),
],
supports_check_mode=True,
)
vultr_domain = AnsibleVultrDnsDomain(module)
if module.params.get('state') == "absent":
domain = vultr_domain.absent_domain()
else:
domain = vultr_domain.present_domain()
result = vultr_domain.get_result(domain)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
sshkey_info = AnsibleVultrSSHKeyInfo(module)
result = sshkey_info.get_result(parse_keys_list(sshkey_info.get_sshkeys()))
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
account_info = AnsibleVultrAccountInfo(module)
result = account_info.get_result(account_info.get_account_info())
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
server_info = AnsibleVultrServerInfo(module)
result = server_info.get_result(parse_servers_list(server_info.get_servers()))
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
domain_info = AnsibleVultrDnsDomainInfo(module)
result = domain_info.get_result(domain_info.get_domains())
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
user_info = AnsibleVultrUserInfo(module)
result = user_info.get_result(user_info.get_regions())
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
plan_info = AnsibleVultrPlanInfo(module)
result = plan_info.get_result(parse_plans_list(plan_info.get_plans()))
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
network_info = AnsibleVultrNetworkInfo(module)
result = network_info.get_result(parse_network_list(network_info.get_networks()))
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
volume_info = AnsibleVultrBlockStorageFacts(module)
result = volume_info.get_result(volume_info.get_block_storage_volumes())
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
os_info = AnsibleVultrOSInfo(module)
result = os_info.get_result(parse_oses_list(os_info.get_oses()))
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
os_facts = AnsibleVultrOSFacts(module)
result = os_facts.get_result(parse_oses_list(os_facts.get_oses()))
ansible_facts = {'vultr_os_facts': result['vultr_os_facts']}
module.exit_json(ansible_facts=ansible_facts, **result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
user_facts = AnsibleVultrUserFacts(module)
result = user_facts.get_result(user_facts.get_regions())
ansible_facts = {'vultr_user_facts': result['vultr_user_facts']}
module.exit_json(ansible_facts=ansible_facts, **result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
account_facts = AnsibleVultrAccountFacts(module)
result = account_facts.get_result(account_facts.get_account_info())
ansible_facts = {'vultr_account_facts': result['vultr_account_facts']}
module.exit_json(ansible_facts=ansible_facts, **result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
fw_group_info = AnsibleVultrFirewallGroupInfo(module)
result = fw_group_info.get_result(
parse_fw_group_list(fw_group_info.get_firewall_group()))
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
startupscript_info = AnsibleVultrStartupScriptInfo(module)
result = startupscript_info.get_result(
parse_startupscript_list(startupscript_info.get_startupscripts()))
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(
dict(
name=dict(required=True, aliases=['label']),
hostname=dict(),
os=dict(),
snapshot=dict(),
plan=dict(),
force=dict(type='bool', default=False),
notify_activate=dict(type='bool', default=False),
private_network_enabled=dict(type='bool'),
auto_backup_enabled=dict(type='bool'),
ipv6_enabled=dict(type='bool'),
tag=dict(),
reserved_ip_v4=dict(),
firewall_group=dict(),
startup_script=dict(),
user_data=dict(),
ssh_keys=dict(type='list', aliases=['ssh_key']),
region=dict(),
state=dict(choices=[
'present', 'absent', 'restarted', 'reinstalled', 'started',
'stopped'
],
default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
vultr_server = AnsibleVultrServer(module)
if module.params.get('state') == "absent":
server = vultr_server.absent_server()
else:
if module.params.get('state') == "started":
server = vultr_server.present_server()
server = vultr_server.start_server()
elif module.params.get('state') == "stopped":
server = vultr_server.present_server(start_server=False)
server = vultr_server.stop_server()
elif module.params.get('state') == "restarted":
server = vultr_server.present_server()
server = vultr_server.restart_server()
elif module.params.get('state') == "reinstalled":
server = vultr_server.reinstall_server()
else:
server = vultr_server.present_server()
result = vultr_server.get_result(server)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
region_facts = AnsibleVultrRegionFacts(module)
result = region_facts.get_result(
parse_regions_list(region_facts.get_regions()))
ansible_facts = {'vultr_region_facts': result['vultr_region_facts']}
module.exit_json(ansible_facts=ansible_facts, **result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
sshkey_facts = AnsibleVultrSSHKeyFacts(module)
result = sshkey_facts.get_result(
parse_keys_list(sshkey_facts.get_sshkeys()))
ansible_facts = {'vultr_ssh_key_facts': result['vultr_ssh_key_facts']}
module.exit_json(ansible_facts=ansible_facts, **result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
network_facts = AnsibleVultrNetworkFacts(module)
result = network_facts.get_result(
parse_network_list(network_facts.get_networks()))
ansible_facts = {'vultr_network_facts': result['vultr_network_facts']}
module.exit_json(ansible_facts=ansible_facts, **result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
domain_facts = AnsibleVultrDnsDomainFacts(module)
result = domain_facts.get_result(domain_facts.get_domains())
ansible_facts = {
'vultr_dns_domain_facts': result['vultr_dns_domain_facts']
}
module.exit_json(ansible_facts=ansible_facts, **result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
account_facts = AnsibleVultrAccountFacts(module)
result = account_facts.get_result(account_facts.get_account_info())
ansible_facts = {
'vultr_account_facts': result['vultr_account_facts']
}
module.exit_json(ansible_facts=ansible_facts, **result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
fw_group_facts = AnsibleVultrFirewallGroupFacts(module)
result = fw_group_facts.get_result(parse_fw_group_list(fw_group_facts.get_firewall_group()))
ansible_facts = {
'vultr_firewall_group_facts': result['vultr_firewall_group_facts']
}
module.exit_json(ansible_facts=ansible_facts, **result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
volume_facts = AnsibleVultrBlockStorageFacts(module)
result = volume_facts.get_result(volume_facts.get_block_storage_volumes())
ansible_facts = {
'vultr_block_storage_facts': result['vultr_block_storage_facts']
}
module.exit_json(ansible_facts=ansible_facts, **result)
def main():
argument_spec = vultr_argument_spec()
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
startupscript_facts = AnsibleVultrStartupScriptFacts(module)
result = startupscript_facts.get_result(parse_startupscript_list(startupscript_facts.get_startupscripts()))
ansible_facts = {
'vultr_startup_script_facts': result['vultr_startup_script_facts']
}
module.exit_json(ansible_facts=ansible_facts, **result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(dict(
name=dict(required=True, aliases=['label']),
hostname=dict(),
os=dict(),
plan=dict(),
force=dict(type='bool', default=False),
notify_activate=dict(type='bool', default=False),
private_network_enabled=dict(type='bool'),
auto_backup_enabled=dict(type='bool'),
ipv6_enabled=dict(type='bool'),
tag=dict(),
reserved_ip_v4=dict(),
firewall_group=dict(),
startup_script=dict(),
user_data=dict(),
ssh_keys=dict(type='list', aliases=['ssh_key']),
region=dict(),
state=dict(choices=['present', 'absent', 'restarted', 'reinstalled', 'started', 'stopped'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
vr_server = AnsibleVultrServer(module)
if module.params.get('state') == "absent":
server = vr_server.absent_server()
else:
if module.params.get('state') == "started":
server = vr_server.present_server()
server = vr_server.start_server()
elif module.params.get('state') == "stopped":
server = vr_server.present_server(start_server=False)
server = vr_server.stop_server()
elif module.params.get('state') == "restarted":
server = vr_server.present_server()
server = vr_server.restart_server()
elif module.params.get('state') == "reinstalled":
server = vr_server.reinstall_server()
else:
server = vr_server.present_server()
result = vr_server.get_result(server)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(dict(
name=dict(required=True, aliases=['description']),
state=dict(choices=['present', 'absent'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
vr_firewall_group = AnsibleVultrFirewallGroup(module)
if module.params.get('state') == "absent":
firewall_group = vr_firewall_group.absent_firewall_group()
else:
firewall_group = vr_firewall_group.present_firewall_group()
result = vr_firewall_group.get_result(firewall_group)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(
dict(
name=dict(required=True, aliases=['description']),
state=dict(choices=['present', 'absent'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
vultr_firewall_group = AnsibleVultrFirewallGroup(module)
if module.params.get('state') == "absent":
firewall_group = vultr_firewall_group.absent_firewall_group()
else:
firewall_group = vultr_firewall_group.present_firewall_group()
result = vultr_firewall_group.get_result(firewall_group)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(
dict(
name=dict(required=True, aliases=['description', 'label']),
cidr=dict(),
region=dict(),
state=dict(choices=['present', 'absent'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[['state', 'present', ['cidr', 'region']]])
vultr_network = AnsibleVultrNetwork(module)
if module.params.get('state') == "absent":
network = vultr_network.absent_network()
else:
network = vultr_network.present_network()
result = vultr_network.get_result(network)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(dict(
name=dict(required=True),
ssh_key=dict(),
state=dict(choices=['present', 'absent'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
('state', 'present', ['ssh_key']),
],
supports_check_mode=True,
)
vr_ssh_key = AnsibleVultrSshKey(module)
if module.params.get('state') == "absent":
ssh_key = vr_ssh_key.absent_ssh_key()
else:
ssh_key = vr_ssh_key.present_ssh_key()
result = vr_ssh_key.get_result(ssh_key)
module.exit_json(**result)
def main():
argument_spec = vultr_argument_spec()
argument_spec.update(dict(
name=dict(required=True),
server_ip=dict(),
state=dict(choices=['present', 'absent'], default='present'),
))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
('state', 'present', ['server_ip']),
],
supports_check_mode=True,
)
vr_domain = AnsibleVultrDnsDomain(module)
if module.params.get('state') == "absent":
domain = vr_domain.absent_domain()
else:
domain = vr_domain.present_domain()
result = vr_domain.get_result(domain)
module.exit_json(**result)
