def run_module():
# define available arguments/parameters a user can pass to the module
module_args = dict(state=dict(type='str',
default='present',
choices=['present', 'absent']),
name=dict(type='str', required=True, aliases=['group']),
ldapconfig=dict(type='str', default=None),
ldapsearchquery=dict(type='str', default=None),
ldapuserattribute=dict(type='str', default=None),
maxlocktime=dict(type='str', default='unset'),
maxopenfiles=dict(type='str', default='unset'),
maxresults=dict(type='str', default='unset'),
maxscanrows=dict(type='str', default='unset'),
owners=dict(type='list', elements='str', default=None),
passwordtimeout=dict(type='str', default='unset'),
subgroups=dict(type='list',
elements='str',
default=None),
timeout=dict(type='str', default='43200'),
users=dict(type='list', elements='str', default=None),
server=dict(type='str',
required=True,
aliases=['p4port'],
fallback=(env_fallback, ['P4PORT'])),
user=dict(type='str',
required=True,
aliases=['p4user'],
fallback=(env_fallback, ['P4USER'])),
password=dict(type='str',
required=True,
aliases=['p4passwd'],
fallback=(env_fallback, ['P4PASSWD']),
no_log=True),
charset=dict(type='str',
default='none',
aliases=['p4charset'],
fallback=(env_fallback, ['P4CHARSET'])),
serverid=dict(type='str', default='any'))
result = dict(changed=False, )
module = AnsibleModule(argument_spec=module_args, supports_check_mode=True)
# connect to helix
p4 = helix_core_connect(module, 'ansible')
try:
# get existing group definition
p4_group_spec = p4.fetch_group(module.params['name'])
if module.params['state'] == 'present':
if 'Users' in p4_group_spec:
# check to see if any fields have changed
p4_group_changes = []
p4_group_changes.append(
p4_group_spec['Group'] == module.params['name'])
p4_group_changes.append(p4_group_spec['MaxLockTime'] ==
module.params['maxlocktime'])
p4_group_changes.append(p4_group_spec['MaxResults'].rstrip() ==
module.params['maxresults'])
p4_group_changes.append(p4_group_spec['MaxOpenFiles'] ==
module.params['maxopenfiles'])
p4_group_changes.append(p4_group_spec['MaxScanRows'] ==
module.params['maxscanrows'])
p4_group_changes.append(p4_group_spec['PasswordTimeout'] ==
module.params['passwordtimeout'])
p4_group_changes.append(
p4_group_spec['Timeout'] == module.params['timeout'])
if module.params['ldapconfig'] is not None:
p4_group_changes.append(p4_group_spec['LdapConfig'] ==
module.params['ldapconfig'])
elif 'LdapConfig' in p4_group_spec:
p4_group_changes.append(False)
if module.params['ldapsearchquery'] is not None:
p4_group_changes.append(p4_group_spec['LdapSearchQuery'] ==
module.params['ldapsearchquery'])
elif 'LdapSearchQuery' in p4_group_spec:
p4_group_changes.append(False)
if module.params['ldapuserattribute'] is not None:
p4_group_changes.append(
p4_group_spec['LdapUserAttribute'] ==
module.params['ldapuserattribute'])
elif 'LdapUserAttribute' in p4_group_spec:
p4_group_changes.append(False)
if module.params['owners'] is not None:
p4_group_changes.append(
p4_group_spec['Owners'] == module.params['owners'])
elif 'Owners' in p4_group_spec:
p4_group_changes.append(False)
if module.params['subgroups'] is not None:
p4_group_changes.append(p4_group_spec['Subgroups'] ==
module.params['subgroups'])
elif 'Subgroups' in p4_group_spec:
p4_group_changes.append(False)
if module.params['users'] is not None:
p4_group_changes.append(
p4_group_spec['Users'] == module.params['users'])
elif 'Users' in p4_group_spec:
p4_group_changes.append(False)
# check to see if changes are detected in any of the fields
if (all(p4_group_changes)):
result['changed'] = False
# if changes are detected, update group with new values
else:
if not module.check_mode:
p4_group_spec['Group'] = module.params['name']
p4_group_spec['MaxLockTime'] = module.params[
'maxlocktime']
p4_group_spec['MaxResults'] = module.params[
'maxresults']
p4_group_spec['MaxOpenFiles'] = module.params[
'maxopenfiles']
p4_group_spec['MaxScanRows'] = module.params[
'maxscanrows']
p4_group_spec['PasswordTimeout'] = module.params[
'passwordtimeout']
p4_group_spec['Timeout'] = module.params['timeout']
if module.params['ldapconfig'] is not None:
p4_group_spec['LdapConfig'] = module.params[
'ldapconfig']
elif 'LdapConfig' in p4_group_spec:
del p4_group_spec['LdapConfig']
if module.params['ldapsearchquery'] is not None:
p4_group_spec['LdapSearchQuery'] = module.params[
'ldapsearchquery']
elif 'LdapSearchQuery' in p4_group_spec:
del p4_group_spec['LdapSearchQuery']
if module.params['ldapuserattribute'] is not None:
p4_group_spec['LdapUserAttribute'] = module.params[
'ldapuserattribute']
elif 'LdapUserAttribute' in p4_group_spec:
del p4_group_spec['LdapUserAttribute']
if module.params['owners'] is not None:
p4_group_spec['Owners'] = module.params['owners']
elif 'Owners' in p4_group_spec:
del p4_group_spec['Owners']
if module.params['subgroups'] is not None:
p4_group_spec['Subgroups'] = module.params[
'subgroups']
elif 'Subgroups' in p4_group_spec:
del p4_group_spec['Subgroups']
if module.params['users'] is not None:
p4_group_spec['Users'] = module.params['users']
elif 'Users' in p4_group_spec:
del p4_group_spec['Users']
p4.save_group(p4_group_spec)
result['changed'] = True
# create new user with specified values
else:
if not module.check_mode:
p4_group_spec['Group'] = module.params['name']
p4_group_spec['MaxLockTime'] = module.params['maxlocktime']
p4_group_spec['MaxResults'] = module.params['maxresults']
p4_group_spec['MaxOpenFiles'] = module.params[
'maxopenfiles']
p4_group_spec['MaxScanRows'] = module.params['maxscanrows']
p4_group_spec['PasswordTimeout'] = module.params[
'passwordtimeout']
p4_group_spec['Timeout'] = module.params['timeout']
if module.params['ldapconfig'] is not None:
p4_group_spec['LdapConfig'] = module.params[
'ldapconfig']
if module.params['ldapsearchquery'] is not None:
p4_group_spec['LdapSearchQuery'] = module.params[
'ldapsearchquery']
if module.params['ldapuserattribute'] is not None:
p4_group_spec['LdapUserAttribute'] = module.params[
'ldapuserattribute']
if module.params['owners'] is not None:
p4_group_spec['Owners'] = module.params['owners']
if module.params['subgroups'] is not None:
p4_group_spec['Subgroups'] = module.params['subgroups']
if module.params['users'] is not None:
p4_group_spec['Users'] = module.params['users']
p4.save_group(p4_group_spec)
result['changed'] = True
elif module.params['state'] == 'absent':
# delete group
if 'Users' in p4_group_spec:
if not module.check_mode:
p4.delete_group(module.params['name'])
result['changed'] = True
else:
result['changed'] = False
except Exception as e:
module.fail_json(msg="Error: {0}".format(e), **result)
helix_core_disconnect(module, p4)
module.exit_json(**result)
def run_module():
# define available arguments/parameters a user can pass to the module
module_args = dict(
state=dict(type='str',
default='present',
choices=['present', 'absent']),
address=dict(type='str', default=None),
allowedaddresses=dict(type='list', elements='str', default=None),
archivedatafilter=dict(type='list', elements='str', default=None),
clientdatafilter=dict(type='list', elements='str', default=None),
description=dict(type='str'),
distributedconfig=dict(type='list', elements='str', default=None),
externaladdress=dict(type='str', default=None),
options=dict(type='str', default='nomandatory'),
replicatingfrom=dict(type='str', default=None),
revisiondatafilter=dict(type='list', elements='str', default=None),
name=dict(type='str', default=None),
serverid=dict(type='str', required=True),
services=dict(type='str',
default='standard',
choices=[
'standard', 'replica', 'forwarding-replica',
'commit-server', 'edge-server', 'build-server',
'standby', 'forwarding-standby', 'local', 'P4AUTH',
'P4CHANGE'
]),
serviceuser=dict(type='str', default=None),
type=dict(type='str', default='server'),
updatedcachedrepos=dict(type='str', default=None),
server=dict(type='str',
required=True,
aliases=['p4port'],
fallback=(env_fallback, ['P4PORT'])),
user=dict(type='str',
required=True,
aliases=['p4user'],
fallback=(env_fallback, ['P4USER'])),
password=dict(type='str',
required=True,
aliases=['p4passwd'],
fallback=(env_fallback, ['P4PASSWD']),
no_log=True),
charset=dict(type='str',
default='none',
aliases=['p4charset'],
fallback=(env_fallback, ['P4CHARSET'])),
)
result = dict(changed=False, )
module = AnsibleModule(argument_spec=module_args, supports_check_mode=True)
# connect to helix
p4 = helix_core_connect(module, 'ansible')
try:
# if description is not given, set a default
if module.params['description'] is None:
module.params['description'] = "Created by {0}.".format(
module.params['user'])
if module.params['state'] == 'present':
# get server definition
p4_server_spec = p4.fetch_server(module.params['serverid'])
servers_dict = p4.run('servers')
# look through the list of servers specs returned and see if any match the current server id
# if a server spec is found with the current server id, let's look for any changes in attributes
if any(server_dict['ServerID'] == module.params['serverid']
for server_dict in servers_dict):
# check to see if any fields have changed
p4_server_changes = []
p4_server_changes.append(p4_server_spec["Description"].rstrip(
) == module.params['description'])
p4_server_changes.append(
p4_server_spec["Options"] == module.params['options'])
p4_server_changes.append(
p4_server_spec["Services"] == module.params['services'])
p4_server_changes.append(
p4_server_spec["Type"] == module.params['type'])
if module.params['address'] is not None:
p4_server_changes.append(
p4_server_spec["Address"] == module.params['address'])
elif 'Address' in p4_server_spec:
p4_server_changes.append(False)
if module.params['allowedaddresses'] is not None:
p4_server_changes.append(
p4_server_spec["AllowedAddresses"] ==
module.params['allowedaddresses'])
elif 'AllowedAddresses' in p4_server_spec:
p4_server_changes.append(False)
if module.params['archivedatafilter'] is not None:
p4_server_changes.append(
p4_server_spec["ArchiveDataFilter"] ==
module.params['archivedatafilter'])
elif 'ArchiveDataFilter' in p4_server_spec:
p4_server_changes.append(False)
if module.params['clientdatafilter'] is not None:
p4_server_changes.append(
p4_server_spec["ClientDataFilter"] ==
module.params['clientdatafilter'])
elif 'ClientDataFilter' in p4_server_spec:
p4_server_changes.append(False)
# ToDo - figure out how to get current configurables for this server id and compare to this if not provided
# if module.params['distributedconfig'] is not None:
# p4_server_changes.append(p4_server_spec["DistributedConfig"] == module.params['distributedconfig'])
# elif 'DistributedConfig' in p4_server_spec:
# p4_server_changes.append(False)
if module.params['externaladdress'] is not None:
p4_server_changes.append(
p4_server_spec["ExternalAddress"] ==
module.params['externaladdress'])
elif 'ExternalAddress' in p4_server_spec:
p4_server_changes.append(False)
if module.params['name'] is not None:
p4_server_changes.append(
p4_server_spec["Name"] == module.params['name'])
elif 'Name' in p4_server_spec:
p4_server_changes.append(False)
if module.params['replicatingfrom'] is not None:
p4_server_changes.append(
p4_server_spec["ReplicatingFrom"] ==
module.params['replicatingfrom'])
elif 'ReplicatingFrom' in p4_server_spec:
p4_server_changes.append(False)
if module.params['revisiondatafilter'] is not None:
p4_server_changes.append(
p4_server_spec["RevisionDataFilter"] ==
module.params['revisiondatafilter'])
elif 'RevisionDataFilter' in p4_server_spec:
p4_server_changes.append(False)
if module.params['updatedcachedrepos'] is not None:
p4_server_changes.append(
p4_server_spec["UpdatedCachedRepos"] ==
module.params['updatedcachedrepos'])
elif 'UpdatedCachedRepos' in p4_server_spec:
p4_server_changes.append(False)
if module.params['serviceuser'] is not None:
p4_server_changes.append(
p4_server_spec["User"] == module.params['serviceuser'])
elif 'User' in p4_server_spec:
p4_server_changes.append(False)
# check to see if changes are detected in any of the fields
if (all(p4_server_changes)):
result['changed'] = False
# if changes are detected, update server spec with new values
else:
if not module.check_mode:
p4_server_spec["Description"] = module.params[
'description']
p4_server_spec["Options"] = module.params['options']
p4_server_spec["Services"] = module.params['services']
p4_server_spec["Type"] = module.params['type']
if module.params['address'] is not None:
p4_server_spec["Address"] = module.params[
'address']
elif 'Address' in p4_server_spec:
del p4_server_spec["Address"]
if module.params['allowedaddresses'] is not None:
p4_server_spec["AllowedAddresses"] = module.params[
'allowedaddresses']
elif 'AllowedAddresses' in p4_server_spec:
del p4_server_spec["AllowedAddresses"]
if module.params['archivedatafilter'] is not None:
p4_server_spec[
"ArchiveDataFilter"] = module.params[
'archivedatafilter']
elif 'ArchiveDataFilter' in p4_server_spec:
del p4_server_spec["ArchiveDataFilter"]
if module.params['clientdatafilter'] is not None:
p4_server_spec["ClientDataFilter"] = module.params[
'clientdatafilter']
elif 'ClientDataFilter' in p4_server_spec:
del p4_server_spec["ClientDataFilter"]
if module.params['distributedconfig'] is not None:
p4_server_spec[
"DistributedConfig"] = module.params[
'distributedconfig']
elif 'DistributedConfig' in p4_server_spec:
del p4_server_spec["DistributedConfig"]
if module.params['externaladdress'] is not None:
p4_server_spec["ExternalAddress"] = module.params[
'externaladdress']
elif 'ExternalAddress' in p4_server_spec:
del p4_server_spec["ExternalAddress"]
if module.params['name'] is not None:
p4_server_spec["Name"] = module.params['name']
elif 'Name' in p4_server_spec:
del p4_server_spec["Name"]
if module.params['replicatingfrom'] is not None:
p4_server_spec["ReplicatingFrom"] = module.params[
'replicatingfrom']
elif 'ReplicatingFrom' in p4_server_spec:
del p4_server_spec["ReplicatingFrom"]
if module.params['revisiondatafilter'] is not None:
p4_server_spec[
"RevisionDataFilter"] = module.params[
'revisiondatafilter']
elif 'RevisionDataFilter' in p4_server_spec:
del p4_server_spec["RevisionDataFilter"]
if module.params['serviceuser'] is not None:
p4_server_spec["User"] = module.params[
'serviceuser']
elif 'User' in p4_server_spec:
del p4_server_spec["User"]
if module.params['updatedcachedrepos'] is not None:
p4_server_spec[
"UpdatedCachedRepos"] = module.params[
'updatedcachedrepos']
elif 'UpdatedCachedRepos' in p4_server_spec:
del p4_server_spec["UpdatedCachedRepos"]
p4.save_server(p4_server_spec)
result['changed'] = True
# create new server spec with specified values
else:
if not module.check_mode:
p4_server_spec["ServerID"] = module.params['serverid']
p4_server_spec["Description"] = module.params[
'description']
p4_server_spec["Options"] = module.params['options']
p4_server_spec["Services"] = module.params['services']
p4_server_spec["Type"] = module.params['type']
if module.params['address'] is not None:
p4_server_spec["Address"] = module.params['address']
if module.params['allowedaddresses'] is not None:
p4_server_spec["AllowedAddresses"] = module.params[
'allowedaddresses']
if module.params['archivedatafilter'] is not None:
p4_server_spec["ArchiveDataFilter"] = module.params[
'archivedatafilter']
if module.params['clientdatafilter'] is not None:
p4_server_spec["ClientDataFilter"] = module.params[
'clientdatafilter']
if module.params['distributedconfig'] is not None:
p4_server_spec["DistributedConfig"] = module.params[
'distributedconfig']
if module.params['externaladdress'] is not None:
p4_server_spec["ExternalAddress"] = module.params[
'externaladdress']
if module.params['name'] is not None:
p4_server_spec["Name"] = module.params['name']
if module.params['replicatingfrom'] is not None:
p4_server_spec["ReplicatingFrom"] = module.params[
'replicatingfrom']
if module.params['revisiondatafilter'] is not None:
p4_server_spec["RevisionDataFilter"] = module.params[
'revisiondatafilter']
if module.params['serviceuser'] is not None:
p4_server_spec["User"] = module.params['serviceuser']
if module.params['updatedcachedrepos'] is not None:
p4_server_spec["UpdatedCachedRepos"] = module.params[
'updatedcachedrepos']
p4.save_server(p4_server_spec)
result['changed'] = True
elif module.params['state'] == 'absent':
servers_dict = p4.run('servers')
# delete server spec
if any(server_dict['ServerID'] == module.params['serverid']
for server_dict in servers_dict):
if not module.check_mode:
p4.delete_server(module.params['serverid'])
result['changed'] = True
else:
result['changed'] = False
except Exception as e:
module.fail_json(msg="Error: {0}".format(e), **result)
helix_core_disconnect(module, p4)
module.exit_json(**result)
def run_module():
# define available arguments/parameters a user can pass to the module
module_args = dict(state=dict(type='str',
default='present',
choices=['present', 'absent']),
name=dict(type='str', required=True),
value=dict(type='str', required=True),
server=dict(type='str',
required=True,
aliases=['p4port'],
fallback=(env_fallback, ['P4PORT'])),
user=dict(type='str',
required=True,
aliases=['p4user'],
fallback=(env_fallback, ['P4USER'])),
password=dict(type='str',
required=True,
aliases=['p4passwd'],
fallback=(env_fallback, ['P4PASSWD']),
no_log=True),
charset=dict(type='str',
default='none',
aliases=['p4charset'],
fallback=(env_fallback, ['P4CHARSET'])),
serverid=dict(type='str', default='any'))
result = dict(changed=False, )
module = AnsibleModule(argument_spec=module_args, supports_check_mode=True)
# connect to helix
p4 = helix_core_connect(module, 'ansible')
try:
# get existing config values
p4_current_configs = p4.run('configure', 'show', 'allservers')
p4_current_values = []
# search for all config values specific to this server id and add to list
for config in p4_current_configs:
if config["ServerName"] == module.params['serverid']:
p4_current_values.append(config)
# get the current value of our specific configurable
p4_current_value = next((item for item in p4_current_values
if item["Name"] == module.params['name']),
None)
if module.params['state'] == 'present':
if p4_current_value is None or module.params[
'value'] != p4_current_value['Value']:
if not module.check_mode:
p4.run(
'configure', 'set',
"{0}#{1}={2}".format(module.params['serverid'],
module.params['name'],
module.params['value']))
result['changed'] = True
elif module.params['state'] == 'absent':
if p4_current_value is not None:
if not module.check_mode:
p4.run(
'configure', 'unset',
"{0}#{1}".format(module.params['serverid'],
module.params['name']))
result['changed'] = True
except Exception as e:
module.fail_json(msg="Error: {0}".format(e), **result)
helix_core_disconnect(module, p4)
module.exit_json(**result)
def run_module():
# define available arguments/parameters a user can pass to the module
module_args = dict(
state=dict(type='str',
default='present',
choices=['present', 'absent']),
name=dict(type='str', required=True),
description=dict(type='str'),
host=dict(type='str'),
root=dict(type='str'),
altroots=dict(type='list', elements='str', default=None),
view=dict(type='list', elements='str', required=True),
lineend=dict(type='str',
default='local',
choices=['local', 'unix', 'mac', 'win', 'share']),
options=dict(
type='str',
default='noallwrite noclobber nocompress unlocked nomodtime normdir'
),
submitoptions=dict(type='str', default='submitunchanged'),
server=dict(type='str',
required=True,
aliases=['p4port'],
fallback=(env_fallback, ['P4PORT'])),
user=dict(type='str',
required=True,
aliases=['p4user'],
fallback=(env_fallback, ['P4USER'])),
password=dict(type='str',
required=True,
aliases=['p4passwd'],
fallback=(env_fallback, ['P4PASSWD']),
no_log=True),
charset=dict(type='str',
default='none',
aliases=['p4charset'],
fallback=(env_fallback, ['P4CHARSET'])),
serverid=dict(type='str', default='any'))
result = dict(changed=False, )
module = AnsibleModule(argument_spec=module_args, supports_check_mode=True)
# connect to helix
p4 = helix_core_connect(module, 'ansible')
try:
# get existing client definition
p4_client_spec = p4.fetch_client(module.params['name'])
# if description is not given, set a default
if module.params['description'] is None:
module.params['description'] = "Created by {0}.".format(
module.params['user'])
# if host is not given, set a default
if module.params['host'] is None:
module.params['host'] = gethostname()
# if root is not given, set a default
if module.params['root'] is None:
module.params['root'] = getcwd()
if module.params['state'] == 'present':
# check to see if any fields have changed
if 'Access' in p4_client_spec:
p4_client_changes = []
p4_client_changes.append(p4_client_spec["Description"].rstrip(
) == module.params['description'])
p4_client_changes.append(
p4_client_spec["Host"] == module.params['host'])
p4_client_changes.append(
p4_client_spec["Root"] == module.params['root'])
p4_client_changes.append(
p4_client_spec["View"] == module.params['view'])
p4_client_changes.append(
p4_client_spec["LineEnd"] == module.params['lineend'])
p4_client_changes.append(
p4_client_spec["Options"] == module.params['options'])
p4_client_changes.append(p4_client_spec["SubmitOptions"] ==
module.params['submitoptions'])
if module.params['altroots'] is not None:
p4_client_changes.append(p4_client_spec["AltRoots"] ==
module.params['altroots'])
elif 'AltRoots' in p4_client_spec:
p4_client_changes.append(False)
# check to see if changes are detected in any of the fields
if (all(p4_client_changes)):
result['changed'] = False
# if changes are detected, update client with new values
else:
if not module.check_mode:
p4_client_spec["Root"] = module.params['root']
p4_client_spec["Host"] = module.params['host']
p4_client_spec["Description"] = module.params[
'description']
p4_client_spec["View"] = module.params['view']
p4_client_spec["LineEnd"] = module.params['lineend']
p4_client_spec["Options"] = module.params['options']
p4_client_spec["SubmitOptions"] = module.params[
'submitoptions']
if module.params['altroots'] is not None:
p4_client_spec["AltRoots"] = module.params[
'altroots']
elif 'AltRoots' in p4_client_spec:
del p4_client_spec["AltRoots"]
p4.save_client(p4_client_spec)
result['changed'] = True
# create new client with specified values
else:
if not module.check_mode:
p4_client_spec["Root"] = module.params['root']
p4_client_spec["Host"] = module.params['host']
p4_client_spec["Description"] = module.params[
'description']
p4_client_spec["View"] = module.params['view']
p4_client_spec["LineEnd"] = module.params['lineend']
p4_client_spec["Options"] = module.params['options']
p4_client_spec["SubmitOptions"] = module.params[
'submitoptions']
if module.params['altroots'] is not None:
p4_client_spec["AltRoots"] = module.params['altroots']
p4.save_client(p4_client_spec)
result['changed'] = True
elif module.params['state'] == 'absent':
# delete client
if 'Access' in p4_client_spec:
if not module.check_mode:
p4.delete_client('-f', module.params['name'])
result['changed'] = True
else:
result['changed'] = False
except Exception as e:
module.fail_json(msg="Error: {0}".format(e), **result)
helix_core_disconnect(module, p4)
module.exit_json(**result)
def run_module():
# define available arguments/parameters a user can pass to the module
module_args = dict(
state=dict(type='str',
default='present',
choices=['present', 'absent']),
name=dict(type='str', required=True, aliases=['depot']),
description=dict(type='str'),
address=dict(type='str', default=None),
map=dict(type='str'),
specmap=dict(type='str', default=None),
streamdepth=dict(type='str', default=None),
suffix=dict(type='str', default=None),
type=dict(type='str',
default='local',
choices=[
'local', 'remote', 'stream', 'spec', 'unload', 'archive',
'tangent', 'graph'
]),
server=dict(type='str',
required=True,
aliases=['p4port'],
fallback=(env_fallback, ['P4PORT'])),
user=dict(type='str',
required=True,
aliases=['p4user'],
fallback=(env_fallback, ['P4USER'])),
password=dict(type='str',
required=True,
aliases=['p4passwd'],
fallback=(env_fallback, ['P4PASSWD']),
no_log=True),
charset=dict(type='str',
default='none',
aliases=['p4charset'],
fallback=(env_fallback, ['P4CHARSET'])),
)
result = dict(changed=False, )
module = AnsibleModule(argument_spec=module_args, supports_check_mode=True)
# connect to helix
p4 = helix_core_connect(module, 'ansible')
try:
# if description is not given, set a default
if module.params['description'] is None:
module.params['description'] = "Created by {0}.".format(
module.params['user'])
if module.params['map'] is None:
module.params['map'] = "{0}/...".format(module.params['name'])
if module.params['state'] == 'present':
# get existing depot definition
p4_depot_spec = p4.fetch_depot(module.params['name'])
depots_dict = p4.run('depots')
# look through the list of depot specs returned and see if any match the current depot
# if a depot spec is found with the current depot name, let's look for any changes in attributes
if any(depot_dict['name'] == module.params['name']
for depot_dict in depots_dict):
# check to see if any fields have changed
p4_depot_changes = []
p4_depot_changes.append(p4_depot_spec["Description"].rstrip()
== module.params['description'])
p4_depot_changes.append(
p4_depot_spec["Type"] == module.params['type'])
p4_depot_changes.append(
p4_depot_spec["Map"] == module.params['map'])
if module.params['address'] is not None:
p4_depot_changes.append(
p4_depot_spec["Address"] == module.params['address'])
elif 'Address' in p4_depot_spec:
p4_depot_changes.append(False)
if module.params['specmap'] is not None:
p4_depot_changes.append(
p4_depot_spec["SpecMap"] == module.params['specmap'])
elif 'SpecMap' in p4_depot_spec:
p4_depot_changes.append(False)
if module.params['streamdepth'] is not None:
p4_depot_changes.append(p4_depot_spec["StreamDepth"] ==
module.params['streamdepth'])
elif 'StreamDepth' in p4_depot_spec:
p4_depot_changes.append(False)
if module.params['suffix'] is not None:
p4_depot_changes.append(
p4_depot_spec["Suffix"] == module.params['suffix'])
elif 'Suffix' in p4_depot_spec:
p4_depot_changes.append(False)
# check to see if changes are detected in any of the fields
if (all(p4_depot_changes)):
result['changed'] = False
# if changes are detected, update depot with new values
else:
if not module.check_mode:
p4_depot_spec["Description"] = module.params[
'description']
p4_depot_spec["Type"] = module.params['type']
p4_depot_spec["Map"] = module.params['map']
if module.params['address'] is not None:
p4_depot_spec["Address"] = module.params['address']
elif 'Address' in p4_depot_spec:
del p4_depot_spec["Address"]
if module.params['specmap'] is not None:
p4_depot_spec["SpecMap"] = module.params['specmap']
elif 'SpecMap' in p4_depot_spec:
del p4_depot_spec["SpecMap"]
if module.params['streamdepth'] is not None:
p4_depot_spec["StreamDepth"] = module.params[
'streamdepth']
elif 'StreamDepth' in p4_depot_spec:
del p4_depot_spec["StreamDepth"]
if module.params['suffix'] is not None:
p4_depot_spec["StreamDepth"] = module.params[
'suffix']
elif 'Suffix' in p4_depot_spec:
del p4_depot_spec["Suffix"]
p4.save_depot(p4_depot_spec)
result['changed'] = True
# create new depot with specified values
else:
if not module.check_mode:
p4_depot_spec["Description"] = module.params['description']
p4_depot_spec["Type"] = module.params['type']
p4_depot_spec["Map"] = module.params['map']
if module.params['address'] is not None:
p4_depot_spec["Address"] = module.params['address']
if module.params['specmap'] is not None:
p4_depot_spec["SpecMap"] = module.params['specmap']
if module.params['streamdepth'] is not None:
p4_depot_spec["StreamDepth"] = module.params[
'streamdepth']
if module.params['suffix'] is not None:
p4_depot_spec["Suffix"] = module.params['suffix']
p4.save_depot(p4_depot_spec)
result['changed'] = True
elif module.params['state'] == 'absent':
depots_dict = p4.run('depots')
# delete depot
if any(depot_dict['name'] == module.params['name']
for depot_dict in depots_dict):
if not module.check_mode:
p4.delete_depot('-f', module.params['name'])
result['changed'] = True
else:
result['changed'] = False
except Exception as e:
module.fail_json(msg="Error: {0}".format(e), **result)
helix_core_disconnect(module, p4)
module.exit_json(**result)
def run_module():
# define available arguments/parameters a user can pass to the module
module_args = dict(
state=dict(type='str',
default='present',
choices=['present', 'absent']),
name=dict(type='str'),
description=dict(type='str'),
owner=dict(type='str'),
stream=dict(type='str', required=True),
parent=dict(type='str', default='none'),
parentview=dict(type='str', default='inherit'),
type=dict(
type='str',
default='development',
choices=['mainline', 'development', 'release', 'virtual', 'task']),
options=dict(
type='str',
default='allsubmit unlocked toparent fromparent mergedown'),
paths=dict(type='list', default=['share ...'], elements='str'),
remapped=dict(type='list', elements='str'),
ignored=dict(type='list', elements='str'),
server=dict(type='str',
required=True,
aliases=['p4port'],
fallback=(env_fallback, ['P4PORT'])),
user=dict(type='str',
required=True,
aliases=['p4user'],
fallback=(env_fallback, ['P4USER'])),
password=dict(type='str',
required=True,
aliases=['p4passwd'],
fallback=(env_fallback, ['P4PASSWD']),
no_log=True),
charset=dict(type='str',
default='none',
aliases=['p4charset'],
fallback=(env_fallback, ['P4CHARSET'])),
serverid=dict(type='str', default='any'))
result = dict(changed=False, )
module = AnsibleModule(argument_spec=module_args, supports_check_mode=True)
# connect to helix
p4 = helix_core_connect(module, 'ansible')
try:
# get existing stream definition
p4_stream_spec = p4.fetch_stream(module.params['stream'])
# if description is not given, set a default
if module.params['description'] is None:
module.params['description'] = "Created by {0}.".format(
module.params['user'])
# if owner is not given, set a default
if module.params['owner'] is None:
module.params['owner'] = module.params['user']
if module.params['state'] == 'present':
# check to see if any fields have changed
if 'Access' in p4_stream_spec:
p4_stream_changes = []
p4_stream_changes.append(p4_stream_spec["Description"].rstrip(
) == module.params['description'])
p4_stream_changes.append(
p4_stream_spec["Owner"] == module.params['owner'])
p4_stream_changes.append(
p4_stream_spec["Parent"] == module.params['parent'])
p4_stream_changes.append(
p4_stream_spec["Type"] == module.params['type'])
p4_stream_changes.append(
p4_stream_spec["Options"] == module.params['options'])
p4_stream_changes.append(
p4_stream_spec["Paths"] == module.params['paths'])
if module.params['remapped'] is not None:
p4_stream_changes.append(p4_stream_spec["Remapped"] ==
module.params['remapped'])
elif 'Remapped' in p4_stream_spec:
p4_stream_changes.append(False)
if module.params['ignored'] is not None:
p4_stream_changes.append(
p4_stream_spec["Ignored"] == module.params['ignored'])
elif 'Ignored' in p4_stream_spec:
p4_stream_changes.append(False)
# check to see if changes are detected in any of the fields
if (all(p4_stream_changes)):
result['changed'] = False
# if changes are detected, update stream with new values
else:
if not module.check_mode:
p4_stream_spec["Description"] = module.params[
'description']
p4_stream_spec["Owner"] = module.params['owner']
p4_stream_spec["Parent"] = module.params['parent']
p4_stream_spec["Type"] = module.params['type']
p4_stream_spec["Options"] = module.params['options']
p4_stream_spec["Paths"] = module.params['paths']
if module.params['remapped'] is not None:
p4_stream_spec["Remapped"] == module.params[
'remapped']
elif 'Remapped' in p4_stream_spec:
del p4_stream_spec["Remapped"]
if module.params['ignored'] is not None:
p4_stream_spec["Ignored"] == module.params[
'ignored']
elif 'Ignored' in p4_stream_spec:
del p4_stream_spec["Ignored"]
p4.save_stream(p4_stream_spec)
result['changed'] = True
# create new stream with specified values
else:
if not module.check_mode:
p4_stream_spec["Description"] = module.params[
'description']
p4_stream_spec["Owner"] = module.params['owner']
p4_stream_spec["Parent"] = module.params['parent']
p4_stream_spec["Type"] = module.params['type']
p4_stream_spec["Options"] = module.params['options']
p4_stream_spec["Paths"] = module.params['paths']
if module.params['remapped'] is not None:
p4_stream_spec["Remapped"] == module.params['remapped']
if module.params['ignored'] is not None:
p4_stream_spec["Ignored"] == module.params['ignored']
p4.save_stream(p4_stream_spec)
result['changed'] = True
elif module.params['state'] == 'absent':
# delete stream
if 'Access' in p4_stream_spec:
if not module.check_mode:
p4.delete_stream('-f', module.params['stream'])
result['changed'] = True
else:
result['changed'] = False
except Exception as e:
module.fail_json(msg="Error: {0}".format(e), **result)
helix_core_disconnect(module, p4)
module.exit_json(**result)
def run_module():
# define available arguments/parameters a user can pass to the module
module_args = dict(state=dict(type='str',
default='present',
choices=['present', 'absent']),
name=dict(type='str', required=True),
authmethod=dict(type='str',
default='perforce',
choices=['perforce', 'ldap']),
email=dict(type='str'),
fullname=dict(type='str'),
server=dict(type='str',
required=True,
aliases=['p4port'],
fallback=(env_fallback, ['P4PORT'])),
user=dict(type='str',
required=True,
aliases=['p4user'],
fallback=(env_fallback, ['P4USER'])),
password=dict(type='str',
required=True,
aliases=['p4passwd'],
fallback=(env_fallback, ['P4PASSWD']),
no_log=True),
charset=dict(type='str',
default='none',
aliases=['p4charset'],
fallback=(env_fallback, ['P4CHARSET'])),
serverid=dict(type='str', default='any'))
result = dict(changed=False, )
module = AnsibleModule(argument_spec=module_args, supports_check_mode=True)
# connect to helix
p4 = helix_core_connect(module, 'ansible')
try:
# get existing user definition
p4_user_spec = p4.fetch_user(module.params['name'])
# if full name is not given, set a default
if module.params['fullname'] is None:
module.params['fullname'] = module.params['name']
# if email is not given, set a default
if module.params['email'] is None:
module.params['email'] = "{0}@{1}".format(module.params['name'],
gethostname())
if module.params['state'] == 'present':
if 'Access' in p4_user_spec:
# check to see if changes are detected in any of the fields
if (p4_user_spec["AuthMethod"] == module.params['authmethod']
and p4_user_spec["Email"] == module.params['email'] and
p4_user_spec["FullName"] == module.params['fullname']):
result['changed'] = False
# update user with new values
else:
if not module.check_mode:
p4_user_spec["AuthMethod"] = module.params[
'authmethod']
p4_user_spec["Email"] = module.params['email']
p4_user_spec["FullName"] = module.params['fullname']
p4.save_user(p4_user_spec, "-f")
result['changed'] = True
# create new user with specified values
else:
if not module.check_mode:
p4_user_spec["AuthMethod"] = module.params['authmethod']
p4_user_spec["Email"] = module.params['email']
p4_user_spec["FullName"] = module.params['fullname']
p4.save_user(p4_user_spec, "-f")
result['changed'] = True
elif module.params['state'] == 'absent':
# delete user
if 'Access' in p4_user_spec:
if not module.check_mode:
p4.delete_user('-f', module.params['name'])
result['changed'] = True
else:
result['changed'] = False
except Exception as e:
module.fail_json(msg="Error: {0}".format(e), **result)
helix_core_disconnect(module, p4)
module.exit_json(**result)