def disable(context, args):
group = context.resource_groups.get(args.resource_group)
if not group.is_enabled:
raise HandledError('The {} resource group is not enabled.'.format(group.name))
util.validate_writable_list(context, [ context.config.local_project_settings.path ])
group.disable()
context.view.resource_group_disabled(group.name)
def validate_writable(self, path):
if not self.is_writable(path):
if self.no_prompt:
raise HandledError('File Not Writable: {}'.format(path))
writable_list = []
writable_list.append(path)
util.validate_writable_list(self.context, writable_list)
return self.is_writable(path)
def write_to_project_file(context, pools):
pools_file = context.config.join_aws_directory_path(
constant.COGNITO_POOLS_FILENAME)
existing_pools = util.load_json(pools_file, optional=True, default=None)
if existing_pools is None:
existing_pools = {}
changes = __merge_common_groups(pools, existing_pools)
changes = changes or __add_new_groups(pools, existing_pools)
if changes:
util.validate_writable_list(context, [pools_file])
with open(pools_file, 'w') as outfile:
json.dump(existing_pools, outfile, indent=4)
def disable_gem(self, gem_name, lmbr_exe_path_override=None):
# verify files are writable
if not util.validate_writable_list(self.__context,
[self.get_gems_file_path()]):
return False
# call lmbr.exe to disable the gem
lmbr_exe_path = self.__get_lmbr_exe_path(lmbr_exe_path_override)
args = [
self.__lmbr_exe_path, 'gems', 'disable',
self.__context.config.game_directory_name, gem_name
]
try:
self.__execute(args)
except Exception as e:
raise HandledError('Gem {} disable failed.'.format(gem_name))
# remove from gem list and resource group list, if needed
gem = self.get_by_name(gem_name)
if gem in self.__enabled_gems:
self.__enabled_gems.remove(gem)
self.__context.resource_groups.remove_resource_group(gem)
# all done
self.__context.view.gem_disabled(gem_name)
def enable_gem(self, gem_name, lmbr_exe_path_override=None):
# verify files are writable
if not util.validate_writable_list(self.__context,
[self.get_gems_file_path()]):
return False
# call lmbr.exe to enable the gem
lmbr_exe_path = self.__get_lmbr_exe_path(lmbr_exe_path_override)
args = [
lmbr_exe_path, 'gems', 'enable',
self.__context.config.game_directory_name, gem_name
]
try:
self.__execute(args)
except Exception as e:
raise HandledError('Gem enable failed. {}'.format(e.message))
# add the gem to list of gems, and load as resource group if needed
gems_file_content = self.__get_gems_file_content()
for gem_file_entry in gems_file_content.get('Gems', []):
if gem_file_entry.get('_comment') == gem_name:
directory_path = self.__get_gem_root_directory_path_from_gems_file_entry(
gem_file_entry)
gem = self.__add_gem(directory_path, is_enabled=True)
self.__add_gem_to_resource_groups(gem)
break
# all done
self.__context.view.gem_enabled(gem_name)
def create_gem(
self,
gem_name,
initial_content = 'empty',
enable = False,
asset_only = False,
version = '1.0.0',
relative_directory_path = None,
lmbr_exe_path_override = None,
no_sln_change = False):
# Validate arguments
try:
util.validate_stack_name(gem_name)
except HandledError as e:
raise HandledError('The gem name is not valid for use as a Cloud Gem. {}.'.format(e))
if initial_content not in self.initial_content_list:
raise HandledError('Invalid initial content: {}. Valid initial content values are {}.'.format(initial_content, ', '.join(self.initial_content_list)))
# Validate files are writable
writable_file_list = []
if enable:
writable_file_list.append(self.get_gems_file_path())
if writable_file_list:
if not util.validate_writable_list(self.__context, writable_file_list):
return
# Create the gem...
root_directory_path = self.__do_lmbr_gems_create(lmbr_exe_path_override, gem_name, relative_directory_path, asset_only, version)
# Add the framework dependency
self.__add_framework_gem_dependency(root_directory_path)
# Copy initial gem content...
self.__copy_initial_gem_content(gem_name, root_directory_path, initial_content, no_sln_change)
# Set the c++ build configuration for the gem.
if not asset_only:
self.__setup_cloud_gem_cpp_build(root_directory_path, gem_name, initial_content)
# Add gem to collections...
gem = self.__add_gem(root_directory_path, enable)
# Tell them about it, then go on to enable if requested...
self.__context.view.gem_created(gem_name, root_directory_path)
if enable:
self.enable_gem(gem_name, lmbr_exe_path_override)
def update_framework_version(context, args):
current_framework_version = context.config.framework_version
if context.gem.framework_gem.version == current_framework_version:
raise HandledError(
'The framework version used by the project is already {}, the same version as the enabled CloudGemFramework gem.'
.format(current_framework_version))
# Project settings writable?
writable_file_paths = set([context.config.local_project_settings.path])
context.hooks.call_module_handlers(
'resource-manager-code/update.py',
'add_framework_version_update_writable_files',
kwargs={
'from_version': current_framework_version,
'to_version': context.gem.framework_gem.version,
'writable_file_paths': writable_file_paths
})
if not util.validate_writable_list(context, writable_file_paths):
return
context.view.updating_framework_version(current_framework_version,
context.gem.framework_gem.version)
context.config.set_pending_framework_version(
context.gem.framework_gem.version)
context.hooks.call_module_handlers('resource-manager-code/update.py',
'before_framework_version_updated',
kwargs={
'from_version':
current_framework_version,
'to_version':
context.gem.framework_gem.version
})
if context.config.project_initialized:
# Is it ok to do this?
pending_resource_status = __get_pending_resource_status(context)
capabilities = context.stack.confirm_stack_operation(
context.config.project_stack_id, 'project stack', args,
pending_resource_status)
__update_project_stack(context, pending_resource_status, capabilities,
args)
context.hooks.call_module_handlers('resource-manager-code/update.py',
'after_framework_version_updated',
kwargs={
'from_version':
current_framework_version,
'to_version':
context.gem.framework_gem.version
})
context.config.save_pending_framework_version()
def create_and_validate_writable_list(context):
write_check_list = gather_writable_check_list(context)
util.validate_writable_list(context, write_check_list)
