| |
| 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) |
