| | |
| | from __future__ import absolute_import, division, print_function, unicode_literals |
| | from future.utils import raise_from, string_types |
| | from builtins import (bytes, str, open, super, range, |
| | zip, round, input, int, pow, object) |
| |
|
| | import os |
| | import re |
| | import sys |
| | import glob |
| | import subprocess |
| | from itertools import chain |
| |
|
| | if (sys.version_info < (3, 0)) and (os.name == 'nt'): |
| | import gslab_make.private.subprocess_fix as subprocess_fix |
| | else: |
| | import subprocess as subprocess_fix |
| | |
| | import gslab_make.private.messages as messages |
| | import gslab_make.private.metadata as metadata |
| | from gslab_make.private.exceptionclasses import CritError |
| | from gslab_make.private.utility import convert_to_list, norm_path, file_to_array, format_traceback, decode |
| |
|
| |
|
| | class MoveDirective(object): |
| | """ |
| | Directive for creating symbolic link or copy of data. |
| | |
| | Note |
| | ---- |
| | Parse line of text containing linking/copying instructions and represent as directive. |
| | |
| | Note |
| | ---- |
| | Takes glob-style wildcards. |
| | |
| | Parameters |
| | ---------- |
| | file: str |
| | File containing linking/copying instructions (used for error messaging). |
| | raw_line : str |
| | Raw text of line containing linking/copying instructions (used for error messaging). |
| | line : str |
| | Line of text containing linking/copying instructions. |
| | move_dir : str |
| | Directory to write symlink/copy. |
| | osname : str, optional |
| | Name of OS. Defaults to ``os.name``. |
| | |
| | Attributes |
| | ---------- |
| | source : list |
| | List of sources parsed from line. |
| | destination : list |
| | List of destinations parsed from line. |
| | move_list : list |
| | List of (source, destination) mappings parsed from line. |
| | """ |
| | |
| | def __init__(self, raw_line, file, line, move_dir, osname = os.name): |
| | self.raw_line = raw_line |
| | self.file = file |
| | self.line = line |
| | self.move_dir = move_dir |
| | self.osname = osname |
| | self.check_os() |
| | self.get_paths() |
| | self.check_paths() |
| | self.get_move_list() |
| |
|
| | def check_os(self): |
| | """Check OS is either POSIX or NT. |
| | |
| | Returns |
| | ------- |
| | None |
| | """ |
| | |
| | if self.osname not in ['posix', 'nt']: |
| | raise CritError(messages.crit_error_unknown_system % self.osname) |
| |
|
| | def get_paths(self): |
| | """Parse sources and destinations from line. |
| | |
| | Returns |
| | ------- |
| | None |
| | """ |
| | |
| | try: |
| | self.line = self.line.split('|') |
| | self.line = [l.strip() for l in self.line] |
| | self.line = [l.strip('"\'') for l in self.line] |
| | self.destination, self.source = self.line |
| | except Exception: |
| | error_message = messages.crit_error_bad_move % (self.raw_line, self.file) |
| | error_message = error_message + format_traceback() |
| | raise_from(CritError(error_message), None) |
| |
|
| | self.source = norm_path(self.source) |
| | self.destination = norm_path(os.path.join(self.move_dir, self.destination)) |
| |
|
| | def check_paths(self): |
| | """Check sources and destination exist and have same number of wildcards. |
| | |
| | Returns |
| | ------- |
| | None |
| | """ |
| |
|
| | if re.findall('\*', self.source) != re.findall('\*', self.destination): |
| | raise SyntaxError(messages.syn_error_wildcard % (self.raw_line, self.file)) |
| | |
| | if re.search('\*', self.source): |
| | if not glob.glob(self.source): |
| | raise CritError(messages.crit_error_no_path_wildcard % self.source) |
| | else: |
| | if not os.path.exists(self.source): |
| | raise CritError(messages.crit_error_no_path % self.source) |
| |
|
| | def get_move_list(self): |
| | """Interpret wildcards to get list of paths that meet criteria. |
| | |
| | Returns |
| | ------- |
| | None |
| | """ |
| | if re.search('\*', self.source): |
| | self.source_list = glob.glob(self.source) |
| | self.destination_list = [self.extract_wildcards(t) for t in self.source_list] |
| | self.destination_list = [self.fill_in_wildcards(s) for s in self.destination_list] |
| | else: |
| | self.source_list = [self.source] |
| | self.destination_list = [self.destination] |
| |
|
| | self.move_list = list(zip(self.source_list, self.destination_list)) |
| |
|
| | def extract_wildcards(self, f): |
| | """Extract wildcard characters from source path. |
| | |
| | Notes |
| | ----- |
| | Suppose path ``foo.py`` and glob pattern ``*.py``. |
| | The wildcard characters would therefore be ``foo``. |
| | |
| | Parameters |
| | ---------- |
| | f : str |
| | Source path from which to extract wildcard characters. |
| | |
| | Returns |
| | ------- |
| | wildcards : iter |
| | Iterator of extracted wildcard characters. |
| | """ |
| | |
| | regex = re.escape(self.source) |
| | regex = regex.split('\*') |
| | regex = '(.*)'.join(regex) |
| |
|
| | wildcards = re.findall(regex, f) |
| | wildcards = [(w, ) if isinstance(w, string_types) else w for w in wildcards] |
| | wildcards = chain(*wildcards) |
| |
|
| | return(wildcards) |
| |
|
| | def fill_in_wildcards(self, wildcards): |
| | """Fill in wildcards for destination path. |
| | |
| | Notes |
| | ----- |
| | Use extracted wildcard characters from a source path to create |
| | corresponding destination path. |
| | |
| | Parameters |
| | ---------- |
| | wildcards: iterator |
| | Extracted wildcard characters (returned from :func:`.extract_wildcards`). |
| | |
| | Returns |
| | ------- |
| | f : str |
| | Destination path |
| | """ |
| | |
| | f = self.destination |
| | for w in wildcards: |
| | f = re.sub('\*', w, f, 1) |
| |
|
| | return(f) |
| |
|
| | def create_symlinks(self): |
| | """Create symlinks. |
| | |
| | Returns |
| | ------- |
| | None |
| | """ |
| | |
| | if self.osname == 'posix': |
| | self.move_posix(movetype = 'symlink') |
| | elif self.osname == 'nt': |
| | self.move_nt(movetype = 'symlink') |
| |
|
| | return(self.move_list) |
| |
|
| | def create_copies(self): |
| | """Create copies. |
| | |
| | Returns |
| | ------- |
| | None |
| | """ |
| | |
| | if self.osname == 'posix': |
| | self.move_posix(movetype = 'copy') |
| | elif self.osname == 'nt': |
| | self.move_nt(movetype = 'copy') |
| |
|
| | return(self.move_list) |
| |
|
| | def move_posix(self, movetype): |
| | """Create symlinks/copies using POSIX shell command specified in metadata. |
| | |
| | Parameters |
| | ---------- |
| | movetype : str |
| | Type of file movement. Takes either ``'copy'`` or ``'symlink'``. |
| | |
| | Returns |
| | ------- |
| | None |
| | """ |
| | |
| | for source, destination in self.move_list: |
| | if movetype == 'copy': |
| | command = metadata.commands[self.osname]['makecopy'] % (source, destination) |
| | elif movetype == 'symlink': |
| | command = metadata.commands[self.osname]['makelink'] % (source, destination) |
| |
|
| | process = subprocess_fix.Popen(command, |
| | shell = True, |
| | stdout = subprocess.PIPE, |
| | stderr = subprocess.PIPE, |
| | universal_newlines = True) |
| | process.wait() |
| | stdout, stderr = process.communicate() |
| | |
| | if process.returncode != 0: |
| | error_message = messages.crit_error_move_command % command |
| | error_message = error_message + format_traceback(stderr) |
| | raise CritError(error_message) |
| |
|
| |
|
| | def move_nt(self, movetype): |
| | """Create symlinks/copies using NT shell command specified in metadata. |
| | |
| | Parameters |
| | ---------- |
| | movetype : str |
| | Type of file movement. Takes either ``'copy'`` or ``'symlink'``. |
| | |
| | Returns |
| | ------- |
| | None |
| | """ |
| | for source, destination in self.move_list: |
| | if os.path.isdir(source): |
| | link_option = '/d' |
| | copy_option = '' |
| | elif os.path.isfile(source): |
| | link_option = '' |
| | copy_option = 'cmd /c echo F | ' |
| |
|
| | if movetype == 'copy': |
| | command = metadata.commands[self.osname]['makecopy'] % (copy_option, source, destination) |
| | elif movetype == 'symlink': |
| | command = metadata.commands[self.osname]['makelink'] % (link_option, destination, source) |
| |
|
| | process = subprocess_fix.Popen(command, |
| | shell = True, |
| | stdout = subprocess.PIPE, |
| | stderr = subprocess.PIPE, |
| | universal_newlines = True) |
| | process.wait() |
| | stdout, stderr = process.communicate() |
| | |
| | if process.returncode != 0: |
| | error_message = messages.crit_error_move_command % command |
| | error_message = error_message + format_traceback(stderr) |
| | raise CritError(error_message) |
| |
|
| |
|
| | class MoveList(object): |
| | """ |
| | List of move directives. |
| | |
| | Notes |
| | ----- |
| | Parse files containing linking/copying instructions and represent as move directives. |
| | |
| | Parameters |
| | ---------- |
| | file_list : list |
| | List of files from which to parse linking/copying instructions. |
| | move_dir : str |
| | Directory to write symlink/copy. |
| | mapping_dict : dict, optional |
| | Dictionary of path mappings used to parse linking/copying instructions. |
| | Defaults to no mappings. |
| | |
| | Attributes |
| | ---------- |
| | move_directive_list : list |
| | List of move directives. |
| | """ |
| | |
| | def __init__(self, |
| | file_list, |
| | move_dir, |
| | mapping_dict = {}): |
| | |
| | self.file_list = file_list |
| | self.move_dir = move_dir |
| | self.mapping_dict = mapping_dict |
| | self.parse_file_list() |
| | self.get_paths() |
| | self.get_move_directive_list() |
| |
|
| | def parse_file_list(self): |
| | """Parse wildcards in list of files. |
| | |
| | Returns |
| | ------- |
| | None |
| | """ |
| |
|
| | if self.file_list: |
| | self.file_list = convert_to_list(self.file_list, 'file') |
| | self.file_list = [norm_path(file) for file in self.file_list] |
| | |
| | file_list_parsed = [f for file in self.file_list for f in glob.glob(file)] |
| | if file_list_parsed: |
| | self.file_list = file_list_parsed |
| | else: |
| | error_list = [decode(f) for f in self.file_list] |
| | raise CritError(messages.crit_error_no_files % error_list) |
| |
|
| | def get_paths(self): |
| | """Normalize paths. |
| | |
| | Returns |
| | ------- |
| | None |
| | """ |
| | |
| | self.move_dir = norm_path(self.move_dir) |
| | self.file_list = [norm_path(f) for f in self.file_list] |
| |
|
| | def get_move_directive_list(self): |
| | """Parse list of files to create symlink directives. |
| | |
| | Returns |
| | ------- |
| | None |
| | """ |
| | lines = [] |
| | for file in self.file_list: |
| | for raw_line in file_to_array(file): |
| | try: |
| | line = raw_line.format(**self.mapping_dict) |
| | lines.append((file, raw_line, line)) |
| | except KeyError as e: |
| | key = decode(e).lstrip("u'").rstrip("'") |
| | error_message = messages.crit_error_path_mapping % (key, key, file, raw_line, key) |
| | error_message = error_message + format_traceback() |
| | raise_from(CritError(error_message), None) |
| |
|
| | self.move_directive_list = [MoveDirective(file, raw_line, line, self.move_dir) for (file, raw_line, line) in lines] |
| |
|
| | def create_symlinks(self): |
| | """Create symlinks according to directives. |
| | |
| | Returns |
| | ------- |
| | move_map : list |
| | List of (source, destination) for each symlink created. |
| | """ |
| | |
| | move_map = [] |
| | for move in self.move_directive_list: |
| | move_map.extend(move.create_symlinks()) |
| | |
| | return(move_map) |
| |
|
| | def create_copies(self): |
| | """Create copies according to directives. |
| | |
| | Returns |
| | ------- |
| | move_map : list |
| | List of (source, destination) for each copy created. |
| | """ |
| | |
| | move_map = [] |
| | for move in self.move_directive_list: |
| | move_map.extend(move.create_copies()) |
| | |
| | return(move_map) |
