def write_manifest(spec): manifest_file = os.path.join(spec.prefix, spack.store.layout.metadata_dir, spack.store.layout.manifest_file_name) if not os.path.exists(manifest_file): tty.debug("Writing manifest file: No manifest from binary") manifest = {} for root, dirs, files in os.walk(spec.prefix): for entry in list(dirs + files): path = os.path.join(root, entry) manifest[path] = create_manifest_entry(path) manifest[spec.prefix] = create_manifest_entry(spec.prefix) with open(manifest_file, 'w') as f: sjson.dump(manifest, f) fp.set_permissions_by_spec(manifest_file, spec)
def post_install(spec): if not spec.external: fp.set_permissions_by_spec(spec.prefix, spec) # os.walk explicitly set not to follow links for root, dirs, files in os.walk(spec.prefix, followlinks=False): for d in dirs: if not os.path.islink(os.path.join(root, d)): fp.set_permissions_by_spec(os.path.join(root, d), spec) for f in files: if not os.path.islink(os.path.join(root, f)): fp.set_permissions_by_spec(os.path.join(root, f), spec)
def write(self, overwrite=False): """Writes the module file. Args: overwrite (bool): if True it is fine to overwrite an already existing file. If False the operation is skipped an we print a warning to the user. """ # Return immediately if the module is blacklisted if self.conf.blacklisted: msg = '\tNOT WRITING: {0} [BLACKLISTED]' tty.debug(msg.format(self.spec.cshort_spec)) return # Print a warning in case I am accidentally overwriting # a module file that is already there (name clash) if not overwrite and os.path.exists(self.layout.filename): message = 'Module file already exists : skipping creation\n' message += 'file : {0.filename}\n' message += 'spec : {0.spec}' tty.warn(message.format(self.layout)) return # If we are here it means it's ok to write the module file msg = '\tWRITE: {0} [{1}]' tty.debug(msg.format(self.spec.cshort_spec, self.layout.filename)) # If the directory where the module should reside does not exist # create it module_dir = os.path.dirname(self.layout.filename) if not os.path.exists(module_dir): llnl.util.filesystem.mkdirp(module_dir) # Get the template for the module template_name = self._get_template() import jinja2 try: env = tengine.make_environment() template = env.get_template(template_name) except jinja2.TemplateNotFound: # If the template was not found raise an exception with a little # more information msg = 'template \'{0}\' was not found for \'{1}\'' name = type(self).__name__ msg = msg.format(template_name, name) raise ModulesTemplateNotFoundError(msg) # Construct the context following the usual hierarchy of updates: # 1. start with the default context from the module writer class # 2. update with package specific context # 3. update with 'modules.yaml' specific context context = self.context.to_dict() # Attribute from package module_name = str(self.module.__name__).split('.')[-1] attr_name = '{0}_context'.format(module_name) pkg_update = getattr(self.spec.package, attr_name, {}) context.update(pkg_update) # Context key in modules.yaml conf_update = self.conf.context context.update(conf_update) # Render the template text = template.render(context) # Write it to file with open(self.layout.filename, 'w') as f: f.write(text) # Set the file permissions of the module to match that of the package if os.path.exists(self.layout.filename): fp.set_permissions_by_spec(self.layout.filename, self.spec)