def tag_asset(self, assetpath, tags):
"""
Function is lowlevel and does not look up values from titles.
assetpath: e.g. /my_robots/bernard.jpg
tags: e.g. {name: ['bernard.jpg'], type: ['host']}
"""
if assetpath.startswith("/content/dam"):
assetpath = remove_prefix("/content/dam", assetpath)
log("Fetching status for {}".format(assetpath))
status, data = self.api.get(assetpath)
if status != OK:
error("Failed to get status for {}: {}".format(assetpath, data))
return SERVER_ERROR, None
props = data['properties']
existing_tags = flatten_properties(props)
tags = merge_tags(existing_tags, tags)
if existing_tags == tags:
log("Skipping {}, no updates to make".format(assetpath))
return OK
log("Tagging {}".format(assetpath))
status, data = self.api.setprops(assetpath, tags)
sys.stdout.write("{}\n".format(assetpath))
if status != OK:
error("Failed to update metadata of {}".format(assetpath))
return status, None
return OK, data
def list_pending_jobs(server):
url = server.url(QUERYBUILDER_PATH)
resp = requests.get(url, auth=server.auth, params=pending_params)
if resp.status_code != 200:
error("Failed to list pending jobs from {}".format(url))
else:
sys.stdout.write("{}\n".format(resp.content))
def _list_assets(self, path):
""" List assets under path
:return (<status>, <list>)
<status>: <OK|USER_ERROR|SERVER_ERROR>
<list> [{name: <name>, title: <title>}...]
"""
log("Fetching asset list for {}".format(path))
req_path = "{root}{path}.json".format(root=API_ROOT, path=path)
url = self.server.url(req_path)
status, data = self._fetch_json(url)
if status != OK:
return SERVER_ERROR, None
_add_path(data, path)
next_url = _get_next_url(data)
while next_url is not None:
status, next_data = self._fetch_json(next_url)
if status != OK:
error("Failed to fetch next listing {}".format(next_url))
next_url = None
else:
_add_path(next_data, path)
data['entities'].extend(next_data['entities'])
next_url = _get_next_url(next_data)
return OK, data
def _post_file(server, filepath, dst_path, dry_run):
""" POST single file to DAM
curl -v -u admin:admin -X POST -i -F "file=@\"$FILENAME\"" $HOST$dampath.createasset.html &> $tempfile
"""
assert os.path.isfile(filepath)
if dry_run:
return OK
filename = os.path.basename(filepath)
f = open(filepath, 'rb')
mime, enc = mimetypes.guess_type(filepath)
log("Uploading {} as {}, {}".format(f, mime, enc))
form_data = dict(
file=(filename, f, mime, dict()),
fileName=filename
)
url = server.url("{path}.createasset.html".format(path=dst_path, filename=os.path.basename(filepath)))
log("POSTing to {}".format(url))
resp = requests.post(url, auth=server.auth, files=form_data)
if not _ok(resp.status_code):
error("Failed to upload file {}\n{}".format(filepath, resp.content))
return SERVER_ERROR
return OK
def promote_package(server, target_server, options, package_name):
""" Download package from server, upload to target_server and install. """
if not package_name:
error("Missing package name argument")
return USER_ERROR
_, tmp_filepath = tempfile.mkstemp(".zip")
log("Download package from source server {} to {}".format(
server, tmp_filepath))
status = download_package(server,
options,
package_name,
filename=tmp_filepath)
if status != OK:
return status
log("Upload downloaded package file to target server {}".format(
target_server))
status = upload_package(target_server, options, tmp_filepath)
os.remove(tmp_filepath)
if status != OK:
return status
log("Install uploaded package on target server")
install_package(target_server, options, package_name)
return status
def execute(self, server, argv):
options, args = parser.parse_args(argv)
action = get_action(args, default='list')
actionarg = get_argument(args)
if action == 'list' or action == 'ls':
return list_packages(server, options)
elif actionarg is None:
parser.print_help()
return USER_ERROR
elif action == 'build':
return build_package(server, options, actionarg)
elif action == 'install':
return install_package(server, options, actionarg)
elif action == 'uninstall':
return uninstall_package(server, options, actionarg)
elif action == 'download':
return download_package(server, options, actionarg)
elif action == 'upload':
return upload_package(server, options, actionarg)
elif action == 'promote':
target_server_name = options.target_server
if target_server_name is None:
error("Missing target server, use -t flag.")
return USER_ERROR
target_server = self.config.get_server(target_server_name)
return promote_package(server, target_server, options, actionarg)
else:
sys.stderr.write(
'error: Unknown package action {a}\n'.format(a=action))
return USER_ERROR
def upload_package(server, options, filename):
""" curl -u admin:admin -F file=@"name of zip file" -F name="name of package"
-F strict=true -F install=false http://localhost:4505/crx/packmgr/service.jsp """
form_data = dict(file=(filename, open(filename,
'rb'), 'application/zip', dict()),
name=filename.rstrip('.zip'),
strict="true",
install=json_bool(options.install))
log(form_data)
url = server.url(SERVICE_PATH)
log("POSTing to {}".format(url))
resp = requests.post(url, auth=server.auth, files=form_data)
log("Got status %s" % str(resp.content))
if resp.status_code != 200:
error('Failed to upload paackage: {}: {}'.format(
resp.status_code, resp.content))
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
return SERVER_ERROR
else:
try:
tree = ElementTree.fromstring(resp.content)
pkg_elem = tree.find('response').find('data').find('package')
pkg = parse_package(pkg_elem)
sys.stdout.write("{}\n".format(format_package(pkg)))
except Exception as e:
sys.stderr.write('error: Failed to parse response: {}\n'.format(e))
return SERVER_ERROR
return OK
def execute(server, argv):
options, args = parser.parse_args(argv)
action = get_command(args, default='list')
argument = get_argument(args, i=2)
argument2 = get_argument(args, i=3, default=argument)
if action == 'list' or action == 'ls':
return list_rcp_tasks(server, options)
if action == 'create':
src_path = argument
dst_path = argument2
return create_new_task(server, src_path, dst_path, options)
elif action == 'start':
return start_task(server, argument, options)
elif action == 'stop':
return stop_task(server, argument, options)
elif action == 'remove' or action == 'rm':
return remove_task(server, argument)
elif action == 'clear':
return clear_tasks(server)
elif action == 'fetch':
return fetch_tree_synchronous(server, options, argument)
else:
error("Unknown rcp action {a}".format(a=action))
return USER_ERROR
def _create_task(server, task_id, src_path, dst_path, options):
""" Create a new task, does not start it """
log("Creating task {}".format(task_id))
payload = {
"cmd":
"create",
"id":
task_id,
"src":
"http://{credentials}@{source_host}/crx/-/jcr:root{content_path}".
format(credentials=options.source_credentials,
source_host=options.source_host,
content_path=src_path),
"dst":
dst_path,
"batchsize":
int(options.batch_size),
"update":
options.overwrite_existing,
"onlyNewer":
options.respect_modified_date,
"throttle":
int(options.throttle),
"recursive":
True,
}
url = server.url("/system/jackrabbit/filevault/rcp")
resp = requests.post(url, auth=server.auth, json=payload)
if resp.status_code != 201:
error("Failed to create task, request returned {} and {}".format(
resp.status_code, resp.content))
return SERVER_ERROR, None
return OK, resp.json()
def execute(_, argv):
(options, args) = parser.parse_args(argv)
arg = get_command(args, '_tools')
if arg == '_tools':
print_tools(sys.stdout, options.compact)
elif arg == '_servers':
print_servers(sys.stdout)
else:
_tool = tool_repo.get_tool(arg)
_module = tool_repo.get_module(arg)
if _tool is None:
error("No tool named {} found".format(arg))
print_tools(sys.stderr, options.compact)
return USER_ERROR
if options.compact:
for cmd in _tool.commands:
sys.stdout.write("{}\n".format(cmd))
else:
if hasattr(_module, 'parser'):
_module.parser.print_help()
else:
sys.stdout.write("Available commands:\n")
for cmd in _tool.commands:
sys.stdout.write("\t{}\n".format(cmd))
return OK
def find(self, path):
if path.startswith("/content/dam"):
path = remove_prefix("/content/dam", path)
status, root = self._list_assets(path)
if status != OK:
error("Failed to find in {}".format(path))
return SERVER_ERROR, None
assets = _filter_assets(root['entities'])
folder_queue = _filter_folders(root['entities'])
while len(folder_queue) > 0:
entity = folder_queue.pop()
path = join(entity['properties']['path'], entity['properties']['name'])
status, data = self._list_assets(path)
if status != OK:
error("Failed to list contents of {}".format(path))
else:
for entity in data.get('entities', list()):
if _is_folder(entity):
folder_queue.insert(0, entity)
elif _is_asset(entity):
assets.append(entity)
return OK, assets
def execute(self, server, argv):
options, args = parser.parse_args(argv)
if len(argv) < 2:
parser.print_help()
return USER_ERROR
filename = args[1]
f = open(filename, 'r')
status, data = backend.execute(server, f.read(), [], raw_output=options.raw)
if status != OK:
error("Failed to run script {filename}: {content}".format(
filename=filename,
content=data))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(json.dumps(data, indent=4)))
else:
# The stacktrace prop changed name with newer versions.
if backend.STACKTRACE_FIELD in data:
sys.stderr.write(data[backend.STACKTRACE_FIELD])
return SERVER_ERROR
elif backend.OUTPUT_FIELD in data:
sys.stdout.write("{}".format(data[backend.OUTPUT_FIELD].encode('utf-8')))
else:
return INTERNAL_ERROR
return OK
def parse_tag(tag_expr):
""" Expects key=val """
parts = re.split("(?<!\\\\)=", tag_expr)
if len(parts) != 2:
error("Failed to parse tag parameter string")
return USER_ERROR, None, None
return OK, decode(parts[0]), decode(parts[1])
def execute(_, argv):
(options, args) = parser.parse_args(argv)
arg = get_command(args, '_tools')
if arg == '_tools':
print_tools(sys.stdout, options.compact)
elif arg == '_servers':
print_servers(sys.stdout)
else:
_tool = get_tool(arg)
_module = get_module(arg)
if _tool is None:
error("No tool named {} found".format(arg))
print_tools(sys.stderr, options.compact)
return USER_ERROR
if options.compact:
for cmd in _tool.commands:
sys.stdout.write("{}\n".format(cmd))
else:
if hasattr(_module, 'parser'):
_module.parser.print_help()
else:
sys.stdout.write("Available commands:\n")
for cmd in _tool.commands:
sys.stdout.write("\t{}\n".format(cmd))
return OK
def execute(server, argv):
options, args = parser.parse_args(argv)
action = get_action(args)
actionarg = get_argument(args)
api = WorkflowsApi(server)
if action == 'models' or action == 'md':
return list_workflow_models(server, options)
elif action == 'instances' or action == 'in':
return list_workflow_instances(api, 'COMPLETED')
elif action == 'start':
model = actionarg
if len(args) >= 4:
path = get_argument(args, i=3)
status, output = api.start_workflow(model, path)
sys.stdout.write("{}\n".format(output))
return status
else:
ret = OK
for path in sys.stdin:
status, output = api.start_workflow(model, path.strip())
if status == OK:
sys.stdout.write("{}\n".format(output))
ret = ret | status
return ret
else:
error('Unknown workflows action {a}\n'.format(a=action))
return USER_ERROR
def execute(self, server, argv):
options, args = parser.parse_args(argv)
if len(argv) < 2:
parser.print_help()
return USER_ERROR
filename = args[1]
f = open(filename, 'r')
status, data = backend.execute(server,
f.read(), [],
raw_output=options.raw)
if status != OK:
error("Failed to run script {filename}: {content}".format(
filename=filename, content=data))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(json.dumps(data, indent=4)))
else:
# The stacktrace prop changed name with newer versions.
if backend.STACKTRACE_FIELD in data:
sys.stderr.write(data[backend.STACKTRACE_FIELD])
return SERVER_ERROR
elif backend.OUTPUT_FIELD in data:
sys.stdout.write("{}".format(
data[backend.OUTPUT_FIELD].encode('utf-8')))
else:
return INTERNAL_ERROR
return OK
def start_workflow(self, model, path):
""" curl -u admin:admin
-d "model=/etc/workflow/models/request_for_activation/jcr:content/model&
payload=/content/geometrixx/en/company&
payloadType=JCR_PATH&
workflowTitle=myWorkflowTitle" http://localhost:4502/etc/workflow/instances
"""
task_id = create_task_id(model)
form_data = dict(
model='/etc/workflow/models/{}/jcr:content/model'.format(model),
payload=path,
payloadType='JCR_PATH',
workflowTitle=task_id,
startComment='')
url = self.server.url(INSTANCES_PATH)
resp = requests.post(url, auth=self.server.auth, data=form_data)
if resp.status_code != 201:
error("Unexpected error code {code}: {content}".format(
code=resp.status_code, content=resp.content))
return SERVER_ERROR
output = resp.content if self.raw else task_id
return OK, output
def list_workflow_instances(api, mode):
status, data = api.get_instances(mode)
if status != OK:
error(data)
else:
for instance in data:
sys.stdout.write("{}\n".format(instance['uri']))
return status
def set_master_password():
if not acmd.util.crypto.is_supported():
error(
"Crypto functions are not supported on this system. Install pycrypto or pycryptodome"
)
return USER_ERROR
acmd.util.crypto.set_master_password()
return OK
def get_server(self, server_name):
if server_name not in self.servers:
error("Server {} not defined in {}; servers={}".format(
server_name, get_rcfilename(), self.servers.keys()))
sys.exit(acmd.USER_ERROR)
# server_name = DEFAULT_SERVER_SETTING
return self.servers.get(server_name)
def garbage_collect(server, options):
url = server.url(GC_PATH)
resp = requests.post(url, auth=server.auth)
if resp.status_code != 200:
error("Failed to trigger Tar Optimization because: {}".format(resp.content))
return -1
else:
if options.raw:
sys.stdout.write("{}".format(resp.content))
def garbage_collect(server, options):
url = server.url(GC_PATH)
resp = requests.post(url, auth=server.auth)
if resp.status_code != 200:
error("Failed to trigger Tar Optimization because: {}".format(
resp.content))
return -1
else:
if options.raw:
sys.stdout.write("{}".format(resp.content))
def execute(self, server, argv):
options, args = parser.parse_args(argv)
action = get_command(args)
actionarg = get_argument(args)
if action == 'import':
return self.import_path(server, options, actionarg)
else:
error("Unknown action {}".format(action))
return USER_ERROR
def get_bundle_list(server):
url = server.url('/system/console/bundles.json')
log("GETting service {}".format(url))
response = requests.get(url, auth=server.auth)
if response.status_code != 200:
error("Failed to list bundles: {}".format(response.status_code))
return []
bundles = response.json()['data']
return bundles
def delete_package(server, options, package_name):
url = get_package_url(package_name, server, options)
form_data = dict(cmd='delete')
log("Deleting package with POST to {}".format(url))
resp = requests.post(url, auth=server.auth, data=form_data)
if resp.status_code != 200:
error("Failed to delete package: {}".format(resp.content))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
return OK
def _get_task_list(server):
url = server.url("/system/jackrabbit/filevault/rcp")
log("GETting service {}".format(url))
resp = requests.get(url, auth=server.auth)
if resp.status_code != 200:
error("Failed to list rcp tasks, request returned {}".format(
resp.status_code))
return SERVER_ERROR, None
return OK, resp.json()
def stop_bundle(server, bundlename, options):
""" curl -u admin:admin http://localhost:4505/system/console/bundles/org.apache.sling.scripting.jsp
-F action=stop."""
form_data = {'action': 'stop'}
url = server.url('/system/console/bundles/{bundle}'.format(bundle=bundlename))
log("POSTing to service {}".format(url))
resp = requests.post(url, auth=(server.username, server.password), data=form_data)
if resp.status_code != 200:
error("Failed to stop bundle {bundle}: {status}".format(bundle=bundlename, status=resp.status_code))
return -1
elif options.raw:
sys.stdout.write("{}\n".format(resp.content))
def delete_package(server, options, package_name):
url = get_package_url(package_name, server, options)
form_data = dict(cmd='delete')
log("Deleting package with POST to {}".format(url))
resp = requests.post(url, auth=server.auth, data=form_data)
if resp.status_code != 200:
error("Failed to delete package: {}".format(resp.content))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
return OK
def execute(self, server, argv):
self.api = AssetsApi(server)
options, args = parser.parse_args(argv)
action = get_action(args)
actionarg = get_argument(args)
if action == 'import':
funnel = AssetsImportFunnel(server, dry_run=options.dry_run, destination_root=options.destination_root)
return funnel.import_path(actionarg)
elif action == 'touch':
api = WorkflowsApi(server)
if len(args) >= 3:
self.touch_asset(api, actionarg, options.model)
else:
for line in sys.stdin:
self.touch_asset(api, line.strip(), options.model)
return OK
elif action == 'list' or action == 'ls':
status, data = self.api._list_assets(actionarg)
if status != OK:
return status
for item in data['entities']:
sys.stdout.write("{}\n".format(item['properties']['name']))
return OK
elif action == 'find':
status, data = self.api.find(actionarg)
if status != OK:
return status
for item in data:
props = item['properties']
path = acmd.jcr.path.join(props['path'], props['name'])
sys.stdout.write("{}\n".format(path))
return OK
elif action == 'tag':
tag_str = get_argument(args)
status, tags = parse_tags(tag_str)
if status != OK:
return status
if len(args) <= 3:
log("Reading files from input")
for path in sys.stdin:
path = path.strip()
self.tag_asset(path, tags)
else:
path = get_argument(args, i=3)
self.tag_asset(path, tags)
return OK
else:
error("Unknown action {}".format(action))
return USER_ERROR
def build_package(server, options, package_name):
""" curl -u admin:admin -X POST
http://localhost:4505:/crx/packmgr/service/.json/etc/packages/name_of_package.zip?cmd=build """
url = get_package_url(package_name, server, options)
form_data = dict(cmd='build')
resp = requests.post(url, auth=server.auth, data=form_data)
if resp.status_code != 200:
error("Failed to rebuild package: {}".format(resp.content))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
return OK
def build_package(server, options, package_name):
""" curl -u admin:admin -X POST
http://localhost:4505:/crx/packmgr/service/.json/etc/packages/name_of_package.zip?cmd=build """
url = get_package_url(package_name, server, options)
form_data = dict(cmd="build")
resp = requests.post(url, auth=server.auth, data=form_data)
if resp.status_code != 200:
error("Failed to rebuild package: {}".format(resp.content))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
return OK
def get_instances(self, mode):
if mode not in INSTANCE_MODES:
return USER_ERROR, "Unknown instance mode {}".format(mode)
path = "/etc/workflow/instances.{mode}.json".format(mode=mode)
url = self.server.url(path)
resp = requests.get(url, auth=self.server.auth)
if resp.status_code != 200:
error("Unexpected error code {code}: {content}".format(
code=resp.status_code, content=resp.content))
return SERVER_ERROR, []
return OK, json.loads(resp.content)
def create_new_task(server, src_path, dst_path, options):
if options.source_host is None:
error("Missing argument source host (-s)")
return USER_ERROR
if not options.batch_size.isdigit():
error("Batch size '{}' needs to be a number. (Default is 2048)".format(
options.batch_size))
return USER_ERROR
if not options.throttle.isdigit():
error("Throttling '{}' needs to be a number. (Default is 1)".format(
options.throttle))
return USER_ERROR
task_id = create_task_id('rcp')
status, data = _create_task(server, task_id, src_path, dst_path, options)
if status != OK:
error("Failed to fetch {} from {}".format(src_path,
options.source_host))
return status
if options.raw:
sys.stdout.write("{}\n".format(json.dumps(data)))
else:
sys.stdout.write("{}\n".format(data['id']))
return OK
def list_workflows(server, options):
url = server.url(MODELS_PATH)
resp = requests.get(url, auth=server.auth)
if resp.status_code != 200:
error("Unexpected error code {code}: {content}".format(
code=resp.status_code, content=resp.content))
return SERVER_ERROR
data = resp.json()
if options.raw:
sys.stdout.write(json.dumps(data, indent=4))
else:
for model_item in data:
model_name = _get_name(model_item['uri'])
sys.stdout.write("{}\n".format(model_name))
return OK
def _create_dir(server, path, dry_run):
""" Create file in the DAM
e.g. curl -s -u admin:admin -X POST -F "jcr:primaryType=sling:OrderedFolder" $HOST$dampath > /dev/null
"""
if dry_run:
return OK
form_data = {'jcr:primaryType': 'sling:OrderedFolder'}
url = server.url(path)
log("POSTing to {}".format(url))
resp = requests.post(url, auth=server.auth, data=form_data)
if not _ok(resp.status_code):
error("Failed to create directory {}\n{}".format(url, resp.content))
return SERVER_ERROR
return OK
def list_workflow_models(server, options):
url = server.url(MODELS_PATH)
resp = requests.get(url, auth=server.auth)
if resp.status_code != 200:
error("Unexpected error code {code}: {content}".format(
code=resp.status_code, content=resp.content))
return SERVER_ERROR
data = json.loads(resp.content)
if options.raw:
sys.stdout.write(json.dumps(data, indent=4))
else:
for model_item in data:
model_name = _get_name(model_item['uri'])
sys.stdout.write("{}\n".format(model_name))
return OK
def add_user(server, options, groupname, username):
""" curl -u admin:admin -FaddMembers=testuser1
http://localhost:4502/home/groups/t/testGroup.rw.html """
group_path = get_group_path(groupname)
path = "{}.rw.html".format(group_path)
url = server.url(path)
props = {'addMembers': username}
resp = requests.post(url, auth=server.auth, data=props)
if resp.status_code != 200:
error("Failed to add user: {}".format(resp.content))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
else:
path = html.parse_value(resp.text, 'div', 'Path')
sys.stdout.write("{}\n".format(path))
return OK
def install_package(server, options, package_name):
""" curl -u admin:admin -X POST \
http://localhost:4505/crx/packmgr/service/.json/etc/packages/export/name of package?cmd=install """
url = get_package_url(package_name, server, options)
form_data = dict(cmd="install")
log("Installing package with POST to {}".format(url))
resp = requests.post(url, auth=server.auth, data=form_data)
if resp.status_code != 200:
error("Failed to install package: {}".format(resp.content))
return SERVER_ERROR
data = resp.json()
assert data["success"] is True
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
else:
sys.stdout.write("{}\n".format(data["msg"]))
return OK
def add_user(server, options, groupname, username):
""" curl -u admin:admin -FaddMembers=testuser1
http://localhost:4502/home/groups/t/testGroup.rw.html """
group_path = get_group_path(groupname)
path = "{}.rw.html".format(group_path)
url = server.url(path)
props = {"addMembers": username}
resp = requests.post(url, auth=server.auth, data=props)
if resp.status_code != 200:
error("Failed to add user: {}".format(resp.content))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
else:
tree = html.fromstring(resp.text)
path = tree.xpath('//div[@id="Path"]/text()')[0]
sys.stdout.write("{}\n".format(path))
return OK
def create_group(server, options, name):
""" curl -u admin:admin -FcreateGroup=group1 -FauthorizableId=testGroup1
http://localhost:4502/libs/granite/security/post/authorizables
"""
assert len(name) > 0
form_data = {"createGroup": "", "authorizableId": name}
url = server.url("/libs/granite/security/post/authorizables")
resp = requests.post(url, auth=server.auth, data=form_data)
if resp.status_code != 201:
error("Failed to create group: {}".format(resp.content))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
else:
tree = html.fromstring(resp.text)
path = tree.xpath('//div[@id="Path"]/text()')[0]
sys.stdout.write("{}\n".format(path))
return OK
def list_groups(server, options):
url = server.url("/home/groups.2.json")
resp = requests.get(url, auth=server.auth)
if resp.status_code != 200:
error("Failed to get groups list:\n{}\n".format(resp.content))
return SERVER_ERROR
data = resp.json()
if options.raw:
sys.stdout.write("{}\n".format(json.dumps(data, indent=4)))
elif options.compact:
for initial, group in filter_system(data.items()):
for groupname, userdata in filter_system(group.items()):
sys.stdout.write("{}\n".format(groupname))
else:
sys.stdout.write("Available groups:\n")
for initial, group in filter_system(data.items()):
for username, userdata in filter_system(group.items()):
sys.stdout.write(" {}\n".format(username))
return OK
def create_user(server, options, username):
""" curl -u admin:admin -FcreateUser= -FauthorizableId=testuser -Frep:password=abc123
http://localhost:4502/libs/granite/security/post/authorizables """
assert len(username) > 0
form_data = {
'createUser': '',
'authorizableId': username,
'rep:password': options.password
}
url = server.url('/libs/granite/security/post/authorizables')
resp = requests.post(url, auth=server.auth, data=form_data)
if resp.status_code != 201:
error("Failed to create user: {}".format(resp.content))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
else:
path = html.parse_value(resp.text, 'div', 'Path')
sys.stdout.write("{}\n".format(path))
return OK
def create_group(server, options, name):
""" curl -u admin:admin -FcreateGroup=group1 -FauthorizableId=testGroup1
http://localhost:4502/libs/granite/security/post/authorizables
"""
assert len(name) > 0
form_data = {
'createGroup': '',
'authorizableId': name
}
url = server.url('/libs/granite/security/post/authorizables')
resp = requests.post(url, auth=server.auth, data=form_data)
if resp.status_code != 201:
error("Failed to create group: {}".format(resp.content))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
else:
path = html.parse_value(resp.text, 'div', 'Path')
sys.stdout.write("{}\n".format(path))
return OK
def execute(server, argv):
options, args = parser.parse_args(argv)
action = get_command(args)
actionarg = get_argument(args)
if action == 'list' or action == 'ls':
return list_workflows(server, options)
elif action == 'start':
model = actionarg
if len(args) >= 4:
path = get_argument(args, i=3)
return start_workflow(server, options, model, path)
else:
ret = OK
for path in sys.stdin:
ret = ret | start_workflow(server, options, model, path.strip())
return ret
else:
error('Unknown workflows action {a}\n'.format(a=action))
return USER_ERROR
def start_workflow(server, options, model, path):
task_id = create_task_id(model)
form_data = dict(
model='/etc/workflow/models/{}/jcr:content/model'.format(model),
payload=_asset_path(path),
payloadType='JCR_PATH',
workflowTitle=task_id,
startComment=''
)
log(_asset_path(path))
url = server.url(INSTANCES_PATH)
resp = requests.post(url, auth=server.auth, data=form_data)
if resp.status_code != 201:
error("Unexpected error code {code}: {content}".format(
code=resp.status_code, content=resp.content))
return SERVER_ERROR
output = resp.content if options.raw else task_id
sys.stdout.write("{}\n".format(output))
return OK
def upload_package(server, options, filename):
""" curl -u admin:admin -F file=@"name of zip file" -F name="name of package"
-F force=true -F install=false http://localhost:4505/crx/packmgr/service.jsp """
form_data = dict(
file=(filename, open(filename, "rb"), "application/zip", dict()),
name=filename.rstrip(".zip"),
force=json_bool(options.install),
install=json_bool(options.install),
)
log(form_data)
url = server.url(SERVICE_PATH)
resp = requests.post(url, auth=server.auth, files=form_data)
if resp.status_code != 200:
error("Failed to upload paackage: {}: {}".format(resp.status_code, resp.content))
return SERVER_ERROR
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
else:
tree = ElementTree.fromstring(resp.content)
pkg_elem = tree.find("response").find("data").find("package")
pkg = parse_package(pkg_elem)
sys.stdout.write("{}\n".format(format_package(pkg)))
return OK
def activate(server, options, path):
""" curl -u admin:admin -X POST -F path="/content/path/to/page" -F cmd="activate" http://localhost:4502/bin/replicate.json
"""
url = server.url(SERVICE_PATH)
form_data = dict(cmd='activate',
path=path,
ignoredeactivated='false',
onlymodified='false')
resp = requests.post(url, auth=server.auth, data=form_data)
if not resp.status_code == 200:
error("Failed to perform activation because {}: {}\n".format(resp.status_code, resp.content))
else:
if options.raw:
sys.stdout.write("{}\n".format(resp.content))
else:
tree = html.fromstring(resp.text)
paths = tree.xpath("//body/div/div[@class='path']/text()")
paths = [path.split(' ')[0] for path in paths]
paths = filter(lambda path: path.strip() != '', paths)
msg = '\n'.join(paths)
log("{}".format(msg))
sys.stdout.write("{}\n".format(msg))
def get_server(self, server_name):
if server_name not in self.servers:
error("Server {} not defined in {}; servers={}".format(server_name,get_rcfilename(),self.servers.keys()))
sys.exit(acmd.USER_ERROR)
# server_name = DEFAULT_SERVER_SETTING
return self.servers.get(server_name)
