def main():
module = AnsibleModule(
argument_spec=dict(host=dict(required=True),
port=dict(required=True),
path_name=dict(required=True),
path_primary_type=dict(required=True),
path_mixin_types_csv=dict(required=True)))
host = module.params['host']
port = module.params['port']
path_name = module.params['path_name']
path_primary_type = module.params['path_primary_type']
path_mixin_types_csv = module.params['path_mixin_types_csv']
aem_username = os.getenv('crx_username')
aem_password = os.getenv('crx_password')
aem = pyaem.PyAem(aem_username, aem_password, host, port)
params = {
'jcr:primaryType': path_primary_type,
'jcr:mixinTypes': path_mixin_types_csv.split(',')
}
result = aem.create_path(path_name, **params)
if result.is_failure():
print json.dumps({'failed': True, 'msg': result.message})
else:
print json.dumps({'msg': result.message})
def main():
module = AnsibleModule(
argument_spec=dict(
host=dict(required=True),
port=dict(required=True),
agent_name=dict(required=True),
run_mode=dict(required=True)
)
)
host = module.params['host']
port = module.params['port']
agent_name = module.params['agent_name']
run_mode = module.params['run_mode']
aem_username = os.getenv('crx_username')
aem_password = os.getenv('crx_password')
aem = pyaem.PyAem(aem_username, aem_password, host, port)
result = aem.delete_agent(agent_name, run_mode)
if result.is_failure():
print json.dumps({'failed': True, 'msg': result.message})
else:
print json.dumps({'msg': result.message})
def main():
module = AnsibleModule(argument_spec=dict(host=dict(required=True),
port=dict(required=True),
user_path=dict(required=True),
user_name=dict(required=True),
old_password=dict(required=True),
new_password=dict(
required=True)))
host = module.params['host']
port = module.params['port']
user_name = module.params['user_name']
user_path = module.params['user_path']
old_password = module.params['old_password']
new_password = module.params['new_password']
aem_username = os.getenv('crx_username')
aem_password = os.getenv('crx_password')
aem = pyaem.PyAem(aem_username, aem_password, host, port)
result = aem.change_password(user_path, user_name, old_password,
new_password)
if result.is_failure():
print(json.dumps({'failed': True, 'msg': result.message}))
else:
print(json.dumps({'msg': result.message}))
def main():
module = AnsibleModule(
argument_spec=dict(host=dict(required=True),
port=dict(required=True),
group_path=dict(required=True),
group_name=dict(required=True),
group_desc=dict(required=True),
group_parent=dict(required=True, type='str')))
host = module.params['host']
port = module.params['port']
group_path = module.params['group_path']
group_name = module.params['group_name']
group_desc = module.params['group_desc']
group_parent = module.params['group_parent']
aem_username = os.getenv('crx_username')
aem_password = os.getenv('crx_password')
aem = pyaem.PyAem(aem_username, aem_password, host, port)
params = {'profile/givenName': group_desc}
if group_parent != '':
params['membership'] = group_parent
result = aem.create_group(group_path, group_name, **params)
if result.is_failure():
print json.dumps({'failed': True, 'msg': result.message})
else:
print json.dumps({'msg': result.message})
def main():
module = AnsibleModule(
argument_spec=dict(
host=dict(required=True),
port=dict(required=True),
user_or_group_name=dict(required=True),
path=dict(required=True),
permissions=dict(required=True)
)
)
host = module.params['host']
port = module.params['port']
user_or_group_name = module.params['user_or_group_name']
path = module.params['path']
permissions = module.params['permissions']
aem_username = os.getenv('crx_username')
aem_password = os.getenv('crx_password')
aem = pyaem.PyAem(aem_username, aem_password, host, port)
result = aem.set_permission(user_or_group_name, path, permissions)
if result.is_failure():
print json.dumps({'failed': True, 'msg': result.message})
else:
print json.dumps({'msg': result.message})
def main():
module = AnsibleModule(argument_spec=dict(host=dict(required=True),
port=dict(required=True),
user_path=dict(required=True),
user_name=dict(required=True),
password=dict(required=True),
group_name=dict(required=False)))
host = module.params['host']
port = module.params['port']
user_path = module.params['user_path']
user_name = module.params['user_name']
password = module.params['password']
group_name = module.params['group_name']
aem_username = os.getenv('crx_username')
aem_password = os.getenv('crx_password')
aem = pyaem.PyAem(aem_username, aem_password, host, port)
if group_name != None:
result = aem.create_user(user_path,
user_name,
password,
membership=group_name)
else:
result = aem.create_user(user_path, user_name, password)
if result.is_failure():
print json.dumps({'failed': True, 'msg': result.message})
else:
print json.dumps({'msg': result.message})
def main():
module = AnsibleModule(argument_spec=dict(host=dict(required=True),
port=dict(required=True),
group_name=dict(required=True),
package_name=dict(required=True),
package_version=dict(
required=True)))
host = module.params['host']
port = module.params['port']
group_name = module.params['group_name']
package_name = module.params['package_name']
package_version = module.params['package_version']
aem_username = os.getenv('crx_username')
aem_password = os.getenv('crx_password')
aem = pyaem.PyAem(aem_username, aem_password, host, port)
result = aem.replicate_package_sync(group_name, package_name,
package_version)
if result.is_failure():
print(json.dumps({'failed': True, 'msg': result.message}))
else:
print(json.dumps({'msg': result.message}))
def test_init_ssl_debug(self):
aem = pyaem.PyAem('someusername', 'somepassword', 'localhost', 4502, use_ssl=True, debug=True)
self.assertTrue(hasattr(aem, 'content_repo'))
self.assertTrue(hasattr(aem, 'package_manager'))
self.assertTrue(hasattr(aem, 'package_manager_service_html'))
self.assertTrue(hasattr(aem, 'package_manager_service_json'))
self.assertTrue(hasattr(aem, 'package_manager_service_jsp'))
self.assertTrue(hasattr(aem, 'web_console'))
def main ():
module = AnsibleModule(
argument_spec = dict(
host = dict(required=True),
port = dict(required=True),
aem_username = dict(required=True),
aem_password = dict(required=True),
stack = dict(required=True),
agent_id = dict(required=True),
agent_name = dict(required=True),
agent_type = dict(required=True),
agent_loglevel = dict(required=True),
agent_retrydelay = dict(required=True),
dest_group = dict(required=True),
dest_username = dict(required=True),
dest_password = dict(required=True),
dest_url = dict(required=True),
run_mode = dict(required=True)
)
)
host = module.params['host']
port = module.params['port']
stack = module.params['stack']
agent_id = module.params['agent_id']
agent_name = module.params['agent_name']
agent_type = module.params['agent_type']
agent_loglevel = module.params['agent_loglevel']
agent_retrydelay = module.params['agent_retrydelay']
dest_username = module.params['dest_username']
dest_password = module.params['dest_password']
dest_group = module.params['dest_group']
dest_url = module.params['dest_url']
run_mode = module.params['run_mode']
agent_title = '{0} agent to {1} {2}'.format(agent_type, dest_group, agent_id)
aem_username = module.params['aem_username']
aem_password = module.params['aem_password']
aem = pyaem.PyAem(aem_username, aem_password, host, port)
params = {
'jcr:content/jcr:title': agent_title,
'jcr:content/jcr:description': agent_title,
'jcr:content/logLevel': agent_loglevel,
'jcr:content/retryDelay': agent_retrydelay
}
result = aem.create_agent(agent_name, agent_type, dest_username, dest_password, dest_url, run_mode, **params)
if result.is_failure():
print(json.dumps({ 'failed': True, 'msg': result.message }))
else:
print(json.dumps({ 'msg': result.message }))
def main():
module = AnsibleModule(argument_spec=dict(host=dict(required=True),
port=dict(required=True),
username=dict(required=True),
password=dict(required=True)))
host = module.params['host']
port = module.params['port']
username = module.params['username']
password = module.params['password']
aem = pyaem.PyAem(username, password, host, port)
result = aem.is_valid_login()
if result.is_failure():
print json.dumps({'failed': True, 'msg': result.message})
else:
print json.dumps({'msg': result.message})
def main():
module = AnsibleModule(argument_spec=dict(host=dict(required=True),
port=dict(required=True),
bundle_name=dict(required=True)))
host = module.params['host']
port = module.params['port']
bundle_name = module.params['bundle_name']
aem_username = os.getenv('crx_username')
aem_password = os.getenv('crx_password')
aem = pyaem.PyAem(aem_username, aem_password, host, port)
result = aem.stop_bundle(bundle_name)
if result.is_failure():
print(json.dumps({'failed': True, 'msg': result.message}))
else:
print(json.dumps({'msg': result.message}))
def main():
module = AnsibleModule(argument_spec=dict(host=dict(required=True),
port=dict(required=True),
path=dict(required=True)))
host = module.params['host']
port = module.params['port']
path = module.params['path']
aem_username = os.getenv('crx_username')
aem_password = os.getenv('crx_password')
aem = pyaem.PyAem(aem_username, aem_password, host, port)
result = aem.activate_path(path,
ignoredeactivated='true',
onlymodified='false')
if result.is_failure():
print json.dumps({'failed': True, 'msg': result.message})
else:
print json.dumps({'msg': result.message})
def main():
module = AnsibleModule(argument_spec=dict(host=dict(required=True),
port=dict(required=True),
path_name=dict(required=True),
path_base=dict(required=True),
path_type=dict(required=True)))
host = module.params['host']
port = module.params['port']
path_name = module.params['path_name']
path_base = module.params['path_base']
path_type = module.params['path_type']
aem_username = os.getenv('crx_username')
aem_password = os.getenv('crx_password')
aem = pyaem.PyAem(aem_username, aem_password, host, port)
params = {
':nameHint': path_name,
'jcr:primaryType': path_type,
'jcr:mixinTypes': 'rep:AccessControllable'
}
try:
if not path_base.endswith("/*"):
path_base = '{0}/*'.format(path_base)
result = aem.create_path(path_base, **params)
if result.is_failure():
print(json.dumps({'failed': True, 'msg': result.message}))
else:
print(json.dumps({'msg': result.message}))
except pyaem.PyAemException as e:
print(
json.dumps({
'msg':
'Allow error due to inability to differentiate existing path from real error when response code is 500'
+ e.response['body']
}))
def main():
module = AnsibleModule(
argument_spec=dict(host=dict(required=True),
port=dict(required=True),
group_name=dict(required=True),
package_name=dict(required=True),
package_version=dict(required=False),
file_path=dict(required=True),
aem_username=dict(required=True),
aem_password=dict(required=True),
force=dict(required=False,
type='str',
choices=['true', 'false'],
default='false')))
host = module.params['host']
port = module.params['port']
group_name = module.params['group_name']
package_name = module.params['package_name']
package_version = module.params['package_version']
file_path = module.params['file_path']
aem_username = module.params['aem_username']
aem_password = module.params['aem_password']
force_upload = module.params['force']
aem = pyaem.PyAem(aem_username, aem_password, host, port)
result = aem.upload_package_sync(group_name,
package_name,
package_version,
file_path,
force=force_upload)
if result.is_failure():
print json.dumps({'failed': True, 'msg': result.message})
else:
print json.dumps({'msg': result.message})
def setUp(self):
self.aem = pyaem.PyAem('someusername', 'somepassword', 'localhost',
4502)
def main():
module = AnsibleModule(
argument_spec=dict(
host=dict(required=False, type='str', default='localhost'),
port=dict(required=False, type='int', default=4502),
group_name=dict(required=True),
package_name=dict(required=True),
package_version=dict(required=True),
aem_username=dict(required=True),
aem_password=dict(required=True),
interval=dict(required=False, type='int', default=10),
requires_restart=dict(required=False, type='bool', default=False)
)
)
host = module.params['host']
port = module.params['port']
group_name = module.params['group_name']
package_name = module.params['package_name']
package_version = module.params['package_version']
aem_username = module.params['aem_username']
aem_password = module.params['aem_password']
aem = pyaem.PyAem(aem_username, aem_password, host, port)
result = aem.install_package_sync(group_name, package_name, package_version)
requires_restart = module.params['requires_restart']
interval = module.params['interval']
if requires_restart and not result.is_failure():
attempts = 0
max_attempts = 10
while attempts < max_attempts:
attempts += 1
# All AEM Ansible modules are currently using http://
try:
request = urllib2.Request("http://"+host+":"+str(port)+"/system/console/bundles.json")
encodedBasicAuth = base64.b64encode('%s:%s' % (aem_username, aem_password))
request.add_header("Authorization", "Basic %s" % encodedBasicAuth)
response = urllib2.urlopen(request)
if response.code == 401:
print(json.dumps({'failed': True, 'msg': response.message}))
return
elif response.code == 200:
bundles = json.load(response)
bundle_status = bundles['s']
existing = bundle_status[0]
active = bundle_status[1]
fragment = bundle_status[2]
if existing == active + fragment:
print(json.dumps({'msg': 'Package installed and all bundles active. '}))
return
except (urllib2.URLError, urllib2.HTTPError):
pass
time.sleep(interval)
if result.is_failure():
print(json.dumps({'failed': True, 'msg': result.message}))
else:
print(json.dumps({'msg': result.message}))
__author__ = 'maxbarrass'
import os
import time
import json
import sys
import argparse
import pyaem
aem = pyaem.PyAem('admin', 'admin', 'localhost', 4502)
try:
path_name = "test"
path_base = "/content/pytest/*"
path_type = "nt:OrderedFolder"
params = {
':nameHint': path_name,
'jcr:primaryType': path_type,
'jcr:mixinTypes': 'rep:AccessControllable'
}
try:
result = aem.create_path(path_base, **params)
if result.is_failure():
print(json.dumps({'failed': True, 'msg': result.message}))
else:
print(json.dumps({'msg': result.message}))
def main():
module = AnsibleModule(
argument_spec=dict(host=dict(required=True),
port=dict(required=True),
stack=dict(required=True),
agent_id=dict(required=True),
agent_name=dict(required=True),
agent_type=dict(required=True),
dest_group=dict(required=True),
dest_username=dict(required=True),
dest_password=dict(required=True),
run_mode=dict(required=True)))
host = module.params['host']
port = module.params['port']
stack = module.params['stack']
agent_id = module.params['agent_id']
agent_name = module.params['agent_name']
agent_type = module.params['agent_type']
dest_username = module.params['dest_username']
dest_password = module.params['dest_password']
dest_group = module.params['dest_group']
run_mode = module.params['run_mode']
# determine ports based on group
if dest_group == 'author':
dest_port = 4502
elif dest_group == 'publisher':
dest_port = 4503
else:
dest_port = 8080
agent_title = '{0} agent to {1} {2}'.format(agent_type, dest_group,
agent_id)
if stack == 'local':
dest_url = 'http://localhost:{0}'.format(dest_port)
elif stack == 'docker':
if dest_port == 4502:
dest_url = 'http://192.168.78.1:{0}'.format(dest_port)
elif dest_port == 4503:
dest_url = 'http://192.168.78.2:{0}'.format(dest_port)
elif dest_port == 8080:
dest_url = 'http://192.168.78.3:{0}'.format(dest_port)
else:
dest_domain = re.search(r'.aws-sensis.com.au', host).group()
dest_url = 'http://sitesmart-{0}-{1}-{2}.in.{3}:{4}'.format(
stack, dest_group, agent_id, dest_domain, dest_port)
aem_username = os.getenv('crx_username')
aem_password = os.getenv('crx_password')
aem = pyaem.PyAem(aem_username, aem_password, host, port)
params = {
'jcr:content/jcr:title': agent_title,
'jcr:content/jcr:description': agent_title,
'jcr:content/logLevel': 'info',
'jcr:content/retryDelay': '60000'
}
result = aem.create_agent(agent_name, agent_type, dest_username,
dest_password, dest_url, run_mode, **params)
if result.is_failure():
print json.dumps({'failed': True, 'msg': result.message})
else:
print json.dumps({'msg': result.message})
